{"version":3,"file":"static/js/2922.a2563ef9.chunk.js","mappings":"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","sources":["webpack://power-app-fe/./node_modules/@progress/kendo-data-query/dist/es/utils.js","webpack://power-app-fe/./node_modules/@progress/kendo-data-query/dist/es/filter-serialization.common.js","webpack://power-app-fe/./node_modules/@progress/kendo-data-query/dist/es/funcs.js","webpack://power-app-fe/./node_modules/@progress/kendo-data-query/dist/es/odata.operators.js","webpack://power-app-fe/./node_modules/@progress/kendo-data-query/dist/es/filtering/filter-descriptor.interface.js","webpack://power-app-fe/./node_modules/@progress/kendo-data-query/dist/es/filtering/filter.operators.js","webpack://power-app-fe/./node_modules/@progress/kendo-data-query/dist/es/odata-filtering.operators.js","webpack://power-app-fe/./node_modules/@progress/kendo-data-query/dist/es/accessor.js","webpack://power-app-fe/./node_modules/@progress/kendo-data-query/dist/es/mvc/operators.js","webpack://power-app-fe/./node_modules/@progress/kendo-data-query/dist/es/filtering/operators.enum.js","webpack://power-app-fe/./node_modules/@progress/kendo-data-query/dist/es/mvc/deserialization.js","webpack://power-app-fe/./node_modules/@progress/kendo-data-query/dist/es/sorting/sort-array.operator.js","webpack://power-app-fe/./node_modules/@progress/kendo-data-query/dist/es/transducers.js","webpack://power-app-fe/./node_modules/@progress/kendo-data-query/dist/es/grouping/aggregate.operators.js","webpack://power-app-fe/./node_modules/@progress/kendo-data-query/dist/es/filtering/filter-no-eval.js","webpack://power-app-fe/./node_modules/@progress/kendo-data-query/dist/es/filtering/filter-expression.factory.js","webpack://power-app-fe/./node_modules/@progress/kendo-data-query/dist/es/grouping/group.operators.js","webpack://power-app-fe/./node_modules/@progress/kendo-data-query/dist/es/array.operators.js"],"sourcesContent":["/**\n * @hidden\n */\nexport var isPresent = function (value) { return value !== null && value !== undefined; };\n/**\n * @hidden\n */\nexport var isBlank = function (value) { return value === null || value === undefined; };\n/**\n * @hidden\n */\nexport var isArray = function (value) { return Array.isArray(value); };\n/**\n * @hidden\n */\nexport var isFunction = function (value) { return typeof value === 'function'; };\n/**\n * @hidden\n */\nexport var isString = function (value) { return typeof value === 'string'; };\n/**\n * @hidden\n */\nexport var isTruthy = function (value) { return !!value; };\n/**\n * @hidden\n */\nexport var isNullOrEmptyString = function (value) { return isBlank(value) || value.trim().length === 0; };\n/**\n * @hidden\n */\nexport var isNotNullOrEmptyString = function (value) { return !isNullOrEmptyString(value); };\n/**\n * @hidden\n */\nexport var isNumeric = function (value) { return !isNaN(value - parseFloat(value)); };\n/**\n * @hidden\n */\nexport var isDate = function (value) { return value && value.getTime; };\n","import { __makeTemplateObject } from \"tslib\";\nimport { isString, isDate } from './utils';\n/**\n * @hidden\n * Creates a single arity function which wraps the value based on the provided predicate.\n * @example\n * ```\n * wrapIf(() => ignoreCase) `tolower(${field})`\n * //ignoreCase=true -> tolower(${field})`\n * //ignoreCase=false -> ${field}`\n * ```\n */\nexport var wrapIf = function (predicate) { return function (str) {\n    var args = [];\n    for (var _i = 1; _i < arguments.length; _i++) {\n        args[_i - 1] = arguments[_i];\n    }\n    return predicate() ? \"\".concat(str[0]).concat(args[0]).concat(str[1]) : args[0];\n}; };\n/**\n * @hidden\n */\nexport var toUTC = function (date) {\n    return new Date(Date.UTC(date.getFullYear(), date.getMonth(), date.getDate(), date.getHours(), date.getMinutes(), date.getSeconds(), date.getMilliseconds()));\n};\n/**\n * @hidden\n */\nexport var quote = function (_a) {\n    var field = _a.field, value = _a.value, ignoreCase = _a.ignoreCase, operator = _a.operator;\n    return ({\n        value: \"'\".concat(value.replace(/'/g, \"''\"), \"'\"),\n        field: field,\n        ignoreCase: ignoreCase,\n        operator: operator\n    });\n};\n/**\n * @hidden\n */\nexport var encodeValue = function (_a) {\n    var field = _a.field, value = _a.value, ignoreCase = _a.ignoreCase, operator = _a.operator;\n    return ({\n        value: \"\".concat(encodeURIComponent(value)),\n        field: field,\n        ignoreCase: ignoreCase,\n        operator: operator\n    });\n};\n/**\n * @hidden\n */\nexport var toLower = function (_a) {\n    var field = _a.field, value = _a.value, ignoreCase = _a.ignoreCase, operator = _a.operator;\n    return ({\n        field: wrapIf(function () { return ignoreCase; })(templateObject_1 || (templateObject_1 = __makeTemplateObject([\"tolower(\", \")\"], [\"tolower(\", \")\"])), field),\n        value: value,\n        ignoreCase: ignoreCase,\n        operator: operator\n    });\n};\n/**\n * @hidden\n */\nexport var normalizeField = function (_a) {\n    var field = _a.field, value = _a.value, ignoreCase = _a.ignoreCase, operator = _a.operator;\n    return ({\n        value: value,\n        field: field.replace(/\\./g, \"/\"),\n        ignoreCase: ignoreCase,\n        operator: operator\n    });\n};\n/**\n * @hidden\n */\nexport var isStringValue = function (x) { return isString(x.value); };\n/**\n * @hidden\n */\nexport var isDateValue = function (x) { return isDate(x.value); };\n/**\n * @hidden\n */\nexport var serializeFilters = function (map, join) { return function (filter) {\n    var brackets = wrapIf(function () { return filter.filters.length > 1; });\n    return brackets(templateObject_2 || (templateObject_2 = __makeTemplateObject([\"(\", \")\"], [\"(\", \")\"])), filter.filters\n        .map(map)\n        .join(join(filter)));\n}; };\nvar templateObject_1, templateObject_2;\n","/**\n * @hidden\n */\nexport var ifElse = function (predicate, right, left) { return function (value) { return predicate(value) ? right(value) : left(value); }; };\n/**\n * @hidden\n * Performs the right-to-left function composition. Functions should have a unary.\n */\nexport var compose = function () {\n    var args = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        args[_i] = arguments[_i];\n    }\n    return function (data) { return args.reduceRight(function (acc, curr) { return curr(acc); }, data); };\n};\n/**\n * @hidden\n */\nexport var constant = function (x) { return function () { return x; }; };\n/**\n * @hidden\n */\nexport var identity = function (x) { return x; };\n","import { __makeTemplateObject } from \"tslib\";\nimport { isPresent, isNotNullOrEmptyString } from './utils';\nimport { serializeFilter } from './odata-filtering.operators';\nimport { ifElse, constant } from './funcs';\nvar serializeSort = function (orderby) {\n    var str = orderby\n        .filter(function (sort) { return isPresent(sort.dir); })\n        .map(function (sort) {\n        var order = sort.field.replace(/\\./g, \"/\");\n        return sort.dir === \"desc\" ? order + \" desc\" : order;\n    }).join(\",\");\n    return str ? \"$orderby=\".concat(str) : str;\n};\nvar emptyString = constant('');\nvar concat = function (a) { return function (b) { return a + b; }; };\nvar serializeKey = function (strings, val) { return ifElse(isPresent, concat(strings[0]), emptyString)(val); };\nvar rules = function (settings, state) { return function (key) { return ({\n    \"filter\": serializeFilter(state.filter || {}, settings),\n    \"skip\": serializeKey(templateObject_1 || (templateObject_1 = __makeTemplateObject([\"$skip=\", \"\"], [\"$skip=\", \"\"])), state.skip),\n    \"sort\": serializeSort(state.sort || []),\n    \"take\": serializeKey(templateObject_2 || (templateObject_2 = __makeTemplateObject([\"$top=\", \"\"], [\"$top=\", \"\"])), state.take)\n}[key]); }; };\n// tslint:enable:max-line-length\n/**\n * Converts a [State]({% slug api_kendo-data-query_state %}) into an OData v4 compatible string.\n *\n * @param {State} state - The state that will be serialized.\n * @param {ODataSettings} settings - The settings that are used during the serialization.\n * @returns {string} - The serialized state.\n */\nexport var toODataString = function (state, settings) {\n    if (settings === void 0) { settings = {}; }\n    return (Object.keys(state)\n        .map(rules(settings, state))\n        .filter(isNotNullOrEmptyString)\n        .join('&'));\n};\nvar templateObject_1, templateObject_2;\n","import { isPresent } from '../utils';\n// tslint:enable:max-line-length\n/**\n * @hidden\n * Type guard for `CompositeFilterDescriptor`.\n */\nexport var isCompositeFilterDescriptor = function (source) {\n    return isPresent(source.filters);\n};\n","import { isPresent, isString, isArray } from '../utils';\nimport { isCompositeFilterDescriptor } from './filter-descriptor.interface';\nvar operatorMap = function (key) { return ({\n    \"!=\": \"neq\",\n    \"<\": \"lt\",\n    \"<=\": \"lte\",\n    \"==\": \"eq\",\n    \">\": \"gt\",\n    \">=\": \"gte\",\n    equal: \"eq\",\n    equals: \"eq\",\n    equalto: \"eq\",\n    ge: \"gte\",\n    greater: \"gt\",\n    greaterthan: \"gt\",\n    greaterthanequal: \"gte\",\n    isempty: \"isempty\",\n    isequalto: \"eq\",\n    isgreaterthan: \"gt\",\n    isgreaterthanorequalto: \"gte\",\n    islessthan: \"lt\",\n    islessthanorequalto: \"lte\",\n    isnotempty: \"isnotempty\",\n    isnotequalto: \"neq\",\n    isnull: \"isnull\",\n    le: \"lte\",\n    less: \"lt\",\n    lessthan: \"lt\",\n    lessthanequal: \"lte\",\n    ne: \"neq\",\n    notequal: \"neq\",\n    notequals: \"neq\",\n    notequalto: \"neq\",\n    notsubstringof: \"doesnotcontain\"\n}[key.toLowerCase()] || key); };\nvar normalizeOperator = function (descriptor) {\n    if (descriptor.filters) {\n        descriptor.filters = descriptor.filters.map(function (filter) {\n            var result = Object.assign({}, filter);\n            if (!isCompositeFilterDescriptor(filter) && isString(filter.operator)) {\n                result.operator = operatorMap(filter.operator);\n            }\n            if (isCompositeFilterDescriptor(filter)) {\n                normalizeOperator(result);\n            }\n            return result;\n        });\n    }\n};\nvar normalizeDescriptor = function (descriptor) {\n    if (!isCompositeFilterDescriptor(descriptor)) {\n        return {\n            filters: isArray(descriptor) ? descriptor : [descriptor],\n            logic: \"and\"\n        };\n    }\n    return Object.assign({}, descriptor);\n};\n// tslint:disable:max-line-length\n/**\n * Converts a [`FilterDescriptor`]({% slug api_kendo-data-query_filterdescriptor %}) into a [`CompositeFilterDescriptor`]({% slug api_kendo-data-query_compositefilterdescriptor %}). If a `CompositeFilterDescriptor` is passed, no modifications will be made.\n *\n * @param {CompositeFilterDescriptor | FilterDescriptor} descriptor - The descriptor that will be normalized.\n * @returns {CompositeFilterDescriptor} - The normalized descriptor.\n */\n// tslint:enable:max-line-length\nexport var normalizeFilters = function (descriptor) {\n    if (isPresent(descriptor)) {\n        descriptor = normalizeDescriptor(descriptor);\n        normalizeOperator(descriptor);\n    }\n    return descriptor;\n};\n","import { __assign } from \"tslib\";\nimport { isCompositeFilterDescriptor } from './filtering/filter-descriptor.interface';\nimport { compose, ifElse } from './funcs';\nimport { normalizeField, quote, toLower, isDateValue, isStringValue, serializeFilters, encodeValue, toUTC } from './filter-serialization.common';\nimport { normalizeFilters } from './filtering/filter.operators';\nvar formatDate = function (_a) {\n    var utcDates = _a.utcDates;\n    return function (_a) {\n        var field = _a.field, value = _a.value, ignoreCase = _a.ignoreCase, operator = _a.operator;\n        return ({\n            value: (!utcDates ? toUTC(value) : value).toISOString(),\n            field: field,\n            ignoreCase: ignoreCase,\n            operator: operator\n        });\n    };\n};\nvar fnFormatter = function (_a) {\n    var operator = _a.operator;\n    return function (_a) {\n        var field = _a.field, value = _a.value;\n        return \"\".concat(operator, \"(\").concat(field, \",\").concat(value, \")\");\n    };\n};\nvar singleOperatorFormatter = function (_a) {\n    var operator = _a.operator;\n    return function (_a) {\n        var field = _a.field, value = _a.value;\n        return \"\".concat(field, \" \").concat(operator, \" \").concat(value);\n    };\n};\nvar stringFormat = function (formatter) { return compose(formatter, encodeValue, quote, toLower, normalizeField); };\nvar stringFnOperator = function (settings) { return stringFormat(fnFormatter(settings)); };\nvar stringOperator = function (settings) { return stringFormat(singleOperatorFormatter(settings)); };\nvar numericOperator = function (settings) { return compose(singleOperatorFormatter(settings), normalizeField); };\nvar dateOperator = function (settings) { return compose(singleOperatorFormatter(settings), normalizeField, formatDate(settings)); };\nvar ifDate = function (settings) { return ifElse(isDateValue, dateOperator(settings), numericOperator(settings)); };\nvar typedOperator = function (settings) { return ifElse(isStringValue, stringOperator(settings), ifDate(settings)); };\nvar appendEqual = function (str) { return \"\".concat(str, \" eq -1\"); };\nvar nonValueExpression = function (formatter) { return compose(formatter, normalizeField); };\nvar filterOperators = function (operator, settings) { return ({\n    contains: stringFnOperator(__assign(__assign({}, settings), { operator: \"contains\" })),\n    doesnotcontain: compose(appendEqual, stringFnOperator(__assign(__assign({}, settings), { operator: \"indexof\" }))),\n    endswith: stringFnOperator(__assign(__assign({}, settings), { operator: \"endswith\" })),\n    eq: typedOperator(__assign(__assign({}, settings), { operator: \"eq\" })),\n    gt: typedOperator(__assign(__assign({}, settings), { operator: \"gt\" })),\n    gte: typedOperator(__assign(__assign({}, settings), { operator: \"ge\" })),\n    isempty: nonValueExpression(function (_a) {\n        var field = _a.field;\n        return \"\".concat(field, \" eq ''\");\n    }),\n    isnotempty: nonValueExpression(function (_a) {\n        var field = _a.field;\n        return \"\".concat(field, \" ne ''\");\n    }),\n    isnotnull: nonValueExpression(function (_a) {\n        var field = _a.field;\n        return \"\".concat(field, \" ne null\");\n    }),\n    isnull: nonValueExpression(function (_a) {\n        var field = _a.field;\n        return \"\".concat(field, \" eq null\");\n    }),\n    lt: typedOperator(__assign(__assign({}, settings), { operator: \"lt\" })),\n    lte: typedOperator(__assign(__assign({}, settings), { operator: \"le\" })),\n    neq: typedOperator(__assign(__assign({}, settings), { operator: \"ne\" })),\n    startswith: stringFnOperator(__assign(__assign({}, settings), { operator: \"startswith\" }))\n}[operator]); };\nvar join = function (x) { return \" \".concat(x.logic, \" \"); };\nvar serialize = function (settings) { return function (x) { return filterOperators(x.operator, settings)(x); }; };\nvar serializeAll = function (settings) { return serializeFilters(function (filter) { return ifElse(isCompositeFilterDescriptor, serializeAll(settings), serialize(settings))(filter); }, join); };\n/**\n * @hidden\n */\nexport var serializeFilter = function (filter, settings) {\n    if (settings === void 0) { settings = {}; }\n    if (filter.filters && filter.filters.length) {\n        return \"$filter=\" + serializeAll(settings)(normalizeFilters(filter));\n    }\n    return \"\";\n};\n","import { isPresent } from './utils';\nvar getterCache = {};\nvar FIELD_REGEX = /\\[(?:(\\d+)|['\"](.*?)['\"])\\]|((?:(?!\\[.*?\\]|\\.).)+)/g;\n// tslint:disable-next-line:no-string-literal\ngetterCache['undefined'] = function (obj) { return obj; };\n/**\n * @hidden\n */\nexport var getter = function (field, safe) {\n    var key = field + safe;\n    if (getterCache[key]) {\n        return getterCache[key];\n    }\n    var fields = [];\n    field.replace(FIELD_REGEX, function (_, index, indexAccessor, field) {\n        fields.push(isPresent(index) ? index : (indexAccessor || field));\n        return undefined;\n    });\n    getterCache[key] = function (obj) {\n        var result = obj;\n        for (var idx = 0; idx < fields.length; idx++) {\n            result = result[fields[idx]];\n            if (!isPresent(result) && safe) {\n                return result;\n            }\n        }\n        return result;\n    };\n    return getterCache[key];\n};\n","import { __assign, __spreadArray } from \"tslib\";\nimport { isCompositeFilterDescriptor } from '../filtering/filter-descriptor.interface';\nimport { isPresent, isNotNullOrEmptyString, isArray } from '../utils';\nimport { getter } from '../accessor';\nimport { compose, ifElse, identity } from '../funcs';\nimport { isStringValue, isDateValue, quote, serializeFilters, toUTC, encodeValue } from '../filter-serialization.common';\nvar toQueryString = function (values) { return values.reduce(function (acc, _a) {\n    var key = _a[0], value = _a[1];\n    return __spreadArray(__spreadArray([], acc, true), [\"\".concat(key, \"=\").concat(value)], false);\n}, []); };\nvar toObject = function (values) { return values.reduce(function (acc, _a) {\n    var _b;\n    var key = _a[0], value = _a[1];\n    return (__assign(__assign({}, acc), (_b = {}, _b[key] = value, _b)));\n}, {}); };\nvar pairwise = function (key) { return function (value) { return [key, value]; }; };\nvar empty = function () { return null; };\nvar isNotEmptyArray = function (value) { return isPresent(value) && isArray(value) && value.length > 0; };\nvar has = function (accessor) { return function (value) { return isPresent(accessor(value)); }; };\nvar isNotEmpty = function (accessor) { return function (value) { return isNotEmptyArray(accessor(value)); }; };\nvar runOrEmpty = function (predicate, fn) { return ifElse(predicate, fn, empty); };\nvar calcPage = function (_a) {\n    var skip = _a.skip, take = _a.take;\n    return Math.floor((skip || 0) / take) + 1;\n};\nvar formatDescriptors = function (accessor, formatter) { return function (state) { return (accessor(state).map(formatter).join(\"~\")); }; };\nvar removeAfter = function (what) { return function (str) { return str.slice(0, str.indexOf(what)); }; };\nvar replace = function (patterns) {\n    return compose.apply(void 0, patterns.map(function (_a) {\n        var left = _a[0], right = _a[1];\n        return function (s) { return s.replace(new RegExp(left, \"g\"), right); };\n    }));\n};\nvar sanitizeDateLiterals = replace([[\"\\\"\", \"\"], [\":\", \"-\"]]);\nvar removeAfterDot = removeAfter(\".\");\nvar directionFormatter = function (_a) {\n    var field = _a.field, _b = _a.dir, dir = _b === void 0 ? \"asc\" : _b;\n    return \"\".concat(field, \"-\").concat(dir);\n};\nvar aggregateFormatter = function (_a) {\n    var field = _a.field, aggregate = _a.aggregate;\n    return \"\".concat(field, \"-\").concat(aggregate);\n};\nvar take = getter(\"take\");\nvar aggregates = getter(\"aggregates\");\nvar skip = getter(\"skip\");\nvar group = getter(\"group\");\nvar sort = getter(\"sort\", true);\nvar formatSort = formatDescriptors(sort, directionFormatter);\nvar formatGroup = formatDescriptors(group, directionFormatter);\nvar formatAggregates = formatDescriptors(aggregates, aggregateFormatter);\nvar prefixDateValue = function (value) { return \"datetime'\".concat(value, \"'\"); };\nvar formatDateValue = compose(prefixDateValue, removeAfterDot, sanitizeDateLiterals, JSON.stringify, toUTC);\nvar formatDate = function (_a) {\n    var field = _a.field, value = _a.value, ignoreCase = _a.ignoreCase, operator = _a.operator;\n    return ({\n        value: formatDateValue(value),\n        field: field,\n        ignoreCase: ignoreCase,\n        operator: operator\n    });\n};\nvar normalizeSort = function (state) { return Object.assign({}, state, {\n    sort: (sort(state) || []).filter(function (_a) {\n        var dir = _a.dir;\n        return isNotNullOrEmptyString(dir);\n    })\n}); };\nvar transformSkip = compose(pairwise('page'), calcPage);\nvar transformTake = compose(pairwise('pageSize'), take);\nvar transformGroup = compose(pairwise('group'), formatGroup);\nvar transformSort = compose(pairwise('sort'), formatSort);\nvar transformAggregates = compose(pairwise('aggregate'), formatAggregates);\nvar serializePage = runOrEmpty(has(skip), transformSkip);\nvar serializePageSize = runOrEmpty(has(take), transformTake);\nvar serializeGroup = runOrEmpty(isNotEmpty(group), transformGroup);\nvar serializeAggregates = runOrEmpty(has(aggregates), transformAggregates);\nvar serializeSort = compose(runOrEmpty(isNotEmpty(sort), transformSort), normalizeSort);\nvar hasField = function (_a) {\n    var field = _a.field;\n    return isNotNullOrEmptyString(field);\n};\nvar filterFormatter = function (_a) {\n    var field = _a.field, operator = _a.operator, value = _a.value;\n    return \"\".concat(field, \"~\").concat(operator, \"~\").concat(value);\n};\nvar dateFormatter = ifElse(isDateValue, compose(filterFormatter, formatDate), filterFormatter);\nvar typedFormatter = function (encode) { return runOrEmpty(hasField, ifElse(isStringValue, compose(filterFormatter, quote, encode ? encodeValue : identity), dateFormatter)); };\nvar join = function (_a) {\n    var logic = _a.logic;\n    return \"~\".concat(logic, \"~\");\n};\nvar serialize = function (encode) { return serializeFilters(function (filter) { return ifElse(isCompositeFilterDescriptor, serialize(encode), typedFormatter(encode))(filter); }, join); };\nvar serializeFilter = function (_a, encode) {\n    var filter = _a.filter;\n    if (filter && filter.filters) {\n        var filters = serialize(encode)(filter);\n        if (filters.length) {\n            return ['filter', filters];\n        }\n    }\n    return null;\n};\nvar rules = function (state, encode) {\n    if (encode === void 0) { encode = true; }\n    return function (key) { return ({\n        \"aggregates\": serializeAggregates(state),\n        \"filter\": serializeFilter(state, encode),\n        \"group\": serializeGroup(state),\n        \"skip\": serializePage(state),\n        \"sort\": serializeSort(state),\n        \"take\": serializePageSize(state)\n    }[key]); };\n};\n/**\n * Converts a [DataSourceRequestState]({% slug api_kendo-data-query_datasourcerequeststate %}) into a string\n * that is comparable with the `DataSourceRequest` format in UI for ASP.NET MVC.\n *\n * @param {DataSourceRequestState} state - The state that will be serialized.\n * @returns {string} - The serialized state.\n *\n * @example\n * {% platform_content angular %}\n * ```ts\n *  import {\n *      toDataSourceRequestString,\n *      translateDataSourceResultGroups,\n *      translateAggregateResults\n * } from '@progress/kendo-data-query';\n *\n * export class Service {\n *  private BASE_URL: string = '...';\n *\n *  constructor(private http: Http) { }\n *\n *  // Omitted for brevity...\n *\n *  private fetch(state: DataSourceRequestState): Observable<DataResult> {\n *   const queryStr = `${toDataSourceRequestString(state)}`; //serialize the state\n *   const hasGroups = state.group && state.group.length;\n *\n *   return this.http\n *       .get(`${this.BASE_URL}?${queryStr}`) //send the state to the server\n *       .map(response => response.json())\n *       .map(({Data, Total, AggregateResults}) => // process the response\n *           (<GridDataResult>{\n *               //if there are groups convert them to compatible format\n *               data: hasGroups ? translateDataSourceResultGroups(Data) : Data,\n *               total: Total,\n *               // convert the aggregates if such exists\n *               aggregateResult: translateAggregateResults(AggregateResults)\n *           })\n *       );\n *  }\n * }\n * ```\n * {% endplatform_content %}\n *\n * {% platform_content react %}\n * ```jsx\n * import React from 'react';\n * import { toDataSourceRequestString, translateDataSourceResultGroups } from '@progress/kendo-data-query';\n *\n * export function withState(WrappedGrid) {\n *     return class StatefullGrid extends React.Component {\n *         constructor(props) {\n *             super(props);\n *             this.state = { dataState: { skip: 0, take: 20 } };\n *         }\n *\n *         render() {\n *             return (\n *                 <WrappedGrid\n *                     filterable={true}\n *                     sortable={true}\n *                     pageable={{ pageSizes: true }}\n *                     {...this.props}\n *                     total={this.state.total}\n *                     data={this.state.data}\n *                     skip={this.state.dataState.skip}\n *                     pageSize={this.state.dataState.take}\n *                     filter={this.state.dataState.filter}\n *                     sort={this.state.dataState.sort}\n *                     dataStateChange={this.dataStateChange}\n *                 />\n *             );\n *         }\n *\n *         componentDidMount() {\n *             this.fetchData(this.state.dataState);\n *         }\n *\n *         dataStateChange = (changeEvent) => {\n *             this.setState({ dataState: changeEvent.data });\n *             this.fetchData(changeEvent.data);\n *         }\n *\n *         fetchData(dataState) {\n *             const queryStr = `${toDataSourceRequestString(dataState)}`; // Serialize the state\n *             const hasGroups = dataState.group && dataState.group.length;\n *\n *             const base_url = 'api/Products';\n *             const init = { method: 'GET', accept: 'application/json', headers: {} };\n *\n *             fetch(`${base_url}?${queryStr}`, init)\n *                 .then(response => response.json())\n *                 .then(({ data, total }) => {\n *                     this.setState({\n *                         data: hasGroups ? translateDataSourceResultGroups(data) : data,\n *                         total,\n *                         dataState\n *                     });\n *                 });\n *         }\n *     }\n * }\n * ```\n * {% endplatform_content %}\n */\nexport var toDataSourceRequestString = function (state) { return (toQueryString(Object.keys(state)\n    .map(rules(state))\n    .filter(isPresent)).join('&')); };\n/**\n * Converts a [DataSourceRequestState]({% slug api_kendo-data-query_datasourcerequeststate %}) into an object\n * that is compatible with the `DataSourceRequest` format in UI for ASP.NET MVC.\n *\n * @param {DataSourceRequestState} state - The state that will be serialized.\n * @returns {any} - The serialized state.\n */\nexport var toDataSourceRequest = function (state) { return (toObject(Object.keys(state)\n    .map(rules(state, false))\n    .filter(isPresent))); };\n","/**\n * Represents the list of supported [`FilterDescriptor`]({% slug api_kendo-data-query_filterdescriptor %}) operators.\n * Allows restricting `FilterDescriptor.operator` definition to available values only.\n */\nexport var FilterOperator;\n(function (FilterOperator) {\n    /**\n     * The `contains` operator.\n     */\n    FilterOperator[\"Contains\"] = \"contains\";\n    /**\n     * The `doesnotcontain` operator.\n     */\n    FilterOperator[\"DoesNotContain\"] = \"doesnotcontain\";\n    /**\n     * The `doesnotendwith` operator.\n     */\n    FilterOperator[\"DoesNotEndWith\"] = \"doesnotendwith\";\n    /**\n     * The `doesnotstartwith` operator.\n     */\n    FilterOperator[\"DoesNotStartWith\"] = \"doesnotstartwith\";\n    /**\n     * The `endswith` operator.\n     */\n    FilterOperator[\"EndsWith\"] = \"endswith\";\n    /**\n     * The `eq` operator.\n     */\n    FilterOperator[\"EqualTo\"] = \"eq\";\n    /**\n     * The `gt` operator.\n     */\n    FilterOperator[\"GreaterThan\"] = \"gt\";\n    /**\n     * The `gte` operator.\n     */\n    FilterOperator[\"GreaterThanOrEqual\"] = \"gte\";\n    /**\n     * The `isempty` operator.\n     */\n    FilterOperator[\"IsEmpty\"] = \"isempty\";\n    /**\n     * The `isnotempty` operator.\n     */\n    FilterOperator[\"IsNotEmpty\"] = \"isnotempty\";\n    /**\n     * The `isnotnull` operator.\n     */\n    FilterOperator[\"IsNotNull\"] = \"isnotnull\";\n    /**\n     * The `isnull` operator.\n     */\n    FilterOperator[\"IsNull\"] = \"isnull\";\n    /**\n     * The `lt` operator.\n     */\n    FilterOperator[\"LessThan\"] = \"lt\";\n    /**\n     * The `lte` operator.\n     */\n    FilterOperator[\"LessThanOrEqual\"] = \"lte\";\n    /**\n     * The `neq` operator.\n     */\n    FilterOperator[\"NotEqualTo\"] = \"neq\";\n    /**\n     * The `startswith` operator.\n     */\n    FilterOperator[\"StartsWith\"] = \"startswith\";\n})(FilterOperator || (FilterOperator = {}));\n","import { isPresent } from '../utils';\nimport { compose } from '../funcs';\n// tslint:enable:max-line-length\nvar set = function (field, target, value) {\n    target[field] = value;\n    return target;\n};\nvar toCamelCase = function (str) { return str.replace(/(^[A-Z])/g, function (_, g1) { return g1.toLowerCase(); }); };\nvar prop = function (fieldName) { return function (obj) {\n    var value = obj[fieldName];\n    if (isPresent(value)) {\n        return value;\n    }\n    return obj[toCamelCase(fieldName)];\n}; };\nvar member = prop(\"Member\");\nvar aggregateMethodName = prop(\"AggregateMethodName\");\nvar value = prop(\"Value\");\nvar convert = function (mapper) { return function (values) { return Object.keys(values).reduce(mapper.bind(null, values), {}); }; };\nvar translateAggregate = convert(function (source, acc, field) { return set(field.toLowerCase(), acc, source[field]); });\nvar translateAggregates = convert(function (source, acc, field) { return set(field, acc, translateAggregate(source[field])); });\nvar valueOrDefault = function (value, defaultValue) { return isPresent(value) ? value : defaultValue; };\nvar normalizeGroup = function (group) { return ({\n    aggregates: group.Aggregates || group.aggregates,\n    field: group.Member || group.member || group.field,\n    hasSubgroups: group.HasSubgroups || group.hasSubgroups || false,\n    items: group.Items || group.items,\n    value: valueOrDefault(group.Key, valueOrDefault(group.key, group.value))\n}); };\nvar translateGroup = compose(function (_a) {\n    var field = _a.field, hasSubgroups = _a.hasSubgroups, value = _a.value, aggregates = _a.aggregates, items = _a.items;\n    return ({\n        aggregates: translateAggregates(aggregates),\n        field: field,\n        items: hasSubgroups ? items.map(translateGroup) : items,\n        value: value\n    });\n}, normalizeGroup);\n// tslint:disable:max-line-length\n/**\n * Converts the grouped result, which is returned into the `Data` field of the UI for ASP.NET MVC `ToDataSourceResult` method, to a comparable format.\n * @param data - The value of the `Data` field of the response.\n * @returns {GroupResult[]} - The converted result.\n */\nexport var translateDataSourceResultGroups = function (data) { return data.map(translateGroup); };\n/**\n * Converts the `AggregateResults` field content, which is returned by the UI for ASP.NET MVC `ToDataSourceResult` method, to a comparable format.\n * @param data - The value of the `AggregateResults` field of the response.\n * @returns {AggregateResult} - The converted result.\n */\n// tslint:enable:max-line-length\nexport var translateAggregateResults = function (data) { return ((data || []).reduce(function (acc, x) { return set(member(x), acc, set(aggregateMethodName(x).toLowerCase(), acc[member(x)] || {}, value(x))); }, {})); };\n","import { isPresent, isBlank } from '../utils';\nimport { getter } from '../accessor';\nvar compare = function (a, b) {\n    if (isBlank(a)) {\n        return a === b ? 0 : -1;\n    }\n    if (isBlank(b)) {\n        return 1;\n    }\n    if (a.localeCompare) {\n        return a.localeCompare(b);\n    }\n    return a > b ? 1 : (a < b ? -1 : 0);\n};\nvar compareDesc = function (a, b) { return compare(b, a); };\nvar descriptorAsFunc = function (descriptor) {\n    if (typeof descriptor.compare === 'function') {\n        return descriptor.compare;\n    }\n    var prop = getter(descriptor.field, true);\n    return function (a, b) { return (descriptor.dir === 'asc' ? compare : compareDesc)(prop(a), prop(b)); };\n};\nvar initial = function (_a, _b) { return 0; };\n// tslint:disable:max-line-length\n/**\n * Converts the `SortDescriptors` into a [Comparer]({% slug api_kendo-data-query_comparer %}) function that can be used through `Array.sort`. If multiple descriptors are provided, sorting is applied in a right-to-left order.\n * @param {SortDescriptor[]} descriptors - The descriptors which will be converted.\n * @returns {Comparer} - The produced function.\n *\n * @example\n * ```ts\n * import { composeSortDescriptors } from '@progress/kendo-data-query';\n *\n * const data = [{ name: \"Pork\" }, { name: \"Pepper\" }, { name: \"Beef\" } ];\n * const comparer = composeSortDescriptors([{ field: \"name\", dir: \"asc\" }]);\n * const result = data.sort(comparer);\n * // output: [{ name: \"Beef\" }, { name: \"Pepper\" }, { name: \"Pork\" }];\n * ```\n */\n// tslint:enable:max-line-length\nexport var composeSortDescriptors = function (descriptors) { return (descriptors\n    .filter(function (x) { return isPresent(x.dir) || isPresent(x.compare); })\n    .map(function (descriptor) { return descriptorAsFunc(descriptor); })\n    .reduce(function (acc, curr) { return function (a, b) { return acc(a, b) || curr(a, b); }; }, initial)); };\n","import { isPresent, isNumeric, isDate } from './utils';\nimport { getter } from './accessor';\nvar valueToString = function (value) {\n    value = isPresent(value) && value.getTime ? value.getTime() : value;\n    return value + \"\";\n};\n/**\n * @hidden\n */\nexport var groupCombinator = function (field) {\n    var prop = getter(field, true);\n    var position = 0;\n    return function (agg, value) {\n        agg[field] = agg[field] || {};\n        var groupValue = prop(value);\n        var key = valueToString(groupValue);\n        var values = agg[field][key] || { __position: position++, aggregates: {}, items: [], value: groupValue };\n        values.items.push(value);\n        agg[field][key] = values;\n        return agg;\n    };\n};\n/**\n * @hidden\n */\nexport var expandAggregates = function (result) {\n    if (result === void 0) { result = {}; }\n    Object.keys(result).forEach(function (field) {\n        var aggregates = result[field];\n        Object.keys(aggregates).forEach(function (aggregate) {\n            aggregates[aggregate] = aggregates[aggregate].result();\n        });\n    });\n    return result;\n};\nvar aggregatesFuncs = function (name) { return ({\n    average: function () {\n        var value = 0;\n        var count = 0;\n        return {\n            calc: function (curr) {\n                if (isNumeric(curr)) {\n                    value += curr;\n                    count++;\n                }\n                else {\n                    value = curr;\n                }\n            },\n            result: function () { return isNumeric(value) ? value / count : value; }\n        };\n    },\n    count: function () {\n        var state = 0;\n        return {\n            calc: function () { return state++; },\n            result: function () { return state; }\n        };\n    },\n    max: function () {\n        var state = Number.NEGATIVE_INFINITY;\n        return {\n            calc: function (value) {\n                state = isNumeric(state) || isDate(state) ? state : value;\n                if (state < value && (isNumeric(value) || isDate(value))) {\n                    state = value;\n                }\n            },\n            result: function () { return state; }\n        };\n    },\n    min: function () {\n        var state = Number.POSITIVE_INFINITY;\n        return {\n            calc: function (value) {\n                state = isNumeric(state) || isDate(state) ? state : value;\n                if (state > value && (isNumeric(value) || isDate(value))) {\n                    state = value;\n                }\n            },\n            result: function () { return state; }\n        };\n    },\n    sum: function () {\n        var state = 0;\n        return {\n            calc: function (value) {\n                value = isPresent(value) ? value : 0;\n                state += value;\n            },\n            result: function () { return state; }\n        };\n    }\n}[name]()); };\n/**\n * @hidden\n */\nexport var aggregatesCombinator = function (descriptors) {\n    var functions = descriptors.map(function (descriptor) {\n        var fieldAccessor = getter(descriptor.field, true);\n        var aggregateName = (descriptor.aggregate || \"\").toLowerCase();\n        var aggregateAccessor = getter(aggregateName, true);\n        return function (state, value) {\n            var fieldAggregates = state[descriptor.field] || {};\n            var aggregateFunction = aggregateAccessor(fieldAggregates)\n                || aggregatesFuncs(aggregateName);\n            aggregateFunction.calc(fieldAccessor(value));\n            fieldAggregates[descriptor.aggregate] = aggregateFunction;\n            state[descriptor.field] = fieldAggregates;\n            return state;\n        };\n    });\n    return function (state, value) { return functions.reduce(function (agg, calc) { return calc(agg, value); }, state); };\n};\n/**\n * @hidden\n * Adds the value to the `arr` and produces a new array.\n *\n * > The original array will be modified.\n */\nexport var concat = function (arr, value) {\n    arr.push(value);\n    return arr;\n};\n/**\n * @hidden\n * Returns a reducer that will apply the specified transformation to the value.\n */\nexport var map = function (transform) { return (function (reduce) { return (function (acc, curr, index) { return reduce(acc, transform(curr, index)); }); }); };\n/**\n * @hidden\n * Returns a reducer that will filter out items which do not match the `Predicate`.\n */\nexport var filter = function (predicate) { return (function (reduce) { return (function (acc, curr) { return predicate(curr) ? reduce(acc, curr) : acc; }); }); };\n/**\n * @hidden\n */\nexport var isTransformerResult = function (source) {\n    return isPresent(source.__value);\n};\nvar reduced = function (x) {\n    if (isTransformerResult(x)) {\n        return x;\n    }\n    return {\n        __value: x,\n        reduced: true\n    };\n};\n/**\n * @hidden\n * Returns a reducer that will take the specified number of items.\n */\nexport var take = function (count) { return (function (reduce) { return (function (acc, curr) { return count-- > 0 ? reduce(acc, curr) : reduced(acc); }); }); };\n/**\n * @hidden\n * Returns a reducer that will take the specified number of items.\n */\nexport var takeWhile = function (predicate) { return (function (reduce) { return (function (acc, curr) { return predicate(curr) ? reduce(acc, curr) : reduced(acc); }); }); };\n/**\n * @hidden\n * Returns a reducer that will skip the specified number of items.\n */\nexport var skip = function (count) { return (function (reduce) { return (function (acc, curr) { return count-- <= 0 ? reduce(acc, curr) : acc; }); }); };\n/**\n * @hidden\n * Transforms the data by applying the supplied transformer.\n */\nexport var exec = function (transform, initialValue, data) {\n    var result = initialValue;\n    for (var idx = 0, length_1 = data.length; idx < length_1; idx++) {\n        result = transform(result, data[idx], idx);\n        if (isTransformerResult(result)) {\n            result = result.__value;\n            break;\n        }\n    }\n    return result;\n};\n","import { exec, map, aggregatesCombinator, expandAggregates } from '../transducers';\nvar identity = map(function (x) { return x; });\n// tslint:disable:max-line-length\n/**\n * Applies the specified [`AggregateDescriptors`]({% slug api_kendo-data-query_aggregatedescriptor %}) to the data. Returns an [`AggregateResult`]({% slug api_kendo-data-query_aggregateresult %}) instance.\n *\n * @example\n * ```ts\n * const data = [\n *    { unitPrice: 23, unitsInStock: 21 },\n *    { unitPrice: 10, unitsInStock: 12 },\n *    { unitPrice: 20, unitsInStock: 33 }\n * ];\n *\n * const result = aggregateBy(data, [\n *   { aggregate: \"sum\", field: \"unitPrice\" },\n *   { aggregate: \"sum\", field: \"unitsInStock\" }\n * ]);\n *\n * //output:\n * // {\n * //     \"unitPrice\": { \"sum\": 53 },\n * //     \"unitsInStock\": { \"sum\": 66 }\n * // }\n * ```\n * @param {T[]} data - The data on which the calculation will be executed.\n * @param {AggregateDescriptor[]} descriptors - The aggregate operations that will be executed.\n * @param {any} transformers - For internal use.\n * @returns {AggregateResult} - The aggregated result.\n * For more information, refer to the [aggregateresult](slug:api_kendo-data-query_aggregateresult) configuration.\n */\n// tslint:enable:max-line-length\nexport var aggregateBy = function (data, descriptors, transformers) {\n    if (descriptors === void 0) { descriptors = []; }\n    if (transformers === void 0) { transformers = identity; }\n    var initialValue = {};\n    if (!descriptors.length) {\n        return initialValue;\n    }\n    var result = exec(transformers(aggregatesCombinator(descriptors)), initialValue, data);\n    return expandAggregates(result);\n};\n","import { isCompositeFilterDescriptor } from \"./filter-descriptor.interface\";\nimport { getter } from \"../accessor\";\nimport { isFunction, isPresent, isDate, isString, isBlank } from \"../utils\";\nvar logic = {\n    \"or\": {\n        concat: function (acc, fn) { return function (a) { return acc(a) || fn(a); }; },\n        identity: function () { return false; }\n    },\n    \"and\": {\n        concat: function (acc, fn) { return function (a) { return acc(a) && fn(a); }; },\n        identity: function () { return true; }\n    }\n};\nvar operatorsMap = {\n    contains: function (a, b) { return (a || \"\").indexOf(b) >= 0; },\n    doesnotcontain: function (a, b) { return (a || \"\").indexOf(b) === -1; },\n    doesnotendwith: function (a, b) { return (a || \"\").indexOf(b, (a || \"\").length - (b || \"\").length) < 0; },\n    doesnotstartwith: function (a, b) { return (a || \"\").lastIndexOf(b, 0) === -1; },\n    endswith: function (a, b) { return (a || \"\").indexOf(b, (a || \"\").length - (b || \"\").length) >= 0; },\n    eq: function (a, b) { return a === b; },\n    gt: function (a, b) { return a > b; },\n    gte: function (a, b) { return a >= b; },\n    isempty: function (a) { return a === ''; },\n    isnotempty: function (a) { return a !== ''; },\n    isnotnull: function (a) { return isPresent(a); },\n    isnull: function (a) { return isBlank(a); },\n    lt: function (a, b) { return a < b; },\n    lte: function (a, b) { return a <= b; },\n    neq: function (a, b) { return a != b; },\n    startswith: function (a, b) { return (a || \"\").lastIndexOf(b, 0) === 0; }\n};\nvar dateRegExp = /^\\/Date\\((.*?)\\)\\/$/;\nvar convertValue = function (value, ignoreCase) {\n    if (value != null && isString(value)) {\n        var date = dateRegExp.exec(value);\n        if (date) {\n            return new Date(+date[1]).getTime();\n        }\n        else if (ignoreCase) {\n            return value.toLowerCase();\n        }\n    }\n    else if (value != null && isDate(value)) {\n        return value.getTime();\n    }\n    return value;\n};\nvar typedGetter = function (prop, value, ignoreCase) {\n    if (!isPresent(value)) {\n        return prop;\n    }\n    var acc = prop;\n    if (isString(value)) {\n        var date = dateRegExp.exec(value);\n        if (date) {\n            value = new Date(+date[1]);\n        }\n        else {\n            acc = function (a) {\n                var x = prop(a);\n                if (x === null) {\n                    return x;\n                }\n                var stringValue = typeof x === 'string' ? x : x + \"\";\n                return ignoreCase ? stringValue.toLowerCase() : stringValue;\n            };\n        }\n    }\n    if (isDate(value)) {\n        return function (a) {\n            var x = acc(a);\n            return isDate(x) ? x.getTime() : x;\n        };\n    }\n    return acc;\n};\nvar transformFilter = function (_a) {\n    var field = _a.field, ignoreCase = _a.ignoreCase, value = _a.value, operator = _a.operator;\n    field = !isPresent(field) ? function (a) { return a; } : field;\n    ignoreCase = isPresent(ignoreCase) ? ignoreCase : true;\n    var itemProp = typedGetter(isFunction(field) ? field : getter(field, true), value, ignoreCase);\n    value = convertValue(value, ignoreCase);\n    var op = isFunction(operator) ? operator : operatorsMap[operator];\n    return function (a) { return op(itemProp(a), value, ignoreCase); };\n};\n/**\n * @hidden\n */\nexport var transformCompositeFilter = function (filter) {\n    var combiner = logic[filter.logic];\n    return filter.filters\n        .filter(isPresent)\n        .map(function (x) { return isCompositeFilterDescriptor(x) ? transformCompositeFilter(x) : transformFilter(x); })\n        .reduce(combiner.concat, combiner.identity);\n};\n","import { isPresent } from '../utils';\nimport { isCompositeFilterDescriptor } from './filter-descriptor.interface';\nimport { normalizeFilters } from './filter.operators';\nimport { transformCompositeFilter } from \"./filter-no-eval\";\n// tslint:disable:max-line-length\n/**\n * Creates a [Predicate]({% slug api_kendo-data-query_predicate %}) function for the specified [CompositeFilterDescriptor]({% slug api_kendo-data-query_compositefilterdescriptor %}).\n *\n * @param {CompositeFilterDescriptor} descriptor - The descriptor for which the predicate is created.\n * @returns {Predicate} - The created function instance.\n *\n * @example\n * ```ts\n * import { compileFilter } from '@progress/kendo-data-query';\n *\n * const data = [{ name: \"Pork\" }, { name: \"Pepper\" }, { name: \"Beef\" } ];\n * const predicate = compileFilter({ logic: \"and\", filters: [{ field: \"name\", operator: \"startswith\", value: \"P\" }] });\n * const result = data.filter(predicate);\n *\n * ```\n */\n// tslint:enable:max-line-length\nexport var compileFilter = function (descriptor) {\n    if (!descriptor || descriptor.filters.length === 0) {\n        return function () { return true; };\n    }\n    return transformCompositeFilter(descriptor);\n};\n// tslint:disable:max-line-length\n/**\n * Filters the provided array according to the specified [CompositeFilterDescriptor]({% slug api_kendo-data-query_compositefilterdescriptor %}).\n *\n * @param {T[]} data - The data that will be filtered.\n * @param {(CompositeFilterDescriptor | FilterDescriptor)} descriptor - The filter criteria that will be applied.\n * @returns {T[]} - The filtered data.\n *\n * @example\n * ```ts\n * import { filterBy } from '@progress/kendo-data-query';\n *\n * const data = [\n *  { name: \"Pork\", category: \"Food\", subcategory: \"Meat\" },\n *  { name: \"Pepper\", category: \"Food\", subcategory: \"Vegetables\" },\n *  { name: \"Beef\", category: \"Food\", subcategory: \"Meat\" }\n * ];\n *\n * const result = filterBy(data, {\n *     logic: 'and',\n *     filters: [\n *           { field: \"name\", operator: \"startswith\", value: \"p\", ignoreCase: true },\n *           { field: \"subcategory\", operator: \"eq\", value: \"Meat\" },\n *     ]\n * });\n *\n * // output:\n * // [{ \"name\": \"Pork\", \"category\": \"Food\", \"subcategory\": \"Meat\" }]\n * ```\n */\n// tslint:enable:max-line-length\nexport var filterBy = function (data, descriptor) {\n    if (!isPresent(descriptor) || (isCompositeFilterDescriptor(descriptor) && descriptor.filters.length === 0)) {\n        return data;\n    }\n    return data.filter(compileFilter(normalizeFilters(descriptor)));\n};\n","import { exec, map, groupCombinator } from '../transducers';\nimport { isArray, isPresent } from '../utils';\nimport { aggregateBy } from './aggregate.operators';\nimport { filterBy } from '../filtering/filter-expression.factory';\n/**\n * @hidden\n */\nexport var normalizeGroups = function (descriptors) {\n    descriptors = isArray(descriptors) ? descriptors : [descriptors];\n    return descriptors.map(function (x) { return Object.assign({ dir: \"asc\" }, x); });\n};\nvar identity = map(function (x) { return x; });\n/**\n * Groups the provided data according to the specified descriptors.\n *\n * @param {Array} data - The data that will be grouped.\n * @param {GroupDescriptor[]} descriptors - The descriptors.\n * @param {any} transformers - For internal use.\n * @param {Array} originalData - For internal use.\n * @returns {(Array<GroupResult<T>> | T[])} - The grouped data.\n *\n * @example\n * ```ts\n *\n * import { groupBy } from '@progress/kendo-data-query';\n *\n * const data = [\n *     { name: \"Pork\", category: \"Food\", subcategory: \"Meat\" },\n *     { name: \"Pepper\", category: \"Food\", subcategory: \"Vegetables\" },\n *     { name: \"Beef\", category: \"Food\", subcategory: \"Meat\" }\n * ];\n *\n * const result = groupBy(data, [{ field: \"subcategory\" }]);\n * ```\n */\nexport var groupBy = function (data, descriptors, transformers, originalData) {\n    if (descriptors === void 0) { descriptors = []; }\n    if (transformers === void 0) { transformers = identity; }\n    if (originalData === void 0) { originalData = data; }\n    descriptors = normalizeGroups(descriptors);\n    if (!descriptors.length) {\n        return data;\n    }\n    var descriptor = descriptors[0];\n    var initialValue = {};\n    var view = exec(transformers(groupCombinator(descriptor.field)), initialValue, data);\n    var result = [];\n    Object.keys(view).forEach(function (field) {\n        Object.keys(view[field]).forEach(function (value) {\n            var group = view[field][value];\n            var aggregateResult = {};\n            var filteredData = originalData;\n            if (isPresent(descriptor.aggregates)) {\n                filteredData = filterBy(originalData, {\n                    field: descriptor.field,\n                    ignoreCase: false,\n                    operator: 'eq',\n                    value: group.value\n                });\n                aggregateResult = aggregateBy(filteredData, descriptor.aggregates);\n            }\n            result[group.__position] = {\n                aggregates: aggregateResult,\n                field: field,\n                items: descriptors.length > 1 ?\n                    groupBy(group.items, descriptors.slice(1), identity, filteredData)\n                    : group.items,\n                value: group.value\n            };\n        });\n    });\n    return result;\n};\n","import { __spreadArray } from \"tslib\";\nimport { isPresent, isString } from './utils';\nimport { composeSortDescriptors } from './sorting/sort-array.operator';\nimport { groupBy, normalizeGroups } from './grouping/group.operators';\nimport { normalizeFilters } from './filtering/filter.operators';\nimport { compileFilter } from './filtering/filter-expression.factory';\nimport { exec, skip, take, filter, concat } from './transducers';\nimport { getter } from './accessor';\nimport { compose } from './funcs';\n/**\n * Orders the specified array according to the provided sort descriptors.\n *\n * @param {T[]} data - The data to be sorted.\n * @param {SortDescriptor[]} descriptors - The descriptors by which the data will be sorted.\n * @returns {T[]} - The sorted data.\n *\n * @example\n * ```ts\n * import { orderBy } from '@progress/kendo-data-query';\n *\n * const data = [\n *     { name: \"Pork\", category: \"Food\", subcategory: \"Meat\" },\n *     { name: \"Pepper\", category: \"Food\", subcategory: \"Vegetables\" },\n *     { name: \"Beef\", category: \"Food\", subcategory: \"Meat\" }\n * ];\n *\n * const sortDesc: SortDescriptor[] = [{ field: \"name\", dir: \"asc\" }];\n *\n * const result = orderBy(data, sortDesc);\n * ```\n */\nexport var orderBy = function (data, descriptors) {\n    if (descriptors.some(function (x) { return isPresent(x.dir) || isPresent(x.compare); })) {\n        data = data.slice(0);\n        var comparer = composeSortDescriptors(descriptors);\n        data.sort(comparer);\n    }\n    return data;\n};\nvar defaultComparer = function (a, b) { return a === b; };\nvar normalizeComparer = function (comparer) {\n    if (isString(comparer)) {\n        var accessor_1 = getter(comparer);\n        comparer = function (a, b) { return accessor_1(a) === accessor_1(b); };\n    }\n    return comparer;\n};\nvar _distinct = function (data, comparer) {\n    return data.filter(function (x, idx, xs) { return xs.findIndex(comparer.bind(null, x)) === idx; });\n};\n/**\n * Reduces the provided array so it contains only unique values.\n *\n * @param {T[]} data - The array that will be reduced.\n * @param {(Comparer | string)} comparer - An optional custom comparer function or the field name that will be used for comparison.\n * @returns {T[]} - The reduced data.\n *\n * @example\n * ```ts\n * import { distinct } from '@progress/kendo-data-query';\n *\n * const data = [\n *     { name: \"Pork\", category: \"Food\", subcategory: \"Meat\" },\n *     { name: \"Pepper\", category: \"Food\", subcategory: \"Vegetables\" },\n *     { name: \"Beef\", category: \"Food\", subcategory: \"Meat\" }\n * ];\n *\n * const result = distinct(data, \"subcategory\");\n *\n * // output:\n * // result => [\n * //     { name: \"Pork\", category: \"Food\", subcategory: \"Meat\" },\n * //     { name: \"Pepper\", category: \"Food\", subcategory: \"Vegetables\" }\n * // ];\n * ```\n */\nexport var distinct = function (data, comparer) {\n    if (comparer === void 0) { comparer = defaultComparer; }\n    return _distinct(data, normalizeComparer(comparer));\n};\n/**\n * @hidden\n */\nexport var count = function (data, predicate) {\n    var counter = 0;\n    for (var idx = 0, length_1 = data.length; idx < length_1; idx++) {\n        if (predicate(data[idx])) {\n            counter++;\n        }\n    }\n    return counter;\n};\n/**\n * @hidden\n */\nexport var limit = function (data, predicate) {\n    if (predicate) {\n        return data.filter(predicate);\n    }\n    return data;\n};\n/**\n * Applies the specified operation descriptors to the data.\n *\n * @param {T[]} data - The data to be processed.\n * @param {State} state - The operation descriptors that will be applied to the data.\n * @returns {DataResult} - The processed data.\n *\n * @example\n * ```ts\n *\n * const result = process(data, {\n *     skip: 10,\n *     take: 20,\n *     group: [{\n *       field: 'category.categoryName',\n *             aggregates: [\n *                   { aggregate: \"sum\", field: \"unitPrice\" },\n *                   { aggregate: \"sum\", field: \"unitsInStock\" }\n *             ]\n *       }],\n *     sort: [{ field: 'productName', dir: 'desc' }],\n *     filter: {\n *         logic: \"or\",\n *         filters: [\n *           { field: \"discontinued\", operator: \"eq\", value: true },\n *           { field: \"unitPrice\", operator: \"lt\", value: 22 }\n *         ]\n *     }\n * });\n *\n * ```\n */\nexport var process = function (data, state) {\n    var skipCount = state.skip, takeCount = state.take, filterDescriptor = state.filter, sort = state.sort, group = state.group;\n    var sortDescriptors = __spreadArray(__spreadArray([], normalizeGroups(group || []), true), sort || [], true);\n    if (sortDescriptors.length) {\n        data = orderBy(data, sortDescriptors);\n    }\n    var hasFilters = isPresent(filterDescriptor) && filter.length;\n    var hasGroups = isPresent(group) && group.length;\n    if (!hasFilters && !hasGroups) {\n        return {\n            data: takeCount ? data.slice(skipCount, skipCount + takeCount) : data,\n            total: data.length\n        };\n    }\n    var total;\n    var transformers = [];\n    var predicate;\n    if (hasFilters) {\n        predicate = compileFilter(normalizeFilters(filterDescriptor));\n        total = count(data, predicate);\n        transformers.push(filter(predicate));\n    }\n    else {\n        total = data.length;\n    }\n    if (isPresent(skipCount) && isPresent(takeCount)) {\n        transformers.push(skip(skipCount));\n        transformers.push(take(takeCount));\n    }\n    if (transformers.length) {\n        var transform = compose.apply(void 0, transformers);\n        var result = hasGroups ?\n            groupBy(data, group, transform, limit(data, predicate)) :\n            exec(transform(concat), [], data);\n        return { data: result, total: total };\n    }\n    return {\n        data: hasGroups ? groupBy(data, group) : data,\n        total: total\n    };\n};\n"],"names":["templateObject_1","templateObject_2","x","isPresent","value","undefined","isBlank","isArray","Array","isFunction","isString","isNotNullOrEmptyString","trim","length","isNullOrEmptyString","isNumeric","isNaN","parseFloat","isDate","getTime","isCompositeFilterDescriptor","source","filters","ifElse","predicate","right","left","compose","args","_i","arguments","data","reduceRight","acc","curr","identity","wrapIf","str","concat","toUTC","date","Date","UTC","getFullYear","getMonth","getDate","getHours","getMinutes","getSeconds","getMilliseconds","quote","_a","field","ignoreCase","operator","replace","encodeValue","encodeURIComponent","toLower","normalizeField","isStringValue","isDateValue","serializeFilters","map","join","filter","brackets","normalizeOperator","descriptor","key","result","Object","assign","equal","equals","equalto","ge","greater","greaterthan","greaterthanequal","isempty","isequalto","isgreaterthan","isgreaterthanorequalto","islessthan","islessthanorequalto","isnotempty","isnotequalto","isnull","le","less","lessthan","lessthanequal","ne","notequal","notequals","notequalto","notsubstringof","toLowerCase","normalizeFilters","logic","normalizeDescriptor","singleOperatorFormatter","stringFormat","formatter","stringFnOperator","settings","fnFormatter","dateOperator","utcDates","toISOString","formatDate","ifDate","numericOperator","typedOperator","stringOperator","appendEqual","nonValueExpression","serialize","contains","doesnotcontain","endswith","eq","gt","gte","isnotnull","lt","lte","neq","startswith","filterOperators","serializeAll","serializeFilter","serializeSort","orderby","sort","dir","order","emptyString","serializeKey","strings","val","a","b","toODataString","state","keys","skip","take","rules","getterCache","FIELD_REGEX","obj","what","FilterOperator","getter","safe","fields","_","index","indexAccessor","push","idx","pairwise","empty","has","accessor","isNotEmpty","isNotEmptyArray","runOrEmpty","fn","formatDescriptors","sanitizeDateLiterals","apply","s","RegExp","removeAfterDot","slice","indexOf","directionFormatter","_b","aggregates","group","formatSort","formatGroup","formatAggregates","aggregate","formatDateValue","JSON","stringify","transformSkip","Math","floor","transformTake","transformGroup","transformSort","transformAggregates","serializePage","serializePageSize","serializeGroup","serializeAggregates","hasField","filterFormatter","dateFormatter","encode","typedFormatter","toDataSourceRequestString","values","reduce","toDataSourceRequest","set","target","prop","fieldName","g1","member","aggregateMethodName","convert","mapper","bind","translateAggregate","translateAggregates","valueOrDefault","defaultValue","translateGroup","hasSubgroups","items","Aggregates","Member","HasSubgroups","Items","Key","translateDataSourceResultGroups","translateAggregateResults","compare","localeCompare","compareDesc","descriptorAsFunc","initial","composeSortDescriptors","descriptors","groupCombinator","position","agg","groupValue","valueToString","__position","aggregatesCombinator","functions","fieldAccessor","aggregateName","aggregateAccessor","fieldAggregates","aggregateFunction","average","count","calc","max","Number","NEGATIVE_INFINITY","min","POSITIVE_INFINITY","sum","arr","transform","isTransformerResult","__value","reduced","exec","initialValue","length_1","aggregateBy","transformers","forEach","expandAggregates","operatorsMap","doesnotendwith","doesnotstartwith","lastIndexOf","dateRegExp","transformFilter","itemProp","stringValue","typedGetter","convertValue","op","transformCompositeFilter","combiner","compileFilter","filterBy","normalizeGroups","groupBy","originalData","view","aggregateResult","filteredData","orderBy","some","comparer","defaultComparer","distinct","xs","findIndex","_distinct","accessor_1","normalizeComparer","process","skipCount","takeCount","filterDescriptor","sortDescriptors","total","hasFilters","hasGroups","counter","limit"],"sourceRoot":""}