@mediusinc/mng-commons 5.0.0-rc.0-c31d5206 → 5.0.0-rc.0

package/esm2022/core/data-list/data-list-params.util.mjs

@@ -0,0 +1,417 @@
+import { CommonsInternalError } from '../error/error.model';
+import { DateUtil } from '../utils/date.util';
+import { FilterMatchMode } from './filter-match.model';
+export class DataListParamsUtil {
+    /**
+     * Converts a TableLazyLoadEvent to DataListParams.
+     *
+     * @param {TableLazyLoadEvent} event - The event containing the data to convert.
+     * @return {DataListParams} - The converted DataListParams object.
+     */
+    static fromPrimeTableLoad(event) {
+        const params = {};
+        if (event.first != null) {
+            params.offset = event.first;
+        }
+        if (event.rows != null) {
+            params.limit = event.rows;
+        }
+        if (typeof event.globalFilter === 'string') {
+            params.search = event.globalFilter;
+        }
+        else if (Array.isArray(event.globalFilter) && event.globalFilter.length > 0) {
+            params.search = event.globalFilter.join(',');
+        }
+        if (Array.isArray(event.multiSortMeta) && event.multiSortMeta.length > 0) {
+            params.sort = event.multiSortMeta.map(m => ({ property: m.field, ascending: m.order >= 0 }));
+        }
+        if (event.filters) {
+            params.filters = Object.keys(event.filters).reduce((acc, key) => {
+                const filter = {};
+                const eventFilter = event.filters?.[key];
+                if (Array.isArray(eventFilter)) {
+                    filter.value = eventFilter[0].value;
+                    filter.matchMode = eventFilter[0].matchMode;
+                }
+                else if (eventFilter !== undefined) {
+                    filter.value = eventFilter.value;
+                    filter.matchMode = eventFilter.matchMode;
+                }
+                return { ...acc, [key]: filter };
+            }, {});
+        }
+        return params;
+    }
+    /**
+     * Converts the given parameters to URL query parameters.
+     * Sorts are formatted in Medius data API sort query language: `asc:prop1,desc:prop2`, ...
+     * Filter keys are "flattened" in the new object, values are formatted in Medius data API filter query language: `cs:eq:asd`, `in:asd,qwe`, `ex`, ...
+     *
+     * @param {DataListParams} params - The parameters to convert.
+     * @param {DataListParams|null} defaults - The default parameters used if no matching property in params is available. Defaults to { limit: 25, offset: 0 } if not provided.
+     * @returns {Params} - The URL query parameters object.
+     */
+    static toUrlQueryParams(params, defaults = {
+        limit: 25,
+        offset: 0
+    }) {
+        const urlParams = {};
+        if (params.limit && params.limit !== defaults?.limit) {
+            urlParams['limit'] = params.limit;
+        }
+        if (params.offset && params.offset !== defaults?.offset) {
+            urlParams['offset'] = params.offset;
+        }
+        if (params.search && params.search !== defaults?.search) {
+            urlParams['q'] = params.search;
+        }
+        if (params.sort && Array.isArray(params.sort) && params.sort.length > 0) {
+            if (defaults?.sort == null ||
+                !Array.isArray(defaults.sort) ||
+                defaults.sort.length === 0 ||
+                params.sort.length !== defaults.sort.length ||
+                defaults.sort.some((ds, idx) => ds.property !== params.sort[idx].property || (ds.ascending ?? true) !== (params.sort[idx].ascending ?? true))) {
+                urlParams['sort'] = DataListParamsUtil.sortToUrlQuery(params);
+            }
+        }
+        if (params.filters) {
+            Object.keys(params.filters).forEach(k => {
+                const paramFilter = params.filters[k];
+                const defaultFilter = defaults?.filters?.[k];
+                if (defaultFilter &&
+                    ((Array.isArray(defaultFilter.value) &&
+                        Array.isArray(paramFilter.value) &&
+                        defaultFilter.value.length === paramFilter.value.length &&
+                        defaultFilter.value.every((v, idx) => {
+                            const value = paramFilter.value[idx];
+                            if (value instanceof Date && v instanceof Date)
+                                return value.getTime() === v.getTime();
+                            else
+                                return value === v;
+                        })) || // handle arrays
+                        defaultFilter.value === paramFilter.value) &&
+                    defaultFilter.matchMode === paramFilter.matchMode &&
+                    (defaultFilter.caseSensitive ?? false) === (paramFilter.caseSensitive ?? false)) {
+                    return;
+                }
+                if (paramFilter.value == null && defaultFilter?.value == null) {
+                    return;
+                }
+                urlParams[k] = DataListParamsUtil.paramsFilterToUrlQuery(params, k, true);
+            });
+        }
+        if (defaults?.filters) {
+            // add other defaults
+            const paramFilterKeys = params.filters ? Object.keys(params.filters) : [];
+            Object.keys(defaults.filters)
+                .filter(k => paramFilterKeys.indexOf(k) < 0)
+                .forEach(k => {
+                urlParams[k] = DataListParamsUtil.paramsFilterToUrlQuery(defaults, k);
+            });
+        }
+        return urlParams;
+    }
+    /**
+     * Merges the provided parameters with default values and returns the merged object.
+     *
+     * @param {DataListParams} params - The parameters to merge with defaults.
+     * @param {DataListParams} defaults - The default values to merge with params (optional, default is { limit: 25, offset: 0 }).
+     * @returns {DataListParams} - The merged parameters object.
+     */
+    static mergeWithDefaults(params, defaults = {
+        limit: 25,
+        offset: 0
+    }) {
+        const merged = {
+            limit: params.limit ?? defaults.limit,
+            offset: params.offset ?? defaults.offset,
+            search: params.search ?? defaults.search,
+            sort: (params.sort ?? defaults.sort)?.map(s => ({ ...s }))
+        };
+        if (params.filters) {
+            merged.filters = {};
+            Object.entries(params.filters).forEach(([key, value]) => (merged.filters[key] = { ...value }));
+        }
+        if (defaults.filters) {
+            if (!merged.filters)
+                merged.filters = {};
+            Object.entries(defaults.filters).forEach(([key, value]) => {
+                if (merged.filters[key] === undefined) {
+                    merged.filters[key] = { ...value };
+                }
+            });
+        }
+        return merged;
+    }
+    /**
+     * Converts an object of parameters to a URL query string for sorting.
+     * Sorts are formatted in Medius data API sort query language: `asc:prop1,desc:prop2`, ...
+     *
+     * @param {DataListParams} params - An optional object containing sort parameters.
+     * @returns A string representing the URL query or undefined if no sort parameters are provided.
+     */
+    static sortToUrlQuery(params) {
+        return params && Array.isArray(params.sort)
+            ? params.sort.map(s => `${s.ascending === true || s.ascending === undefined ? 'asc' : 'desc'}:${String(s.property)}`).join(',')
+            : undefined;
+    }
+    /**
+     * Converts a specific filter parameter (by key) from DataListParams object to a URL query string.
+     * Filter keys are "flattened" in the new object, values are formatted in Medius data API filter query language: `cs:eq:asd`, `in:asd,qwe`, `ex`, ...
+     *
+     * @param {DataListParams<any, Filters> | undefined} params - The DataListParams object containing the filters.
+     * @param {Filters} key - The key of the filter to convert.
+     * @param {boolean} [allowNull=false] - Indicates whether to allow null values in the query string.
+     * @return {string | undefined} - The URL query string representing the specified filter, or undefined if the filter is not found.
+     */
+    static paramsFilterToUrlQuery(params, key, allowNull = false) {
+        const paramFilter = params?.filters?.[key];
+        return DataListParamsUtil.filterToUrlQuery(paramFilter, allowNull);
+    }
+    /**
+     * Converts a filter to a URL query string.
+     * Filter keys are "flattened" in the new object, values are formatted in Medius data API filter query language: `cs:eq:asd`, `in:asd,qwe`, `ex`, ...
+     *
+     * @param {DataListFilter} paramFilter - The filter object to be converted.
+     * @param {boolean} [allowNull=false] - Indicates whether to allow null values in the filter.
+     * @returns {string|undefined} - The filter converted to a URL query string, or undefined if no filter is provided or the filter has empty or invalid values.
+     * @throws {CommonsInternalError} - If the filter has invalid values.
+     */
+    static filterToUrlQuery(paramFilter, allowNull = false) {
+        const filterValueAsArray = Array.isArray(paramFilter?.value) ? paramFilter.value.filter(v => v !== undefined && (allowNull || v !== null)) : undefined;
+        if (paramFilter === undefined ||
+            (!allowNull && paramFilter.value == null) ||
+            (typeof paramFilter.value === 'string' && paramFilter.value.length === 0) ||
+            (Array.isArray(filterValueAsArray) && filterValueAsArray.length === 0)) {
+            // no need to include filters for empty values
+            return undefined;
+        }
+        const matchMode = paramFilter.matchMode ?? FilterMatchMode.Equals;
+        if (matchMode === FilterMatchMode.Between && !(Array.isArray(filterValueAsArray) && filterValueAsArray.length === 2)) {
+            throw new CommonsInternalError(`Filter match mode between requires exactly 2 values: ${paramFilter.value}`);
+        }
+        if ((matchMode === FilterMatchMode.In || matchMode === FilterMatchMode.NotIn) && (!Array.isArray(filterValueAsArray) || filterValueAsArray.length === 0)) {
+            throw new CommonsInternalError(`Filter match mode ${matchMode} requires non-empty array: ${paramFilter.value}`);
+        }
+        if ([FilterMatchMode.In, FilterMatchMode.NotIn, FilterMatchMode.Between].indexOf(matchMode) === -1 && Array.isArray(filterValueAsArray)) {
+            throw new CommonsInternalError(`Filter match mode ${matchMode} must not be array: ${paramFilter.value}`);
+        }
+        const noVal = paramFilter.matchMode === FilterMatchMode.Exists || paramFilter.matchMode === FilterMatchMode.DoesNotExist;
+        const urlValuePart = noVal ? '' : `:${DataListParamsUtil.filterValueToUrlParam(filterValueAsArray ?? paramFilter.value, allowNull)}`;
+        return `${paramFilter.caseSensitive ? 'cs:' : paramFilter.caseSensitive === false ? 'ci:' : ''}${FilterMatchMode.getAbbreviation(matchMode) ?? matchMode}${urlValuePart}`;
+    }
+    /**
+     * Converts URL query parameters to a DataListParams object.
+     * Sorts are formatted from Medius data API sort query language: `asc:prop1,desc:prop2`, ...
+     * Filter keys are all keys in Params object that are not matched elsewhere, values are formatted from Medius data API filter query language: `cs:eq:asd`, `in:asd,qwe`, `ex`, ...
+     *
+     * @param {Params} urlParams - The URL query parameters.
+     * @return {DataListParams} - The converted DataListParams object.
+     */
+    static fromUrlQueryParams(urlParams) {
+        const params = {};
+        Object.entries(urlParams).forEach(([urlParamKey, urlParamValue]) => {
+            if (urlParamKey === 'limit') {
+                params.limit = +urlParamValue;
+                if (isNaN(params.limit) || params.limit < 0) {
+                    delete params.limit;
+                }
+            }
+            else if (urlParamKey === 'offset') {
+                params.offset = +urlParamValue;
+                if (isNaN(params.offset) || params.offset < 0) {
+                    delete params.offset;
+                }
+            }
+            else if (urlParamKey === 'q') {
+                params.search = urlParamValue;
+            }
+            else if (urlParamKey === 'sort') {
+                if (typeof urlParamValue === 'string') {
+                    params.sort = urlParamValue.split(',').map(s => {
+                        const [direction, property] = s.split(':');
+                        return { property: (property ?? direction), ascending: direction !== 'desc' };
+                    });
+                }
+                else {
+                    throw new CommonsInternalError(`String is expected as value for '${urlParamKey}' when converting from urlParams`);
+                }
+            }
+            else if (typeof urlParamValue === 'string') {
+                if (urlParamValue.length === 0) {
+                    // empty string should be ignored
+                    return;
+                }
+                const filterParts = urlParamValue.split(':');
+                let partIdx = 0;
+                // case sensitive
+                let caseSensitive = undefined;
+                if (filterParts[partIdx] === 'cs' || filterParts[partIdx] === 'ci') {
+                    caseSensitive = filterParts[partIdx++] === 'cs';
+                }
+                // match mode
+                const matchMode = filterParts[partIdx] ? FilterMatchMode.fromAbbreviation(filterParts[partIdx]) ?? filterParts[partIdx] : FilterMatchMode.Equals;
+                partIdx++;
+                const noVal = matchMode === FilterMatchMode.Exists || matchMode === FilterMatchMode.DoesNotExist;
+                // value
+                let value = undefined;
+                if (!noVal) {
+                    if (filterParts.length < 2) {
+                        return;
+                    }
+                    if (partIdx === filterParts.length - 1) {
+                        value = filterParts[partIdx];
+                    }
+                    else if (partIdx < filterParts.length) {
+                        // array that should not be array, so join back together
+                        value = filterParts.slice(partIdx, filterParts.length).join(':');
+                    }
+                    if (value === undefined && matchMode !== FilterMatchMode.Exists && matchMode !== FilterMatchMode.DoesNotExist) {
+                        // if value undefined and match mode expects value, then skip
+                        return;
+                    }
+                    if (value === 'null') {
+                        value = null;
+                    }
+                    if ((matchMode === FilterMatchMode.In || matchMode === FilterMatchMode.NotIn || matchMode === FilterMatchMode.Between) && typeof value === 'string') {
+                        let arrayVal = [];
+                        // these match modes expect array
+                        if (value.indexOf('"') >= 0) {
+                            const tokens = [];
+                            let currentToken = '';
+                            let explicitQuotes = false; //token is quoted, e.g. in:1,2,"22""",",123"""
+                            let quotesOpened = false; //token has started processing
+                            let quotesExplicitlyClosed = false; //token processing has finished, after single " in quoted mode, or before , in not quoted
+                            for (let i = 0; i < value.length; i++) {
+                                const c = value[i];
+                                // reset the tokenizer when seeing the token separator
+                                // only if either:
+                                // the quotes have not been opened yet (when there are no characters between separators),
+                                // the token has been explicitly closed (when we actually have explicit opening i.e., quotes as the first character)
+                                // or we have implicit quotes (i.e., quotes are not the first character)
+                                if (c === ',' && (!quotesOpened || quotesExplicitlyClosed || !explicitQuotes)) {
+                                    tokens.push(currentToken);
+                                    currentToken = '';
+                                    quotesOpened = false;
+                                    quotesExplicitlyClosed = false;
+                                    explicitQuotes = false;
+                                }
+                                else if (c == '"') {
+                                    // escaped double-quotes
+                                    if (explicitQuotes && i + 1 < value.length && value[i + 1] === '"') {
+                                        currentToken += c; // Append one double-quote to the current token
+                                        i++; // Skip the next double-quote
+                                    }
+                                    // we encounter quotes again after they were the first character => we close the token
+                                    else if (explicitQuotes) {
+                                        quotesExplicitlyClosed = true;
+                                    }
+                                    // implicit quotes
+                                    else if (quotesOpened) {
+                                        currentToken += c;
+                                    }
+                                    // quotes are the first character => explicitly open the token
+                                    else {
+                                        currentToken = '';
+                                        quotesOpened = true;
+                                        explicitQuotes = true;
+                                    }
+                                }
+                                else {
+                                    if (quotesExplicitlyClosed) {
+                                        return;
+                                    }
+                                    quotesOpened = true;
+                                    currentToken += c;
+                                }
+                            }
+                            if (quotesOpened && !quotesExplicitlyClosed && explicitQuotes) {
+                                return;
+                            }
+                            // Append the last token after the loop ends
+                            tokens.push(currentToken.toString());
+                            arrayVal = tokens;
+                        }
+                        else {
+                            arrayVal = value.split(',');
+                        }
+                        if (matchMode === FilterMatchMode.Between && arrayVal.length !== 2) {
+                            return;
+                        }
+                        value = arrayVal;
+                    }
+                    if ((typeof value === 'string' && value.length === 0) || (Array.isArray(value) && value.length === 0)) {
+                        // filter with empty value is to be ignored
+                        return;
+                    }
+                }
+                else {
+                    caseSensitive = undefined;
+                }
+                if (!params.filters) {
+                    params.filters = {};
+                }
+                params.filters[urlParamKey] = { value: value, matchMode: matchMode, caseSensitive: caseSensitive };
+            }
+        });
+        return params;
+    }
+    /**
+     * Makes a copy of the given DataListParams object.
+     *
+     * @param {DataListParams<Sorts, Filters>} params - The DataListParams object to be copied.
+     * @returns {DataListParams<Sorts, Filters>} - Returns a new copy of the DataListParams object.
+     */
+    static copy(params) {
+        const copy = {
+            offset: params.offset,
+            limit: params.limit,
+            search: params.search
+        };
+        if (params.sort) {
+            copy.sort = params.sort?.map(s => ({ ...s }));
+        }
+        if (params.filters) {
+            copy.filters = Object.entries(params.filters).reduce((acc, [key, value]) => {
+                const filterValue = value;
+                return {
+                    ...acc,
+                    [key]: {
+                        ...filterValue,
+                        value: Array.isArray(filterValue.value) ? [...filterValue.value] : filterValue.value
+                    }
+                };
+            }, {});
+        }
+        return copy;
+    }
+    /**
+     * Converts a value to a URL query param string representation.
+     *
+     * @param {unknown} value - The value to be converted.
+     * @param {boolean} [allowNull=false] - Indicates whether null values are allowed.
+     * @returns {string} The URL parameter representation of the value.
+     * @throws {CommonsInternalError} If an undefined value is passed without allowNull set to true.
+     * @throws {CommonsInternalError} If the value is an object (excluding Date).
+     */
+    static filterValueToUrlParam(value, allowNull = false) {
+        if (value === null && allowNull)
+            return 'null';
+        if (value == null)
+            throw new CommonsInternalError('Undefined value cannot be converted to url param.'); // this should not happen, should be filtered out earlier
+        if (Array.isArray(value))
+            return value
+                .map(v => DataListParamsUtil.filterValueToUrlParam(v, allowNull))
+                .map(v => (v.indexOf(',') >= 0 || v.indexOf('"') >= 0 ? `"${v.replaceAll('"', '""')}"` : v))
+                .join(',');
+        if (typeof value === 'object') {
+            if (value instanceof Date)
+                return DateUtil.toIsoString(value, 'dateTime', { utc: true });
+            else {
+                throw new CommonsInternalError('Filter value cannot be object');
+            }
+        }
+        return String(value);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"data-list-params.util.js","sourceRoot":"","sources":["../../../../core/src/data-list/data-list-params.util.ts"],"names":[],"mappings":"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","sourcesContent":["import {Params} from '@angular/router';\n\nimport {TableLazyLoadEvent} from 'primeng/table';\n\nimport {CommonsInternalError} from '../error/error.model';\nimport {DateUtil} from '../utils/date.util';\nimport {DataListFilter, DataListFilterValueType, DataListFiltersType, DataListParams} from './data-list.model';\nimport {FilterMatchMode} from './filter-match.model';\n\nexport class DataListParamsUtil {\n    /**\n     * Converts a TableLazyLoadEvent to DataListParams.\n     *\n     * @param {TableLazyLoadEvent} event - The event containing the data to convert.\n     * @return {DataListParams} - The converted DataListParams object.\n     */\n    public static fromPrimeTableLoad(event: TableLazyLoadEvent): DataListParams {\n        const params: DataListParams = {};\n\n        if (event.first != null) {\n            params.offset = event.first;\n        }\n        if (event.rows != null) {\n            params.limit = event.rows;\n        }\n\n        if (typeof event.globalFilter === 'string') {\n            params.search = event.globalFilter;\n        } else if (Array.isArray(event.globalFilter) && event.globalFilter.length > 0) {\n            params.search = event.globalFilter.join(',');\n        }\n\n        if (Array.isArray(event.multiSortMeta) && event.multiSortMeta.length > 0) {\n            params.sort = event.multiSortMeta.map(m => ({property: m.field, ascending: m.order >= 0}));\n        }\n\n        if (event.filters) {\n            params.filters = Object.keys(event.filters).reduce((acc, key) => {\n                const filter: DataListFilter = {};\n                const eventFilter = event.filters?.[key as keyof object];\n                if (Array.isArray(eventFilter)) {\n                    filter.value = eventFilter[0].value;\n                    filter.matchMode = eventFilter[0].matchMode;\n                } else if (eventFilter !== undefined) {\n                    filter.value = eventFilter.value;\n                    filter.matchMode = eventFilter.matchMode;\n                }\n                return {...acc, [key]: filter};\n            }, {});\n        }\n\n        return params;\n    }\n\n    /**\n     * Converts the given parameters to URL query parameters.\n     * Sorts are formatted in Medius data API sort query language: `asc:prop1,desc:prop2`, ...\n     * Filter keys are \"flattened\" in the new object, values are formatted in Medius data API filter query language: `cs:eq:asd`, `in:asd,qwe`, `ex`, ...\n     *\n     * @param {DataListParams} params - The parameters to convert.\n     * @param {DataListParams|null} defaults - The default parameters used if no matching property in params is available. Defaults to { limit: 25, offset: 0 } if not provided.\n     * @returns {Params} - The URL query parameters object.\n     */\n    public static toUrlQueryParams(\n        params: DataListParams<any, any>,\n        defaults: DataListParams<any, any> | null = {\n            limit: 25,\n            offset: 0\n        }\n    ): Params {\n        const urlParams: Params = {};\n\n        if (params.limit && params.limit !== defaults?.limit) {\n            urlParams['limit'] = params.limit;\n        }\n        if (params.offset && params.offset !== defaults?.offset) {\n            urlParams['offset'] = params.offset;\n        }\n        if (params.search && params.search !== defaults?.search) {\n            urlParams['q'] = params.search;\n        }\n        if (params.sort && Array.isArray(params.sort) && params.sort.length > 0) {\n            if (\n                defaults?.sort == null ||\n                !Array.isArray(defaults.sort) ||\n                defaults.sort.length === 0 ||\n                params.sort.length !== defaults.sort.length ||\n                defaults.sort.some((ds, idx) => ds.property !== params.sort![idx].property || (ds.ascending ?? true) !== (params.sort![idx].ascending ?? true))\n            ) {\n                urlParams['sort'] = DataListParamsUtil.sortToUrlQuery(params);\n            }\n        }\n        if (params.filters) {\n            Object.keys(params.filters).forEach(k => {\n                const paramFilter = params.filters![k as keyof object];\n                const defaultFilter = defaults?.filters?.[k as keyof object];\n                if (\n                    defaultFilter &&\n                    ((Array.isArray(defaultFilter.value) &&\n                        Array.isArray(paramFilter.value) &&\n                        defaultFilter.value.length === paramFilter.value.length &&\n                        defaultFilter.value.every((v, idx) => {\n                            const value = (paramFilter.value as Array<DataListFilterValueType>)[idx];\n                            if (value instanceof Date && v instanceof Date) return value.getTime() === v.getTime();\n                            else return value === v;\n                        })) || // handle arrays\n                        defaultFilter.value === paramFilter.value) &&\n                    defaultFilter.matchMode === paramFilter.matchMode &&\n                    (defaultFilter.caseSensitive ?? false) === (paramFilter.caseSensitive ?? false)\n                ) {\n                    return;\n                }\n\n                if (paramFilter.value == null && defaultFilter?.value == null) {\n                    return;\n                }\n\n                urlParams[k] = DataListParamsUtil.paramsFilterToUrlQuery(params, k, true);\n            });\n        }\n        if (defaults?.filters) {\n            // add other defaults\n            const paramFilterKeys = params.filters ? Object.keys(params.filters) : [];\n            Object.keys(defaults.filters)\n                .filter(k => paramFilterKeys.indexOf(k) < 0)\n                .forEach(k => {\n                    urlParams[k] = DataListParamsUtil.paramsFilterToUrlQuery(defaults, k);\n                });\n        }\n\n        return urlParams;\n    }\n\n    /**\n     * Merges the provided parameters with default values and returns the merged object.\n     *\n     * @param {DataListParams} params - The parameters to merge with defaults.\n     * @param {DataListParams} defaults - The default values to merge with params (optional, default is { limit: 25, offset: 0 }).\n     * @returns {DataListParams} - The merged parameters object.\n     */\n    public static mergeWithDefaults<Sorts = any, Filters extends keyof any = any>(\n        params: DataListParams<Sorts, Filters>,\n        defaults: DataListParams<Sorts, Filters> = {\n            limit: 25,\n            offset: 0\n        }\n    ): DataListParams<Sorts, Filters> {\n        const merged: DataListParams<Sorts, Filters> = {\n            limit: params.limit ?? defaults.limit,\n            offset: params.offset ?? defaults.offset,\n            search: params.search ?? defaults.search,\n            sort: (params.sort ?? defaults.sort)?.map(s => ({...s}))\n        };\n\n        if (params.filters) {\n            merged.filters = {} as DataListFiltersType<Filters>;\n            Object.entries(params.filters).forEach(([key, value]) => (merged.filters![key as Filters] = {...(value as DataListFilter)}));\n        }\n        if (defaults.filters) {\n            if (!merged.filters) merged.filters = {} as DataListFiltersType<Filters>;\n            Object.entries(defaults.filters).forEach(([key, value]) => {\n                if (merged.filters![key as Filters] === undefined) {\n                    merged.filters![key as Filters] = {...(value as DataListFilter)};\n                }\n            });\n        }\n\n        return merged;\n    }\n\n    /**\n     * Converts an object of parameters to a URL query string for sorting.\n     * Sorts are formatted in Medius data API sort query language: `asc:prop1,desc:prop2`, ...\n     *\n     * @param {DataListParams} params - An optional object containing sort parameters.\n     * @returns A string representing the URL query or undefined if no sort parameters are provided.\n     */\n    public static sortToUrlQuery(params?: DataListParams<any, any>): string | undefined {\n        return params && Array.isArray(params.sort)\n            ? params.sort.map(s => `${s.ascending === true || s.ascending === undefined ? 'asc' : 'desc'}:${String(s.property)}`).join(',')\n            : undefined;\n    }\n\n    /**\n     * Converts a specific filter parameter (by key) from DataListParams object to a URL query string.\n     * Filter keys are \"flattened\" in the new object, values are formatted in Medius data API filter query language: `cs:eq:asd`, `in:asd,qwe`, `ex`, ...\n     *\n     * @param {DataListParams<any, Filters> | undefined} params - The DataListParams object containing the filters.\n     * @param {Filters} key - The key of the filter to convert.\n     * @param {boolean} [allowNull=false] - Indicates whether to allow null values in the query string.\n     * @return {string | undefined} - The URL query string representing the specified filter, or undefined if the filter is not found.\n     */\n    public static paramsFilterToUrlQuery<Filters extends keyof any = string>(\n        params: DataListParams<any, Filters> | undefined,\n        key: Filters,\n        allowNull = false\n    ): string | undefined {\n        const paramFilter = params?.filters?.[key];\n        return DataListParamsUtil.filterToUrlQuery(paramFilter, allowNull);\n    }\n\n    /**\n     * Converts a filter to a URL query string.\n     * Filter keys are \"flattened\" in the new object, values are formatted in Medius data API filter query language: `cs:eq:asd`, `in:asd,qwe`, `ex`, ...\n     *\n     * @param {DataListFilter} paramFilter - The filter object to be converted.\n     * @param {boolean} [allowNull=false] - Indicates whether to allow null values in the filter.\n     * @returns {string|undefined} - The filter converted to a URL query string, or undefined if no filter is provided or the filter has empty or invalid values.\n     * @throws {CommonsInternalError} - If the filter has invalid values.\n     */\n    public static filterToUrlQuery(paramFilter?: DataListFilter, allowNull = false): string | undefined {\n        const filterValueAsArray = Array.isArray(paramFilter?.value) ? paramFilter!.value.filter(v => v !== undefined && (allowNull || v !== null)) : undefined;\n        if (\n            paramFilter === undefined ||\n            (!allowNull && paramFilter.value == null) ||\n            (typeof paramFilter.value === 'string' && paramFilter.value.length === 0) ||\n            (Array.isArray(filterValueAsArray) && filterValueAsArray.length === 0)\n        ) {\n            // no need to include filters for empty values\n            return undefined;\n        }\n\n        const matchMode = paramFilter.matchMode ?? FilterMatchMode.Equals;\n\n        if (matchMode === FilterMatchMode.Between && !(Array.isArray(filterValueAsArray) && filterValueAsArray.length === 2)) {\n            throw new CommonsInternalError(`Filter match mode between requires exactly 2 values: ${paramFilter.value}`);\n        }\n\n        if ((matchMode === FilterMatchMode.In || matchMode === FilterMatchMode.NotIn) && (!Array.isArray(filterValueAsArray) || filterValueAsArray.length === 0)) {\n            throw new CommonsInternalError(`Filter match mode ${matchMode} requires non-empty array: ${paramFilter.value}`);\n        }\n\n        if (([FilterMatchMode.In, FilterMatchMode.NotIn, FilterMatchMode.Between] as string[]).indexOf(matchMode) === -1 && Array.isArray(filterValueAsArray)) {\n            throw new CommonsInternalError(`Filter match mode ${matchMode} must not be array: ${paramFilter.value}`);\n        }\n\n        const noVal = paramFilter.matchMode === FilterMatchMode.Exists || paramFilter.matchMode === FilterMatchMode.DoesNotExist;\n        const urlValuePart = noVal ? '' : `:${DataListParamsUtil.filterValueToUrlParam(filterValueAsArray ?? paramFilter.value, allowNull)}`;\n\n        return `${paramFilter.caseSensitive ? 'cs:' : paramFilter.caseSensitive === false ? 'ci:' : ''}${FilterMatchMode.getAbbreviation(matchMode) ?? matchMode}${urlValuePart}`;\n    }\n\n    /**\n     * Converts URL query parameters to a DataListParams object.\n     * Sorts are formatted from Medius data API sort query language: `asc:prop1,desc:prop2`, ...\n     * Filter keys are all keys in Params object that are not matched elsewhere, values are formatted from Medius data API filter query language: `cs:eq:asd`, `in:asd,qwe`, `ex`, ...\n     *\n     * @param {Params} urlParams - The URL query parameters.\n     * @return {DataListParams} - The converted DataListParams object.\n     */\n    public static fromUrlQueryParams(urlParams: Params): DataListParams {\n        const params: DataListParams = {};\n\n        Object.entries(urlParams).forEach(([urlParamKey, urlParamValue]) => {\n            if (urlParamKey === 'limit') {\n                params.limit = +urlParamValue;\n                if (isNaN(params.limit) || params.limit < 0) {\n                    delete params.limit;\n                }\n            } else if (urlParamKey === 'offset') {\n                params.offset = +urlParamValue;\n                if (isNaN(params.offset) || params.offset < 0) {\n                    delete params.offset;\n                }\n            } else if (urlParamKey === 'q') {\n                params.search = urlParamValue;\n            } else if (urlParamKey === 'sort') {\n                if (typeof urlParamValue === 'string') {\n                    params.sort = urlParamValue.split(',').map(s => {\n                        const [direction, property] = s.split(':');\n                        return {property: (property ?? direction) as keyof object, ascending: direction !== 'desc'};\n                    });\n                } else {\n                    throw new CommonsInternalError(`String is expected as value for '${urlParamKey}' when converting from urlParams`);\n                }\n            } else if (typeof urlParamValue === 'string') {\n                if (urlParamValue.length === 0) {\n                    // empty string should be ignored\n                    return;\n                }\n\n                const filterParts = urlParamValue.split(':');\n                let partIdx = 0;\n\n                // case sensitive\n                let caseSensitive: boolean | undefined = undefined;\n                if (filterParts[partIdx] === 'cs' || filterParts[partIdx] === 'ci') {\n                    caseSensitive = filterParts[partIdx++] === 'cs';\n                }\n\n                // match mode\n                const matchMode = filterParts[partIdx] ? FilterMatchMode.fromAbbreviation(filterParts[partIdx]) ?? filterParts[partIdx] : FilterMatchMode.Equals;\n                partIdx++;\n\n                const noVal = matchMode === FilterMatchMode.Exists || matchMode === FilterMatchMode.DoesNotExist;\n\n                // value\n                let value: string | string[] | undefined | null = undefined;\n                if (!noVal) {\n                    if (filterParts.length < 2) {\n                        return;\n                    }\n\n                    if (partIdx === filterParts.length - 1) {\n                        value = filterParts[partIdx];\n                    } else if (partIdx < filterParts.length) {\n                        // array that should not be array, so join back together\n                        value = filterParts.slice(partIdx, filterParts.length).join(':');\n                    }\n\n                    if (value === undefined && matchMode !== FilterMatchMode.Exists && matchMode !== FilterMatchMode.DoesNotExist) {\n                        // if value undefined and match mode expects value, then skip\n                        return;\n                    }\n\n                    if (value === 'null') {\n                        value = null;\n                    }\n\n                    if ((matchMode === FilterMatchMode.In || matchMode === FilterMatchMode.NotIn || matchMode === FilterMatchMode.Between) && typeof value === 'string') {\n                        let arrayVal: string[] = [];\n                        // these match modes expect array\n                        if (value.indexOf('\"') >= 0) {\n                            const tokens: string[] = [];\n                            let currentToken = '';\n                            let explicitQuotes = false; //token is quoted, e.g. in:1,2,\"22\"\"\",\",123\"\"\"\n                            let quotesOpened = false; //token has started processing\n                            let quotesExplicitlyClosed = false; //token processing has finished, after single \" in quoted mode, or before , in not quoted\n\n                            for (let i = 0; i < value.length; i++) {\n                                const c = value[i];\n\n                                // reset the tokenizer when seeing the token separator\n                                // only if either:\n                                // the quotes have not been opened yet (when there are no characters between separators),\n                                // the token has been explicitly closed (when we actually have explicit opening i.e., quotes as the first character)\n                                // or we have implicit quotes (i.e., quotes are not the first character)\n                                if (c === ',' && (!quotesOpened || quotesExplicitlyClosed || !explicitQuotes)) {\n                                    tokens.push(currentToken);\n                                    currentToken = '';\n                                    quotesOpened = false;\n                                    quotesExplicitlyClosed = false;\n                                    explicitQuotes = false;\n                                } else if (c == '\"') {\n                                    // escaped double-quotes\n                                    if (explicitQuotes && i + 1 < value.length && value[i + 1] === '\"') {\n                                        currentToken += c; // Append one double-quote to the current token\n                                        i++; // Skip the next double-quote\n                                    }\n                                    // we encounter quotes again after they were the first character => we close the token\n                                    else if (explicitQuotes) {\n                                        quotesExplicitlyClosed = true;\n                                    }\n                                    // implicit quotes\n                                    else if (quotesOpened) {\n                                        currentToken += c;\n                                    }\n                                    // quotes are the first character => explicitly open the token\n                                    else {\n                                        currentToken = '';\n                                        quotesOpened = true;\n                                        explicitQuotes = true;\n                                    }\n                                } else {\n                                    if (quotesExplicitlyClosed) {\n                                        return;\n                                    }\n\n                                    quotesOpened = true;\n                                    currentToken += c;\n                                }\n                            }\n\n                            if (quotesOpened && !quotesExplicitlyClosed && explicitQuotes) {\n                                return;\n                            }\n\n                            // Append the last token after the loop ends\n                            tokens.push(currentToken.toString());\n\n                            arrayVal = tokens;\n                        } else {\n                            arrayVal = value.split(',');\n                        }\n\n                        if (matchMode === FilterMatchMode.Between && arrayVal.length !== 2) {\n                            return;\n                        }\n\n                        value = arrayVal;\n                    }\n\n                    if ((typeof value === 'string' && value.length === 0) || (Array.isArray(value) && value!.length === 0)) {\n                        // filter with empty value is to be ignored\n                        return;\n                    }\n                } else {\n                    caseSensitive = undefined;\n                }\n\n                if (!params.filters) {\n                    params.filters = {};\n                }\n\n                params.filters[urlParamKey as keyof object] = {value: value, matchMode: matchMode, caseSensitive: caseSensitive};\n            }\n        });\n\n        return params;\n    }\n\n    /**\n     * Makes a copy of the given DataListParams object.\n     *\n     * @param {DataListParams<Sorts, Filters>} params - The DataListParams object to be copied.\n     * @returns {DataListParams<Sorts, Filters>} - Returns a new copy of the DataListParams object.\n     */\n    public static copy<Sorts = string, Filters extends keyof any = string>(params: DataListParams<Sorts, Filters>): DataListParams<Sorts, Filters> {\n        const copy: DataListParams<Sorts, Filters> = {\n            offset: params.offset,\n            limit: params.limit,\n            search: params.search\n        };\n\n        if (params.sort) {\n            copy.sort = params.sort?.map(s => ({...s}));\n        }\n        if (params.filters) {\n            copy.filters = Object.entries(params.filters).reduce((acc, [key, value]) => {\n                const filterValue = value as DataListFilter;\n                return {\n                    ...acc,\n                    [key]: {\n                        ...filterValue,\n                        value: Array.isArray(filterValue.value) ? [...filterValue.value] : filterValue.value\n                    } as DataListFilter\n                };\n            }, {} as DataListFiltersType<Filters>);\n        }\n\n        return copy;\n    }\n\n    /**\n     * Converts a value to a URL query param string representation.\n     *\n     * @param {unknown} value - The value to be converted.\n     * @param {boolean} [allowNull=false] - Indicates whether null values are allowed.\n     * @returns {string} The URL parameter representation of the value.\n     * @throws {CommonsInternalError} If an undefined value is passed without allowNull set to true.\n     * @throws {CommonsInternalError} If the value is an object (excluding Date).\n     */\n    public static filterValueToUrlParam(value: unknown, allowNull = false): string {\n        if (value === null && allowNull) return 'null';\n        if (value == null) throw new CommonsInternalError('Undefined value cannot be converted to url param.'); // this should not happen, should be filtered out earlier\n        if (Array.isArray(value))\n            return value\n                .map(v => DataListParamsUtil.filterValueToUrlParam(v, allowNull))\n                .map(v => (v.indexOf(',') >= 0 || v.indexOf('\"') >= 0 ? `\"${v.replaceAll('\"', '\"\"')}\"` : v))\n                .join(',');\n        if (typeof value === 'object') {\n            if (value instanceof Date) return DateUtil.toIsoString(value, 'dateTime', {utc: true});\n            else {\n                throw new CommonsInternalError('Filter value cannot be object');\n            }\n        }\n        return String(value);\n    }\n}\n"]}

package/esm2022/core/data-list/data-list.model.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0YS1saXN0Lm1vZGVsLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vY29yZS9zcmMvZGF0YS1saXN0L2RhdGEtbGlzdC5tb2RlbC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtGaWx0ZXJNYXRjaE1vZGVFeHRlbmRlZFR5cGV9IGZyb20gJy4vZmlsdGVyLW1hdGNoLm1vZGVsJztcblxuZXhwb3J0IGludGVyZmFjZSBEYXRhTGlzdFBhcmFtczxTb3J0cyA9IHN0cmluZywgRmlsdGVycyBleHRlbmRzIGtleW9mIGFueSA9IHN0cmluZz4ge1xuICAgIG9mZnNldD86IG51bWJlcjtcbiAgICBsaW1pdD86IG51bWJlcjtcbiAgICBzb3J0PzogRGF0YUxpc3RTb3J0PFNvcnRzPltdO1xuICAgIHNlYXJjaD86IHN0cmluZztcbiAgICBmaWx0ZXJzPzogRGF0YUxpc3RGaWx0ZXJzVHlwZTxGaWx0ZXJzPjtcbn1cblxuZXhwb3J0IGludGVyZmFjZSBEYXRhTGlzdFNvcnQ8UHJvcGVydHkgPSBzdHJpbmc+IHtcbiAgICBwcm9wZXJ0eTogUHJvcGVydHk7XG4gICAgYXNjZW5kaW5nPzogYm9vbGVhbjtcbn1cblxuZXhwb3J0IHR5cGUgRGF0YUxpc3RGaWx0ZXJCYXNlVmFsdWVUeXBlID0gc3RyaW5nIHwgbnVtYmVyIHwgYm9vbGVhbiB8IERhdGUgfCB1bmRlZmluZWQgfCBudWxsO1xuZXhwb3J0IHR5cGUgRGF0YUxpc3RGaWx0ZXJWYWx1ZVR5cGUgPSBEYXRhTGlzdEZpbHRlckJhc2VWYWx1ZVR5cGUgfCBEYXRhTGlzdEZpbHRlckJhc2VWYWx1ZVR5cGVbXSB8IHVuZGVmaW5lZCB8IG51bGw7XG5leHBvcnQgdHlwZSBEYXRhTGlzdEZpbHRlckZyb21VcmxWYWx1ZVR5cGUgPSBzdHJpbmcgfCBzdHJpbmdbXSB8IHVuZGVmaW5lZCB8IG51bGw7XG5cbmV4cG9ydCB0eXBlIERhdGFMaXN0RmlsdGVyc1R5cGU8RmlsdGVycyBleHRlbmRzIGtleW9mIGFueSA9IHN0cmluZz4gPSB7XG4gICAgW1Byb3AgaW4gRmlsdGVyc106IERhdGFMaXN0RmlsdGVyO1xufTtcblxuZXhwb3J0IGludGVyZmFjZSBEYXRhTGlzdEZpbHRlcjxWYWx1ZSA9IERhdGFMaXN0RmlsdGVyVmFsdWVUeXBlPiB7XG4gICAgdmFsdWU/OiBWYWx1ZTtcbiAgICBtYXRjaE1vZGU/OiBGaWx0ZXJNYXRjaE1vZGVFeHRlbmRlZFR5cGU7XG4gICAgY2FzZVNlbnNpdGl2ZT86IGJvb2xlYW47XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgRGF0YUxpc3RSZXN1bHQ8SXRlbSA9IGFueT4ge1xuICAgIGRhdGE6IEl0ZW1bXTtcbiAgICB0b3RhbENvdW50PzogbnVtYmVyO1xufVxuIl19