@servicetitan/data-query 31.2.0 → 31.3.0

package/dist/grouping/aggregate.operators.js

@@ -1,5 +1,5 @@
 import { exec, map, aggregatesCombinator, expandAggregates } from '../transducers';
-const identity = map(x => x);
+const identity = map((x)=>x);
 // tslint:disable:max-line-length
 /**
  * Applies the specified [`AggregateDescriptors`]({% slug api_kendo-data-query_aggregatedescriptor %}) to the data. Returns an [`AggregateResult`]({% slug api_kendo-data-query_aggregateresult %}) instance.
@@ -28,9 +28,8 @@ const identity = map(x => x);
  * @param {any} transformers - For internal use.
  * @returns {AggregateResult} - The aggregated result.
  * For more information, refer to the [`aggregateresult`]({% slug api_kendo-data-query_aggregateresult %}) configuration.
- */
-// tslint:enable:max-line-length
-export const aggregateBy = (data, descriptors = [], preprocessors = {}, transformers = identity) => {
+ */ // tslint:enable:max-line-length
+export const aggregateBy = (data, descriptors = [], preprocessors = {}, transformers = identity)=>{
     const initialValue = {};
     if (!descriptors.length) {
         return initialValue;
@@ -38,4 +37,5 @@ export const aggregateBy = (data, descriptors = [], preprocessors = {}, transfor
     const result = exec(transformers(aggregatesCombinator(descriptors, preprocessors)), initialValue, data);
     return expandAggregates(result);
 };
+
 //# sourceMappingURL=aggregate.operators.js.map

package/dist/grouping/aggregate.operators.js.map

@@ -1 +1 @@
-{"version":3,"file":"aggregate.operators.js","sourceRoot":"","sources":["../../src/grouping/aggregate.operators.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,GAAG,EAAE,oBAAoB,EAAE,gBAAgB,EAAmB,MAAM,gBAAgB,CAAC;AAqBpG,MAAM,QAAQ,GAAG,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;AAE7B,iCAAiC;AACjC;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,gCAAgC;AAChC,MAAM,CAAC,MAAM,WAAW,GAAG,CAAI,IAAS,EAAE,cAAqC,EAAE,EAAE,gBAAkC,EAAE,EAAE,eAAoD,QAAQ,EAAmB,EAAE;IACtM,MAAM,YAAY,GAAG,EAAE,CAAC;IAExB,IAAI,CAAC,WAAW,CAAC,MAAM,EAAE,CAAC;QACtB,OAAO,YAAY,CAAC;IACxB,CAAC;IAED,MAAM,MAAM,GAAG,IAAI,CAAC,YAAY,CAAC,oBAAoB,CAAC,WAAW,EAAE,aAAa,CAAC,CAAC,EAAE,YAAY,EAAE,IAAI,CAAC,CAAC;IACxG,OAAO,gBAAgB,CAAC,MAAM,CAAC,CAAC;AACpC,CAAC,CAAC"}
+{"version":3,"sources":["../../src/grouping/aggregate.operators.ts"],"sourcesContent":["import { exec, map, aggregatesCombinator, expandAggregates, AggregateResult } from '../transducers';\nimport { Combinator, Transformer, Preprocessors } from '../common.interfaces';\n\n/**\n * The aggregate operation.\n *\n * For more information, refer to the [`aggregateBy`]({% slug api_kendo-data-query_aggregateby %}) method.\n */\nexport interface AggregateDescriptor {\n\n    /**\n     * The name of the record field on which the function will be executed.\n     */\n    field: string;\n\n    /**\n     * The aggregate function that will be calculated.\n     */\n    aggregate: 'count' | 'sum' | 'average' | 'min' | 'max' | 'count_distinct';\n}\n\nconst identity = map(x => x);\n\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-no-run\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 const aggregateBy = <T>(data: T[], descriptors: AggregateDescriptor[] = [], preprocessors: Preprocessors<T> = {}, transformers: (reduce: Combinator) => Transformer = identity): AggregateResult => {\n    const initialValue = {};\n\n    if (!descriptors.length) {\n        return initialValue;\n    }\n\n    const result = exec(transformers(aggregatesCombinator(descriptors, preprocessors)), initialValue, data);\n    return expandAggregates(result);\n};\n"],"names":["exec","map","aggregatesCombinator","expandAggregates","identity","x","aggregateBy","data","descriptors","preprocessors","transformers","initialValue","length","result"],"mappings":"AAAA,SAASA,IAAI,EAAEC,GAAG,EAAEC,oBAAoB,EAAEC,gBAAgB,QAAyB,iBAAiB;AAqBpG,MAAMC,WAAWH,IAAII,CAAAA,IAAKA;AAE1B,iCAAiC;AACjC;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2BC,GACD,gCAAgC;AAChC,OAAO,MAAMC,cAAc,CAAIC,MAAWC,cAAqC,EAAE,EAAEC,gBAAkC,CAAC,CAAC,EAAEC,eAAoDN,QAAQ;IACjL,MAAMO,eAAe,CAAC;IAEtB,IAAI,CAACH,YAAYI,MAAM,EAAE;QACrB,OAAOD;IACX;IAEA,MAAME,SAASb,KAAKU,aAAaR,qBAAqBM,aAAaC,iBAAiBE,cAAcJ;IAClG,OAAOJ,iBAAiBU;AAC5B,EAAE"}

package/dist/grouping/group-descriptor.interface.js

@@ -1,3 +1,5 @@
-export {};
-// tslint:enable:max-line-length
+/**
+ * The result of the group operation.
+ */ export { }; // tslint:enable:max-line-length
+
 //# sourceMappingURL=group-descriptor.interface.js.map

package/dist/grouping/group-descriptor.interface.js.map

@@ -1 +1 @@
-{"version":3,"file":"group-descriptor.interface.js","sourceRoot":"","sources":["../../src/grouping/group-descriptor.interface.ts"],"names":[],"mappings":";AA2CA,gCAAgC"}
+{"version":3,"sources":["../../src/grouping/group-descriptor.interface.ts"],"sourcesContent":["import { AggregateDescriptor } from './aggregate.operators';\nimport { AggregateResult } from '../transducers';\n\n// tslint:disable:max-line-length\n/**\n * The group descriptor used by the `groupBy` method.\n */\nexport interface GroupDescriptor {\n    /**\n     * The data item field by which the data will be grouped.\n     */\n    field: string;\n    /**\n     * The sort order of the group.\n     */\n    dir?: 'asc' | 'desc';\n    /**\n     * The aggregates which are calculated during grouping.\n     */\n    aggregates?: Array<AggregateDescriptor>;\n}\n\n/**\n * The result of the group operation.\n */\nexport interface GroupResult<T = Object> {\n    /**\n     * Contains either the subgroups, or the data items.\n     */\n    items: T[] | GroupResult<T>[];\n    /**\n     * The aggregated values for the group. An [`AggregateResult`]({% slug api_kendo-data-query_aggregateresult %}) instance.\n     */\n    aggregates: AggregateResult;\n    /**\n     * The field by which the data items are grouped.\n     */\n    field: string;\n    /**\n     * The group key.\n     */\n    value: any;\n}\n// tslint:enable:max-line-length\n"],"names":[],"mappings":"AAsBA;;CAEC,GACD,WAiBC,CACD,gCAAgC"}

package/dist/grouping/group.operators.js

@@ -4,12 +4,15 @@ import { aggregateBy } from './aggregate.operators';
 import { filterBy } from '../filtering/filter-expression.factory';
 /**
  * @hidden
- */
-export const normalizeGroups = (descriptors) => {
-    descriptors = isArray(descriptors) ? descriptors : [descriptors];
-    return descriptors.map(x => Object.assign({ dir: "asc" }, x));
+ */ export const normalizeGroups = (descriptors)=>{
+    descriptors = isArray(descriptors) ? descriptors : [
+        descriptors
+    ];
+    return descriptors.map((x)=>Object.assign({
+            dir: "asc"
+        }, x));
 };
-const identity = map(x => x);
+const identity = map((x)=>x);
 /**
  * Groups the provided data according to the specified descriptors.
  *
@@ -32,8 +35,7 @@ const identity = map(x => x);
  *
  * const result = groupBy(data, [{ field: "subcategory" }]);
  * ```
- */
-export const groupBy = (data, descriptors = [], preprocessors = {}, transformers = identity, originalData = data) => {
+ */ export const groupBy = (data, descriptors = [], preprocessors = {}, transformers = identity, originalData = data)=>{
     descriptors = normalizeGroups(descriptors);
     if (!descriptors.length) {
         return data;
@@ -42,8 +44,8 @@ export const groupBy = (data, descriptors = [], preprocessors = {}, transformers
     const initialValue = {};
     const view = exec(transformers(groupCombinator(descriptor.field, preprocessors)), initialValue, data);
     const result = [];
-    Object.keys(view).forEach(field => {
-        Object.keys(view[field]).forEach(value => {
+    Object.keys(view).forEach((field)=>{
+        Object.keys(view[field]).forEach((value)=>{
             const group = view[field][value];
             let aggregateResult = {};
             let filteredData = originalData;
@@ -59,13 +61,12 @@ export const groupBy = (data, descriptors = [], preprocessors = {}, transformers
             result[group.__position] = {
                 aggregates: aggregateResult,
                 field: field,
-                items: descriptors.length > 1 ?
-                    groupBy(group.items, descriptors.slice(1), preprocessors, identity, filteredData)
-                    : group.items,
+                items: descriptors.length > 1 ? groupBy(group.items, descriptors.slice(1), preprocessors, identity, filteredData) : group.items,
                 value: group.value
             };
         });
     });
     return result;
 };
+
 //# sourceMappingURL=group.operators.js.map

package/dist/grouping/group.operators.js.map

@@ -1 +1 @@
-{"version":3,"file":"group.operators.js","sourceRoot":"","sources":["../../src/grouping/group.operators.ts"],"names":[],"mappings":"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"}
+{"version":3,"sources":["../../src/grouping/group.operators.ts"],"sourcesContent":["import { GroupDescriptor, GroupResult } from './group-descriptor.interface';\nimport { exec, map, groupCombinator } from '../transducers';\nimport { isArray, isPresent } from '../utils';\nimport { aggregateBy } from './aggregate.operators';\nimport { filterBy } from '../filtering/filter-expression.factory';\nimport { Reducer, Preprocessors } from '../common.interfaces';\n\n/**\n * @hidden\n */\nexport const normalizeGroups = (descriptors) => {\n    descriptors = isArray(descriptors) ? descriptors : [descriptors];\n    return descriptors.map(x => Object.assign({ dir: \"asc\" }, x));\n};\n\nconst identity: Reducer = map(x => x);\n\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-no-run\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 const groupBy = <T>(\n    data: T[],\n    descriptors: GroupDescriptor[] = [],\n    preprocessors: Preprocessors<T> = {},\n    transformers = identity,\n    originalData: T[] = data\n): Array<GroupResult> | T[] => {\n\n    descriptors = normalizeGroups(descriptors);\n\n    if (!descriptors.length) {\n        return data;\n    }\n\n    const descriptor = descriptors[0];\n    const initialValue = {};\n\n    const view = exec(transformers(groupCombinator(descriptor.field, preprocessors)), initialValue, data);\n\n    const result = [];\n\n    Object.keys(view).forEach(field => {\n        Object.keys(view[field]).forEach(value => {\n            const group = view[field][value];\n\n            let aggregateResult = {};\n            let filteredData = originalData;\n\n            if (isPresent(descriptor.aggregates)) {\n\n                filteredData = filterBy(originalData, {\n                    field: descriptor.field,\n                    ignoreCase: false,\n                    operator: 'eq',\n                    value: group.value\n                }, preprocessors);\n\n                aggregateResult = aggregateBy(filteredData, descriptor.aggregates, preprocessors);\n            }\n\n            result[group.__position] = {\n                aggregates: aggregateResult,\n                field: field,\n                items: descriptors.length > 1 ?\n                    groupBy(group.items, descriptors.slice(1), preprocessors, identity, filteredData)\n                    : group.items,\n                value: group.value\n            };\n        });\n    });\n    return result;\n};\n"],"names":["exec","map","groupCombinator","isArray","isPresent","aggregateBy","filterBy","normalizeGroups","descriptors","x","Object","assign","dir","identity","groupBy","data","preprocessors","transformers","originalData","length","descriptor","initialValue","view","field","result","keys","forEach","value","group","aggregateResult","filteredData","aggregates","ignoreCase","operator","__position","items","slice"],"mappings":"AACA,SAASA,IAAI,EAAEC,GAAG,EAAEC,eAAe,QAAQ,iBAAiB;AAC5D,SAASC,OAAO,EAAEC,SAAS,QAAQ,WAAW;AAC9C,SAASC,WAAW,QAAQ,wBAAwB;AACpD,SAASC,QAAQ,QAAQ,yCAAyC;AAGlE;;CAEC,GACD,OAAO,MAAMC,kBAAkB,CAACC;IAC5BA,cAAcL,QAAQK,eAAeA,cAAc;QAACA;KAAY;IAChE,OAAOA,YAAYP,GAAG,CAACQ,CAAAA,IAAKC,OAAOC,MAAM,CAAC;YAAEC,KAAK;QAAM,GAAGH;AAC9D,EAAE;AAEF,MAAMI,WAAoBZ,IAAIQ,CAAAA,IAAKA;AAEnC;;;;;;;;;;;;;;;;;;;;;;CAsBC,GACD,OAAO,MAAMK,UAAU,CACnBC,MACAP,cAAiC,EAAE,EACnCQ,gBAAkC,CAAC,CAAC,EACpCC,eAAeJ,QAAQ,EACvBK,eAAoBH,IAAI;IAGxBP,cAAcD,gBAAgBC;IAE9B,IAAI,CAACA,YAAYW,MAAM,EAAE;QACrB,OAAOJ;IACX;IAEA,MAAMK,aAAaZ,WAAW,CAAC,EAAE;IACjC,MAAMa,eAAe,CAAC;IAEtB,MAAMC,OAAOtB,KAAKiB,aAAaf,gBAAgBkB,WAAWG,KAAK,EAAEP,iBAAiBK,cAAcN;IAEhG,MAAMS,SAAS,EAAE;IAEjBd,OAAOe,IAAI,CAACH,MAAMI,OAAO,CAACH,CAAAA;QACtBb,OAAOe,IAAI,CAACH,IAAI,CAACC,MAAM,EAAEG,OAAO,CAACC,CAAAA;YAC7B,MAAMC,QAAQN,IAAI,CAACC,MAAM,CAACI,MAAM;YAEhC,IAAIE,kBAAkB,CAAC;YACvB,IAAIC,eAAeZ;YAEnB,IAAId,UAAUgB,WAAWW,UAAU,GAAG;gBAElCD,eAAexB,SAASY,cAAc;oBAClCK,OAAOH,WAAWG,KAAK;oBACvBS,YAAY;oBACZC,UAAU;oBACVN,OAAOC,MAAMD,KAAK;gBACtB,GAAGX;gBAEHa,kBAAkBxB,YAAYyB,cAAcV,WAAWW,UAAU,EAAEf;YACvE;YAEAQ,MAAM,CAACI,MAAMM,UAAU,CAAC,GAAG;gBACvBH,YAAYF;gBACZN,OAAOA;gBACPY,OAAO3B,YAAYW,MAAM,GAAG,IACxBL,QAAQc,MAAMO,KAAK,EAAE3B,YAAY4B,KAAK,CAAC,IAAIpB,eAAeH,UAAUiB,gBAClEF,MAAMO,KAAK;gBACjBR,OAAOC,MAAMD,KAAK;YACtB;QACJ;IACJ;IACA,OAAOH;AACX,EAAE"}

package/dist/index.js

@@ -1,14 +1,21 @@
-export { isCompositeFilterDescriptor } from './filtering/filter-descriptor.interface';
+export { SortDescriptor } from './sort-descriptor';
+export { GroupDescriptor, GroupResult } from './grouping/group-descriptor.interface';
+export { FilterDescriptor, CompositeFilterDescriptor, isCompositeFilterDescriptor } from './filtering/filter-descriptor.interface';
 export { toODataString } from './odata.operators';
-export { toDataSourceRequestString, toDataSourceRequest } from './mvc/operators';
-export { translateDataSourceResultGroups, translateAggregateResults } from './mvc/deserialization';
+export { toDataSourceRequestString, DataSourceRequestState, toDataSourceRequest } from './mvc/operators';
+export { translateDataSourceResultGroups, ServerGroupResult, translateAggregateResults } from './mvc/deserialization';
+export { State } from './state';
 export { orderBy, process, distinct } from './array.operators';
 export { getter } from './accessor';
 export { filterBy, compileFilter } from './filtering/filter-expression.factory';
 export { groupBy } from './grouping/group.operators';
-export { composeSortDescriptors } from './sorting/sort-array.operator';
+export { Comparer, composeSortDescriptors } from './sorting/sort-array.operator';
 export { normalizeFilters } from './filtering/filter.operators';
 export { normalizeGroups } from './grouping/group.operators';
-export { aggregateBy } from './grouping/aggregate.operators';
-export { InMemoryDataSource, AsyncDataSource } from './data-source';
+export { DataResult } from './data-result.interface';
+export { aggregateBy, AggregateDescriptor } from './grouping/aggregate.operators';
+export { AggregateResult } from './transducers';
+export { Preprocessors } from './common.interfaces';
+export { IdType, DataSource, InMemoryDataSource, AsyncDataSource } from './data-source';
+
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAA+C,2BAA2B,EAAE,MAAM,yCAAyC,CAAC;AACnI,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAClD,OAAO,EAAE,yBAAyB,EAA0B,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AACzG,OAAO,EAAE,+BAA+B,EAAqB,yBAAyB,EAAE,MAAM,uBAAuB,CAAC;AAEtH,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAC/D,OAAO,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AACpC,OAAO,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,uCAAuC,CAAC;AAChF,OAAO,EAAE,OAAO,EAAE,MAAM,4BAA4B,CAAC;AACrD,OAAO,EAAY,sBAAsB,EAAE,MAAM,+BAA+B,CAAC;AACjF,OAAO,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAChE,OAAO,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAE7D,OAAO,EAAE,WAAW,EAAuB,MAAM,gCAAgC,CAAC;AAGlF,OAAO,EAAsB,kBAAkB,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA"}
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["export { SortDescriptor } from './sort-descriptor';\nexport { GroupDescriptor, GroupResult } from './grouping/group-descriptor.interface';\nexport { FilterDescriptor, CompositeFilterDescriptor, isCompositeFilterDescriptor } from './filtering/filter-descriptor.interface';\nexport { toODataString } from './odata.operators';\nexport { toDataSourceRequestString, DataSourceRequestState, toDataSourceRequest } from './mvc/operators';\nexport { translateDataSourceResultGroups, ServerGroupResult, translateAggregateResults } from './mvc/deserialization';\nexport { State } from './state';\nexport { orderBy, process, distinct } from './array.operators';\nexport { getter } from './accessor';\nexport { filterBy, compileFilter } from './filtering/filter-expression.factory';\nexport { groupBy } from './grouping/group.operators';\nexport { Comparer, composeSortDescriptors } from './sorting/sort-array.operator';\nexport { normalizeFilters } from './filtering/filter.operators';\nexport { normalizeGroups } from './grouping/group.operators';\nexport { DataResult } from './data-result.interface';\nexport { aggregateBy, AggregateDescriptor } from './grouping/aggregate.operators';\nexport { AggregateResult } from './transducers';\nexport { Preprocessors } from './common.interfaces';\nexport { IdType, DataSource, InMemoryDataSource, AsyncDataSource } from './data-source'\n"],"names":["SortDescriptor","GroupDescriptor","GroupResult","FilterDescriptor","CompositeFilterDescriptor","isCompositeFilterDescriptor","toODataString","toDataSourceRequestString","DataSourceRequestState","toDataSourceRequest","translateDataSourceResultGroups","ServerGroupResult","translateAggregateResults","State","orderBy","process","distinct","getter","filterBy","compileFilter","groupBy","Comparer","composeSortDescriptors","normalizeFilters","normalizeGroups","DataResult","aggregateBy","AggregateDescriptor","AggregateResult","Preprocessors","IdType","DataSource","InMemoryDataSource","AsyncDataSource"],"mappings":"AAAA,SAASA,cAAc,QAAQ,oBAAoB;AACnD,SAASC,eAAe,EAAEC,WAAW,QAAQ,wCAAwC;AACrF,SAASC,gBAAgB,EAAEC,yBAAyB,EAAEC,2BAA2B,QAAQ,0CAA0C;AACnI,SAASC,aAAa,QAAQ,oBAAoB;AAClD,SAASC,yBAAyB,EAAEC,sBAAsB,EAAEC,mBAAmB,QAAQ,kBAAkB;AACzG,SAASC,+BAA+B,EAAEC,iBAAiB,EAAEC,yBAAyB,QAAQ,wBAAwB;AACtH,SAASC,KAAK,QAAQ,UAAU;AAChC,SAASC,OAAO,EAAEC,OAAO,EAAEC,QAAQ,QAAQ,oBAAoB;AAC/D,SAASC,MAAM,QAAQ,aAAa;AACpC,SAASC,QAAQ,EAAEC,aAAa,QAAQ,wCAAwC;AAChF,SAASC,OAAO,QAAQ,6BAA6B;AACrD,SAASC,QAAQ,EAAEC,sBAAsB,QAAQ,gCAAgC;AACjF,SAASC,gBAAgB,QAAQ,+BAA+B;AAChE,SAASC,eAAe,QAAQ,6BAA6B;AAC7D,SAASC,UAAU,QAAQ,0BAA0B;AACrD,SAASC,WAAW,EAAEC,mBAAmB,QAAQ,iCAAiC;AAClF,SAASC,eAAe,QAAQ,gBAAgB;AAChD,SAASC,aAAa,QAAQ,sBAAsB;AACpD,SAASC,MAAM,EAAEC,UAAU,EAAEC,kBAAkB,EAAEC,eAAe,QAAQ,gBAAe"}

package/dist/mvc/deserialization.js

@@ -1,50 +1,49 @@
 import { isPresent } from '../utils';
 import { compose } from '../funcs';
 // tslint:enable:max-line-length
-const set = (field, target, value) => {
+const set = (field, target, value)=>{
     target[field] = value;
     return target;
 };
-const toCamelCase = str => str.replace(/(^[A-Z])/g, (_, g1) => g1.toLowerCase());
-const prop = (fieldName) => (obj) => {
-    const value = obj[fieldName];
-    if (isPresent(value)) {
-        return value;
-    }
-    return obj[toCamelCase(fieldName)];
-};
+const toCamelCase = (str)=>str.replace(/(^[A-Z])/g, (_, g1)=>g1.toLowerCase());
+const prop = (fieldName)=>(obj)=>{
+        const value = obj[fieldName];
+        if (isPresent(value)) {
+            return value;
+        }
+        return obj[toCamelCase(fieldName)];
+    };
 const member = prop("Member");
 const aggregateMethodName = prop("AggregateMethodName");
 const value = prop("Value");
-const convert = mapper => values => Object.keys(values).reduce(mapper.bind(null, values), {});
-const translateAggregate = convert((source, acc, field) => set(field.toLowerCase(), acc, source[field]));
-const translateAggregates = convert((source, acc, field) => set(field, acc, translateAggregate(source[field])));
-const valueOrDefault = (value, defaultValue) => isPresent(value) ? value : defaultValue;
-const normalizeGroup = group => ({
-    aggregates: group.Aggregates || group.aggregates,
-    field: group.Member || group.member || group.field,
-    hasSubgroups: group.HasSubgroups || group.hasSubgroups || false,
-    items: group.Items || group.items,
-    value: valueOrDefault(group.Key, valueOrDefault(group.key, group.value))
-});
-const translateGroup = compose(({ field, hasSubgroups, value, aggregates, items }) => ({
-    aggregates: translateAggregates(aggregates),
-    field,
-    items: hasSubgroups ? items.map(translateGroup) : items,
-    value
-}), normalizeGroup);
+const convert = (mapper)=>(values)=>Object.keys(values).reduce(mapper.bind(null, values), {});
+const translateAggregate = convert((source, acc, field)=>set(field.toLowerCase(), acc, source[field]));
+const translateAggregates = convert((source, acc, field)=>set(field, acc, translateAggregate(source[field])));
+const valueOrDefault = (value, defaultValue)=>isPresent(value) ? value : defaultValue;
+const normalizeGroup = (group)=>({
+        aggregates: group.Aggregates || group.aggregates,
+        field: group.Member || group.member || group.field,
+        hasSubgroups: group.HasSubgroups || group.hasSubgroups || false,
+        items: group.Items || group.items,
+        value: valueOrDefault(group.Key, valueOrDefault(group.key, group.value))
+    });
+const translateGroup = compose(({ field, hasSubgroups, value, aggregates, items })=>({
+        aggregates: translateAggregates(aggregates),
+        field,
+        items: hasSubgroups ? items.map(translateGroup) : items,
+        value
+    }), normalizeGroup);
 // tslint:disable:max-line-length
 /**
  * Converts the grouped result, which is returned into the `Data` field of the UI for ASP.NET MVC `ToDataSourceResult` method, to a comparable format.
  * @param data - The value of the `Data` field of the response.
  * @returns {GroupResult[]} - The converted result.
- */
-export const translateDataSourceResultGroups = (data) => data.map(translateGroup);
+ */ export const translateDataSourceResultGroups = (data)=>data.map(translateGroup);
 /**
  * Converts the `AggregateResults` field content, which is returned by the UI for ASP.NET MVC `ToDataSourceResult` method, to a comparable format.
  * @param data - The value of the `AggregateResults` field of the response.
  * @returns {AggregateResult} - The converted result.
- */
-// tslint:enable:max-line-length
-export const translateAggregateResults = (data) => ((data || []).reduce((acc, x) => set(member(x), acc, set(aggregateMethodName(x).toLowerCase(), acc[member(x)] || {}, value(x))), {}));
+ */ // tslint:enable:max-line-length
+export const translateAggregateResults = (data)=>(data || []).reduce((acc, x)=>set(member(x), acc, set(aggregateMethodName(x).toLowerCase(), acc[member(x)] || {}, value(x))), {});
+
 //# sourceMappingURL=deserialization.js.map

package/dist/mvc/deserialization.js.map

@@ -1 +1 @@
-{"version":3,"file":"deserialization.js","sourceRoot":"","sources":["../../src/mvc/deserialization.ts"],"names":[],"mappings":"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"}
+{"version":3,"sources":["../../src/mvc/deserialization.ts"],"sourcesContent":["import { GroupResult } from '../grouping/group-descriptor.interface';\nimport { isPresent } from '../utils';\nimport { compose } from '../funcs';\nimport { AggregateResult } from '../transducers';\n\n// tslint:disable:max-line-length\n/**\n * Represents the grouped result returned by the UI for ASP.NET MVC `ToDataSourceResult` method.\n */\nexport type ServerGroupResult = {\n    /**\n     * Contains either the subgroups or the data items.\n     */\n    Items: Object[];\n    /**\n     * The aggregated values for the group. An [`AggregateResult`]({% slug api_kendo-data-query_aggregateresult %}) instance.\n     */\n    Aggregates: any;\n    /**\n     * The field by which the data items are grouped.\n     */\n    Member: string;\n    /**\n     * The group key.\n     */\n    Key: any;\n    /**\n     * Determines if `Items` contains subgroups.\n     */\n    HasSubgroups: boolean\n};\n// tslint:enable:max-line-length\n\nconst set = (field, target, value) => {\n    target[field] = value;\n    return target;\n};\n\nconst toCamelCase = str => str.replace(/(^[A-Z])/g, (_, g1) => g1.toLowerCase());\n\nconst prop = (fieldName: string) => (obj: any) => {\n    const value = obj[fieldName];\n    if (isPresent(value)) {\n        return value;\n    }\n    return obj[toCamelCase(fieldName)];\n};\n\nconst member = prop(\"Member\");\nconst aggregateMethodName = prop(\"AggregateMethodName\");\nconst value = prop(\"Value\");\n\nconst convert = mapper => values => Object.keys(values).reduce(mapper.bind(null, values), {});\nconst translateAggregate = convert((source, acc, field) => set(field.toLowerCase(), acc, source[field]));\nconst translateAggregates = convert((source, acc, field) => set(field, acc, translateAggregate(source[field])));\nconst valueOrDefault = (value, defaultValue) => isPresent(value) ? value : defaultValue;\n\nconst normalizeGroup = group => ({\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});\n\nconst translateGroup = compose(\n    ({ field, hasSubgroups, value, aggregates, items }) => ({\n        aggregates: translateAggregates(aggregates),\n        field,\n        items: hasSubgroups ? items.map(translateGroup) : items,\n        value\n    }),\n    normalizeGroup\n);\n\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 const translateDataSourceResultGroups = (data: any[]): GroupResult[] => data.map(translateGroup);\n\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 const translateAggregateResults = (data: any[]): AggregateResult => (\n    (data || []).reduce((acc, x) => set(member(x), acc, set(aggregateMethodName(x).toLowerCase(), acc[member(x)] || {}, value(x))), {})\n);\n"],"names":["isPresent","compose","set","field","target","value","toCamelCase","str","replace","_","g1","toLowerCase","prop","fieldName","obj","member","aggregateMethodName","convert","mapper","values","Object","keys","reduce","bind","translateAggregate","source","acc","translateAggregates","valueOrDefault","defaultValue","normalizeGroup","group","aggregates","Aggregates","Member","hasSubgroups","HasSubgroups","items","Items","Key","key","translateGroup","map","translateDataSourceResultGroups","data","translateAggregateResults","x"],"mappings":"AACA,SAASA,SAAS,QAAQ,WAAW;AACrC,SAASC,OAAO,QAAQ,WAAW;AA6BnC,gCAAgC;AAEhC,MAAMC,MAAM,CAACC,OAAOC,QAAQC;IACxBD,MAAM,CAACD,MAAM,GAAGE;IAChB,OAAOD;AACX;AAEA,MAAME,cAAcC,CAAAA,MAAOA,IAAIC,OAAO,CAAC,aAAa,CAACC,GAAGC,KAAOA,GAAGC,WAAW;AAE7E,MAAMC,OAAO,CAACC,YAAsB,CAACC;QACjC,MAAMT,QAAQS,GAAG,CAACD,UAAU;QAC5B,IAAIb,UAAUK,QAAQ;YAClB,OAAOA;QACX;QACA,OAAOS,GAAG,CAACR,YAAYO,WAAW;IACtC;AAEA,MAAME,SAASH,KAAK;AACpB,MAAMI,sBAAsBJ,KAAK;AACjC,MAAMP,QAAQO,KAAK;AAEnB,MAAMK,UAAUC,CAAAA,SAAUC,CAAAA,SAAUC,OAAOC,IAAI,CAACF,QAAQG,MAAM,CAACJ,OAAOK,IAAI,CAAC,MAAMJ,SAAS,CAAC;AAC3F,MAAMK,qBAAqBP,QAAQ,CAACQ,QAAQC,KAAKvB,QAAUD,IAAIC,MAAMQ,WAAW,IAAIe,KAAKD,MAAM,CAACtB,MAAM;AACtG,MAAMwB,sBAAsBV,QAAQ,CAACQ,QAAQC,KAAKvB,QAAUD,IAAIC,OAAOuB,KAAKF,mBAAmBC,MAAM,CAACtB,MAAM;AAC5G,MAAMyB,iBAAiB,CAACvB,OAAOwB,eAAiB7B,UAAUK,SAASA,QAAQwB;AAE3E,MAAMC,iBAAiBC,CAAAA,QAAU,CAAA;QAC7BC,YAAYD,MAAME,UAAU,IAAIF,MAAMC,UAAU;QAChD7B,OAAO4B,MAAMG,MAAM,IAAIH,MAAMhB,MAAM,IAAIgB,MAAM5B,KAAK;QAClDgC,cAAcJ,MAAMK,YAAY,IAAIL,MAAMI,YAAY,IAAI;QAC1DE,OAAON,MAAMO,KAAK,IAAIP,MAAMM,KAAK;QACjChC,OAAOuB,eAAeG,MAAMQ,GAAG,EAAEX,eAAeG,MAAMS,GAAG,EAAET,MAAM1B,KAAK;IAC1E,CAAA;AAEA,MAAMoC,iBAAiBxC,QACnB,CAAC,EAAEE,KAAK,EAAEgC,YAAY,EAAE9B,KAAK,EAAE2B,UAAU,EAAEK,KAAK,EAAE,GAAM,CAAA;QACpDL,YAAYL,oBAAoBK;QAChC7B;QACAkC,OAAOF,eAAeE,MAAMK,GAAG,CAACD,kBAAkBJ;QAClDhC;IACJ,CAAA,GACAyB;AAGJ,iCAAiC;AACjC;;;;CAIC,GACD,OAAO,MAAMa,kCAAkC,CAACC,OAA+BA,KAAKF,GAAG,CAACD,gBAAgB;AAExG;;;;CAIC,GACD,gCAAgC;AAChC,OAAO,MAAMI,4BAA4B,CAACD,OACtC,AAACA,CAAAA,QAAQ,EAAE,AAAD,EAAGtB,MAAM,CAAC,CAACI,KAAKoB,IAAM5C,IAAIa,OAAO+B,IAAIpB,KAAKxB,IAAIc,oBAAoB8B,GAAGnC,WAAW,IAAIe,GAAG,CAACX,OAAO+B,GAAG,IAAI,CAAC,GAAGzC,MAAMyC,MAAM,CAAC,GACnI"}

package/dist/mvc/operators.js

@@ -3,22 +3,42 @@ import { isPresent, isNotNullOrEmptyString, isArray } from '../utils';
 import { getter } from '../accessor';
 import { compose, ifElse, identity } from '../funcs';
 import { isStringValue, isDateValue, quote, serializeFilters, toUTC, encodeValue } from '../filter-serialization.common';
-const toQueryString = values => values.reduce((acc, [key, value]) => [...acc, `${key}=${value}`], []);
-const toObject = values => values.reduce((acc, [key, value]) => ({ ...acc, ...{ [key]: value } }), {});
-const pairwise = key => value => [key, value];
-const empty = () => null;
-const isNotEmptyArray = value => isPresent(value) && isArray(value) && value.length > 0;
-const has = accessor => value => isPresent(accessor(value));
-const isNotEmpty = accessor => value => isNotEmptyArray(accessor(value));
-const runOrEmpty = (predicate, fn) => ifElse(predicate, fn, empty);
-const calcPage = ({ skip, take }) => Math.floor((skip || 0) / take) + 1;
-const formatDescriptors = (accessor, formatter) => state => (accessor(state).map(formatter).join("~"));
-const removeAfter = (what) => (str) => str.slice(0, str.indexOf(what));
-const replace = (patterns) => compose(...patterns.map(([left, right]) => (s) => s.replace(new RegExp(left, "g"), right)));
-const sanitizeDateLiterals = replace([["\"", ""], [":", "-"]]);
+const toQueryString = (values)=>values.reduce((acc, [key, value])=>[
+            ...acc,
+            `${key}=${value}`
+        ], []);
+const toObject = (values)=>values.reduce((acc, [key, value])=>({
+            ...acc,
+            ...{
+                [key]: value
+            }
+        }), {});
+const pairwise = (key)=>(value)=>[
+            key,
+            value
+        ];
+const empty = ()=>null;
+const isNotEmptyArray = (value)=>isPresent(value) && isArray(value) && value.length > 0;
+const has = (accessor)=>(value)=>isPresent(accessor(value));
+const isNotEmpty = (accessor)=>(value)=>isNotEmptyArray(accessor(value));
+const runOrEmpty = (predicate, fn)=>ifElse(predicate, fn, empty);
+const calcPage = ({ skip, take })=>Math.floor((skip || 0) / take) + 1;
+const formatDescriptors = (accessor, formatter)=>(state)=>accessor(state).map(formatter).join("~");
+const removeAfter = (what)=>(str)=>str.slice(0, str.indexOf(what));
+const replace = (patterns)=>compose(...patterns.map(([left, right])=>(s)=>s.replace(new RegExp(left, "g"), right)));
+const sanitizeDateLiterals = replace([
+    [
+        "\"",
+        ""
+    ],
+    [
+        ":",
+        "-"
+    ]
+]);
 const removeAfterDot = removeAfter(".");
-const directionFormatter = ({ field, dir = "asc" }) => `${field}-${dir}`;
-const aggregateFormatter = ({ field, aggregate }) => `${field}-${aggregate}`;
+const directionFormatter = ({ field, dir = "asc" })=>`${field}-${dir}`;
+const aggregateFormatter = ({ field, aggregate })=>`${field}-${aggregate}`;
 const take = getter("take");
 const aggregates = getter("aggregates");
 const skip = getter("skip");
@@ -27,17 +47,17 @@ const sort = getter("sort", true);
 const formatSort = formatDescriptors(sort, directionFormatter);
 const formatGroup = formatDescriptors(group, directionFormatter);
 const formatAggregates = formatDescriptors(aggregates, aggregateFormatter);
-const prefixDateValue = value => `datetime'${value}'`;
+const prefixDateValue = (value)=>`datetime'${value}'`;
 const formatDateValue = compose(prefixDateValue, removeAfterDot, sanitizeDateLiterals, JSON.stringify, toUTC);
-const formatDate = ({ field, value, ignoreCase, operator }) => ({
-    value: formatDateValue(value),
-    field,
-    ignoreCase,
-    operator
-});
-const normalizeSort = (state) => Object.assign({}, state, {
-    sort: (sort(state) || []).filter(({ dir }) => isNotNullOrEmptyString(dir))
-});
+const formatDate = ({ field, value, ignoreCase, operator })=>({
+        value: formatDateValue(value),
+        field,
+        ignoreCase,
+        operator
+    });
+const normalizeSort = (state)=>Object.assign({}, state, {
+        sort: (sort(state) || []).filter(({ dir })=>isNotNullOrEmptyString(dir))
+    });
 const transformSkip = compose(pairwise('page'), calcPage);
 const transformTake = compose(pairwise('pageSize'), take);
 const transformGroup = compose(pairwise('group'), formatGroup);
@@ -48,29 +68,32 @@ const serializePageSize = runOrEmpty(has(take), transformTake);
 const serializeGroup = runOrEmpty(isNotEmpty(group), transformGroup);
 const serializeAggregates = runOrEmpty(has(aggregates), transformAggregates);
 const serializeSort = compose(runOrEmpty(isNotEmpty(sort), transformSort), normalizeSort);
-const hasField = ({ field }) => isNotNullOrEmptyString(field);
-const filterFormatter = ({ field, operator, value }) => `${field}~${operator}~${value}`;
+const hasField = ({ field })=>isNotNullOrEmptyString(field);
+const filterFormatter = ({ field, operator, value })=>`${field}~${operator}~${value}`;
 const dateFormatter = ifElse(isDateValue, compose(filterFormatter, formatDate), filterFormatter);
-const typedFormatter = encode => runOrEmpty(hasField, ifElse(isStringValue, compose(filterFormatter, quote, encode ? encodeValue : identity), dateFormatter));
-const join = ({ logic }) => `~${logic}~`;
-const serialize = encode => serializeFilters(filter => ifElse(isCompositeFilterDescriptor, serialize(encode), typedFormatter(encode))(filter), join);
-const serializeFilter = ({ filter }, encode) => {
+const typedFormatter = (encode)=>runOrEmpty(hasField, ifElse(isStringValue, compose(filterFormatter, quote, encode ? encodeValue : identity), dateFormatter));
+const join = ({ logic })=>`~${logic}~`;
+const serialize = (encode)=>serializeFilters((filter)=>ifElse(isCompositeFilterDescriptor, serialize(encode), typedFormatter(encode))(filter), join);
+const serializeFilter = ({ filter }, encode)=>{
     if (filter && filter.filters) {
         const filters = serialize(encode)(filter);
         if (filters.length) {
-            return ['filter', filters];
+            return [
+                'filter',
+                filters
+            ];
         }
     }
     return null;
 };
-const rules = (state, encode = true) => key => ({
-    "aggregates": serializeAggregates(state),
-    "filter": serializeFilter(state, encode),
-    "group": serializeGroup(state),
-    "skip": serializePage(state),
-    "sort": serializeSort(state),
-    "take": serializePageSize(state)
-}[key]);
+const rules = (state, encode = true)=>(key)=>({
+            "aggregates": serializeAggregates(state),
+            "filter": serializeFilter(state, encode),
+            "group": serializeGroup(state),
+            "skip": serializePage(state),
+            "sort": serializeSort(state),
+            "take": serializePageSize(state)
+        })[key];
 /**
  * Converts a [`DataSourceRequestState`]({% slug api_kendo-data-query_datasourcerequeststate %}) into a string
  * that is comparable with the `DataSourceRequest` format in UI for ASP.NET MVC.
@@ -175,18 +198,13 @@ const rules = (state, encode = true) => key => ({
  * }
  * ```
  * {% endplatform_content %}
- */
-export const toDataSourceRequestString = (state) => (toQueryString(Object.keys(state)
-    .map(rules(state))
-    .filter(isPresent)).join('&'));
+ */ export const toDataSourceRequestString = (state)=>toQueryString(Object.keys(state).map(rules(state)).filter(isPresent)).join('&');
 /**
  * Converts a [`DataSourceRequestState`]({% slug api_kendo-data-query_datasourcerequeststate %}) into an object
  * that is compatible with the `DataSourceRequest` format in UI for ASP.NET MVC.
  *
  * @param {DataRequestState} state - The state that will be serialized.
  * @returns {any} - The serialized state.
- */
-export const toDataSourceRequest = (state) => (toObject(Object.keys(state)
-    .map(rules(state, false))
-    .filter(isPresent)));
+ */ export const toDataSourceRequest = (state)=>toObject(Object.keys(state).map(rules(state, false)).filter(isPresent));
+
 //# sourceMappingURL=operators.js.map

package/dist/mvc/operators.js.map

@@ -1 +1 @@
-{"version":3,"file":"operators.js","sourceRoot":"","sources":["../../src/mvc/operators.ts"],"names":[],"mappings":"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"}
+{"version":3,"sources":["../../src/mvc/operators.ts"],"sourcesContent":["import { State } from '../state';\nimport { FilterDescriptor, isCompositeFilterDescriptor } from '../filtering/filter-descriptor.interface';\nimport { AggregateDescriptor } from '../grouping/aggregate.operators';\nimport { isPresent, isNotNullOrEmptyString, isArray, Pair } from '../utils';\nimport { getter } from '../accessor';\nimport { compose, ifElse, identity } from '../funcs';\nimport { isStringValue, isDateValue, quote, serializeFilters, Transformation, toUTC, encodeValue } from '../filter-serialization.common';\n\nconst toQueryString = values => values.reduce((acc, [key, value]) => [...acc, `${key}=${value}`], []);\nconst toObject = values => values.reduce((acc, [key, value]) => ({ ...acc, ...{ [key]: value } }), {});\nconst pairwise = key => value => [key, value];\nconst empty = () => null;\nconst isNotEmptyArray = value => isPresent(value) && isArray(value) && value.length > 0;\nconst has = accessor => value => isPresent(accessor(value));\nconst isNotEmpty = accessor => value => isNotEmptyArray(accessor(value));\nconst runOrEmpty = (predicate, fn) => ifElse(predicate, fn, empty);\n\nconst calcPage = ({ skip, take }: State) => Math.floor((skip || 0) / take) + 1;\nconst formatDescriptors = (accessor, formatter) => state => (\n    accessor(state).map(formatter).join(\"~\")\n);\n\nconst removeAfter = (what: string) => (str: string) => str.slice(0, str.indexOf(what));\nconst replace = (patterns: Pair<string, string>[]) =>\n    compose(...patterns.map(([left, right]) => (s: string) => s.replace(new RegExp(left, \"g\"), right)));\n\nconst sanitizeDateLiterals = replace([[\"\\\"\", \"\"], [\":\", \"-\"]]);\nconst removeAfterDot = removeAfter(\".\");\n\nconst directionFormatter = ({ field, dir = \"asc\" }) => `${field}-${dir}`;\nconst aggregateFormatter = ({ field, aggregate }) => `${field}-${aggregate}`;\n\nconst take = getter(\"take\");\nconst aggregates = getter(\"aggregates\");\nconst skip = getter(\"skip\");\nconst group = getter(\"group\");\nconst sort = getter(\"sort\", true);\n\nconst formatSort = formatDescriptors(sort, directionFormatter);\nconst formatGroup = formatDescriptors(group, directionFormatter);\nconst formatAggregates = formatDescriptors(aggregates, aggregateFormatter);\n\nconst prefixDateValue = value => `datetime'${value}'`;\n\nconst formatDateValue = compose(\n    prefixDateValue,\n    removeAfterDot,\n    sanitizeDateLiterals,\n    JSON.stringify,\n    toUTC\n);\n\nconst formatDate: Transformation = ({ field, value, ignoreCase, operator }) => ({\n    value: formatDateValue(value),\n    field,\n    ignoreCase,\n    operator\n});\n\nconst normalizeSort = (state: State) => Object.assign({}, state, {\n    sort: (sort(state) || []).filter(({ dir }) => isNotNullOrEmptyString(dir))\n});\n\nconst transformSkip = compose(pairwise('page'), calcPage);\nconst transformTake = compose(pairwise('pageSize'), take);\nconst transformGroup = compose(pairwise('group'), formatGroup);\nconst transformSort = compose(pairwise('sort'), formatSort);\nconst transformAggregates = compose(pairwise('aggregate'), formatAggregates);\n\nconst serializePage = runOrEmpty(has(skip), transformSkip);\nconst serializePageSize = runOrEmpty(has(take), transformTake);\nconst serializeGroup = runOrEmpty(isNotEmpty(group), transformGroup);\nconst serializeAggregates = runOrEmpty(has(aggregates), transformAggregates);\nconst serializeSort = compose(runOrEmpty(isNotEmpty(sort), transformSort), normalizeSort);\n\nconst hasField = ({ field }) => isNotNullOrEmptyString(field);\nconst filterFormatter = ({ field, operator, value }: FilterDescriptor) => `${field}~${operator}~${value}`;\nconst dateFormatter = ifElse(isDateValue, compose(filterFormatter, formatDate), filterFormatter);\nconst typedFormatter = encode => runOrEmpty(\n    hasField,\n    ifElse(\n        isStringValue,\n        compose(filterFormatter, quote, encode ? encodeValue : identity),\n        dateFormatter\n    )\n);\n\nconst join = ({ logic }) => `~${logic}~`;\nconst serialize = encode => serializeFilters(\n    filter => ifElse(isCompositeFilterDescriptor, serialize(encode), typedFormatter(encode))(filter),\n    join\n);\n\nconst serializeFilter = ({ filter }: State, encode: boolean) => {\n    if (filter && filter.filters) {\n        const filters = serialize(encode)(filter);\n        if (filters.length) {\n            return ['filter', filters];\n        }\n    }\n    return null;\n};\n\nconst rules = (state, encode = true) => key => ({\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 * Represents the operation descriptors that will be sent\n * ([see example]({% slug api_kendo-data-query_todatasourcerequeststring %})).\n *\n * Extends [`State`]({% slug api_kendo-data-query_state %}) by adding the `aggregates` descriptors&mdash;\n * an array of [`AggregateDescriptor`]({% slug api_kendo-data-query_aggregatedescriptor %}).\n */\nexport type DataSourceRequestState = State & {\n\n    /**\n     * The descriptors used for aggregation.\n     * @type {Array<AggregateDescriptor>}\n     */\n    aggregates?: Array<AggregateDescriptor>;\n};\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 {DataRequestState} state - The state that will be serialized.\n * @returns {string} - The serialized state.\n *\n * @example\n * {% platform_content angular %}\n * ```ts-no-run\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-no-run\n * import { Component } from 'react';\n * import { toDataSourceRequestString, translateDataSourceResultGroups } from '@progress/kendo-data-query';\n *\n * export function withState(WrappedGrid) {\n *     return class StatefullGrid extends 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 const toDataSourceRequestString = (state: DataSourceRequestState): string => (\n    toQueryString(\n        Object.keys(state)\n            .map(rules(state))\n            .filter(isPresent)\n    ).join('&')\n);\n\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 {DataRequestState} state - The state that will be serialized.\n * @returns {any} - The serialized state.\n */\nexport const toDataSourceRequest = (state: DataSourceRequestState): any => (\n    toObject(\n        Object.keys(state)\n            .map(rules(state, false))\n            .filter(isPresent)\n    )\n);\n"],"names":["isCompositeFilterDescriptor","isPresent","isNotNullOrEmptyString","isArray","getter","compose","ifElse","identity","isStringValue","isDateValue","quote","serializeFilters","toUTC","encodeValue","toQueryString","values","reduce","acc","key","value","toObject","pairwise","empty","isNotEmptyArray","length","has","accessor","isNotEmpty","runOrEmpty","predicate","fn","calcPage","skip","take","Math","floor","formatDescriptors","formatter","state","map","join","removeAfter","what","str","slice","indexOf","replace","patterns","left","right","s","RegExp","sanitizeDateLiterals","removeAfterDot","directionFormatter","field","dir","aggregateFormatter","aggregate","aggregates","group","sort","formatSort","formatGroup","formatAggregates","prefixDateValue","formatDateValue","JSON","stringify","formatDate","ignoreCase","operator","normalizeSort","Object","assign","filter","transformSkip","transformTake","transformGroup","transformSort","transformAggregates","serializePage","serializePageSize","serializeGroup","serializeAggregates","serializeSort","hasField","filterFormatter","dateFormatter","typedFormatter","encode","logic","serialize","serializeFilter","filters","rules","toDataSourceRequestString","keys","toDataSourceRequest"],"mappings":"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"}