@progress/kendo-data-query 1.7.2 → 1.7.3-develop.2

package/dist/es2015/mvc/operators.js

@@ -72,44 +72,50 @@ const rules = (state, encode = true) => key => ({
     "take": serializePageSize(state)
 }[key]);
 /**
- * Converts a [DataSourceRequestState]({% slug api_kendo-data-query_datasourcerequeststate %}) into a string
+ * 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.
  *
- * @param {DataSourceRequestState} state - The state that will be serialized.
- * @returns {string} - The serialized state.
+ * @param {DataSourceRequestState} state The state that will be serialized.
+ * @returns {string} The serialized state.
+ *
+ * The following code snippet demonstrates how to use the `toDataSourceRequestString` method.
  *
  * {% platform_content angular %}
  * ```ts
- *  import {
- *      toDataSourceRequestString,
- *      translateDataSourceResultGroups,
- *      translateAggregateResults
+ * import { HttpClient } from '@angular/common/http';
+ * import { Observable } from 'rxjs';
+ * import { map } from 'rxjs/operators';
+ * import {
+ *     DataSourceRequestState,
+ *     toDataSourceRequestString,
+ *     translateDataSourceResultGroups,
+ *     translateAggregateResults
  * } from '@progress/kendo-data-query';
  *
- * export class Service {
- *  private BASE_URL: string = '...';
- *
- *  constructor(private http: Http) { }
- *
- *  // Omitted for brevity...
- *
- *  private fetch(state: DataSourceRequestState): Observable<DataResult> {
- *   const queryStr = `${toDataSourceRequestString(state)}`; //serialize the state
- *   const hasGroups = state.group && state.group.length;
- *
- *   return this.http
- *       .get(`${this.BASE_URL}?${queryStr}`) //send the state to the server
- *       .map(response => response.json())
- *       .map(({Data, Total, AggregateResults}) => // process the response
- *           (<GridDataResult>{
- *               //if there are groups convert them to compatible format
- *               data: hasGroups ? translateDataSourceResultGroups(Data) : Data,
- *               total: Total,
- *               // convert the aggregates if such exists
- *               aggregateResult: translateAggregateResults(AggregateResults)
- *           })
- *       );
- *  }
+ * export class ProductService {
+ *     private BASE_URL = 'https://api.example.com/products';
+ *
+ *     constructor(private http: HttpClient) { }
+ *
+ *     public fetch(state: DataSourceRequestState): Observable<GridDataResult> {
+ *
+ *         // DataSourceRequestState includes:
+ *         // - State properties: skip, take, sort, filter, group
+ *         // - Additional property: aggregates
+ *         const queryString = toDataSourceRequestString(state);
+ *
+ *         const hasGroups = state.group && state.group.length;
+ *
+ *         return this.http
+ *             .get<ServerResponse>(`${this.BASE_URL}?${queryString}`)
+ *             .pipe(
+ *                 map(({ Data, Total, AggregateResults }) => ({
+ *                     data: hasGroups ? translateDataSourceResultGroups(Data) : Data,
+ *                     total: Total,
+ *                     aggregateResult: translateAggregateResults(AggregateResults)
+ *                 }))
+ *             );
+ *     }
  * }
  * ```
  * {% endplatform_content %}
@@ -123,6 +129,9 @@ const rules = (state, encode = true) => key => ({
  *     return class StatefullGrid extends React.Component {
  *         constructor(props) {
  *             super(props);
+ *             // DataSourceRequestState includes:
+ *             // - State properties: skip, take, sort, filter, group
+ *             // - Additional property: aggregates
  *             this.state = { dataState: { skip: 0, take: 20 } };
  *         }
  *
@@ -154,6 +163,9 @@ const rules = (state, encode = true) => key => ({
  *         }
  *
  *         fetchData(dataState) {
+ *             // DataSourceRequestState includes:
+ *             // - State properties: skip, take, sort, filter, group
+ *             // - Additional property: aggregates
  *             const queryStr = `${toDataSourceRequestString(dataState)}`; // Serialize the state
  *             const hasGroups = dataState.group && dataState.group.length;
  *
@@ -179,11 +191,53 @@ export const toDataSourceRequestString = (state) => (toQueryString(Object.keys(s
     .map(rules(state))
     .filter(isPresent)).join('&'));
 /**
- * Converts a [DataSourceRequestState]({% slug api_kendo-data-query_datasourcerequeststate %}) into an object
+ * 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 {DataSourceRequestState} state - The state that will be serialized.
- * @returns {any} - The serialized state.
+ * @param {DataSourceRequestState} state The state that will be serialized.
+ * @returns {any} The serialized state.
+ *
+ * The following code snippet demonstrates how to use the `toDataSourceRequest` method.
+ *
+ * {% platform_content angular %}
+ * ```ts
+ * import { HttpClient } from '@angular/common/http';
+ * import { Observable } from 'rxjs';
+ * import { map } from 'rxjs/operators';
+ * import {
+ *     DataSourceRequestState,
+ *     toDataSourceRequest,
+ *     translateDataSourceResultGroups,
+ *     translateAggregateResults
+ * } from '@progress/kendo-data-query';
+ *
+ * export class ProductService {
+ *     private BASE_URL = 'https://api.example.com/products';
+ *
+ *     constructor(private http: HttpClient) { }
+ *
+ *     public fetch(state: DataSourceRequestState): Observable<GridDataResult> {
+ *
+ *         // DataSourceRequestState includes:
+ *         // - State properties: skip, take, sort, filter, group
+ *         // - Additional property: aggregates
+ *         const dataSourceRequest = toDataSourceRequest(state);
+ *
+ *         const hasGroups = state.group && state.group.length;
+ *
+ *         return this.http
+ *             .post<ServerResponse>(this.BASE_URL, dataSourceRequest)
+ *             .pipe(
+ *                 map(({ Data, Total, AggregateResults }) => ({
+ *                     data: hasGroups ? translateDataSourceResultGroups(Data) : Data,
+ *                     total: Total,
+ *                     aggregateResult: translateAggregateResults(AggregateResults)
+ *                 }))
+ *             );
+ *     }
+ * }
+ * ```
+ * {% endplatform_content %}
  */
 export const toDataSourceRequest = (state) => (toObject(Object.keys(state)
     .map(rules(state, false))

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

@@ -5,6 +5,7 @@ var transducers_1 = require("../transducers");
 var utils_1 = require("../utils");
 var aggregate_operators_1 = require("./aggregate.operators");
 var filter_expression_factory_1 = require("../filtering/filter-expression.factory");
+var sort_array_operator_1 = require("../sorting/sort-array.operator");
 /**
  * @hidden
  */
@@ -73,6 +74,15 @@ var groupBy = function (data, descriptors, transformers, originalData) {
             };
         });
     });
+    // Sort the result according to the descriptor's dir and compare options
+    if ((0, utils_1.isPresent)(descriptor.dir) || (0, utils_1.isPresent)(descriptor.compare)) {
+        var comparer = (0, sort_array_operator_1.composeSortDescriptors)([{
+                field: 'value',
+                dir: descriptor.dir,
+                compare: descriptor.compare
+            }]);
+        result.sort(comparer);
+    }
     return result;
 };
 exports.groupBy = groupBy;

package/dist/npm/mvc/deserialization.d.ts

@@ -27,13 +27,13 @@ export type ServerGroupResult = {
 };
 /**
  * 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.
+ * @param data The value of the `Data` field of the response.
+ * @returns {GroupResult[]} The converted result.
  */
 export declare const translateDataSourceResultGroups: (data: any[]) => GroupResult[];
 /**
  * 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.
+ * @param data The value of the `AggregateResults` field of the response.
+ * @returns {AggregateResult} The converted result.
  */
 export declare const translateAggregateResults: (data: any[]) => AggregateResult;

package/dist/npm/mvc/deserialization.js

@@ -42,15 +42,15 @@ var translateGroup = (0, funcs_1.compose)(function (_a) {
 // 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.
+ * @param data The value of the `Data` field of the response.
+ * @returns {GroupResult[]} The converted result.
  */
 var translateDataSourceResultGroups = function (data) { return data.map(translateGroup); };
 exports.translateDataSourceResultGroups = translateDataSourceResultGroups;
 /**
  * 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.
+ * @param data The value of the `AggregateResults` field of the response.
+ * @returns {AggregateResult} The converted result.
  */
 // tslint:enable:max-line-length
 var translateAggregateResults = function (data) { return ((data || []).reduce(function (acc, x) { return set(member(x), acc, set(aggregateMethodName(x).toLowerCase(), acc[member(x)] || {}, value(x))); }, {})); };

package/dist/npm/mvc/operators.d.ts

@@ -1,11 +1,31 @@
 import { State } from '../state';
 import { AggregateDescriptor } from '../grouping/aggregate.operators';
 /**
- * Represents the operation descriptors that will be sent
- * ([see example]({% slug api_kendo-data-query_todatasourcerequeststring %})).
+ * Represents the state required by the [`toDataSourceRequest`]({% slug api_kendo-data-query_todatasourcerequest %})
+ * and [`toDataSourceRequestString`]({% slug api_kendo-data-query_todatasourcerequeststring %}) methods.
  *
- * Extends [State]({% slug api_kendo-data-query_state %}) by adding the `aggregates` descriptors—
- * an array of [AggregateDescriptor]({% slug api_kendo-data-query_aggregatedescriptor %}).
+ * The `DataSourceRequestState` is an extension of the [`State`]({% slug api_kendo-data-query_state %}) type
+ * with an additional `aggregates` field—an array of [`AggregateDescriptor`]({% slug api_kendo-data-query_aggregatedescriptor %}).
+ *
+ * The aggregates field is required for serialization of aggregate descriptors in the request and does not replace the `aggregate` field
+ * of the [`GroupDescriptor`]({% slug api_kendo-data-query_groupdescriptor %}) used by the `group` field.
+ *
+ * ```ts
+ * import { DataSourceRequestState } from '@progress/kendo-data-query';
+ *
+ * const state: DataSourceRequestState = {
+ *     skip: 0,
+ *     take: 10,
+ *     sort: [{ field: 'ProductName', dir: 'asc' }],
+ *     group: [
+ *         {
+ *             field: 'Category',
+ *             aggregates: [{ field: 'UnitPrice', aggregate: 'sum' }] // GroupDescriptor aggregates
+ *         }
+ *     ],
+ *     aggregates: [{ field: 'UnitPrice', aggregate: 'sum' }] // DataSourceRequestState aggregates
+ * };
+ * ```
  */
 export type DataSourceRequestState = State & {
     /**
@@ -15,44 +35,50 @@ export type DataSourceRequestState = State & {
     aggregates?: Array<AggregateDescriptor>;
 };
 /**
- * Converts a [DataSourceRequestState]({% slug api_kendo-data-query_datasourcerequeststate %}) into a string
+ * 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.
  *
- * @param {DataSourceRequestState} state - The state that will be serialized.
- * @returns {string} - The serialized state.
+ * @param {DataSourceRequestState} state The state that will be serialized.
+ * @returns {string} The serialized state.
+ *
+ * The following code snippet demonstrates how to use the `toDataSourceRequestString` method.
  *
  * {% platform_content angular %}
  * ```ts
- *  import {
- *      toDataSourceRequestString,
- *      translateDataSourceResultGroups,
- *      translateAggregateResults
+ * import { HttpClient } from '@angular/common/http';
+ * import { Observable } from 'rxjs';
+ * import { map } from 'rxjs/operators';
+ * import {
+ *     DataSourceRequestState,
+ *     toDataSourceRequestString,
+ *     translateDataSourceResultGroups,
+ *     translateAggregateResults
  * } from '@progress/kendo-data-query';
  *
- * export class Service {
- *  private BASE_URL: string = '...';
- *
- *  constructor(private http: Http) { }
- *
- *  // Omitted for brevity...
- *
- *  private fetch(state: DataSourceRequestState): Observable<DataResult> {
- *   const queryStr = `${toDataSourceRequestString(state)}`; //serialize the state
- *   const hasGroups = state.group && state.group.length;
- *
- *   return this.http
- *       .get(`${this.BASE_URL}?${queryStr}`) //send the state to the server
- *       .map(response => response.json())
- *       .map(({Data, Total, AggregateResults}) => // process the response
- *           (<GridDataResult>{
- *               //if there are groups convert them to compatible format
- *               data: hasGroups ? translateDataSourceResultGroups(Data) : Data,
- *               total: Total,
- *               // convert the aggregates if such exists
- *               aggregateResult: translateAggregateResults(AggregateResults)
- *           })
- *       );
- *  }
+ * export class ProductService {
+ *     private BASE_URL = 'https://api.example.com/products';
+ *
+ *     constructor(private http: HttpClient) { }
+ *
+ *     public fetch(state: DataSourceRequestState): Observable<GridDataResult> {
+ *
+ *         // DataSourceRequestState includes:
+ *         // - State properties: skip, take, sort, filter, group
+ *         // - Additional property: aggregates
+ *         const queryString = toDataSourceRequestString(state);
+ *
+ *         const hasGroups = state.group && state.group.length;
+ *
+ *         return this.http
+ *             .get<ServerResponse>(`${this.BASE_URL}?${queryString}`)
+ *             .pipe(
+ *                 map(({ Data, Total, AggregateResults }) => ({
+ *                     data: hasGroups ? translateDataSourceResultGroups(Data) : Data,
+ *                     total: Total,
+ *                     aggregateResult: translateAggregateResults(AggregateResults)
+ *                 }))
+ *             );
+ *     }
  * }
  * ```
  * {% endplatform_content %}
@@ -66,6 +92,9 @@ export type DataSourceRequestState = State & {
  *     return class StatefullGrid extends React.Component {
  *         constructor(props) {
  *             super(props);
+ *             // DataSourceRequestState includes:
+ *             // - State properties: skip, take, sort, filter, group
+ *             // - Additional property: aggregates
  *             this.state = { dataState: { skip: 0, take: 20 } };
  *         }
  *
@@ -97,6 +126,9 @@ export type DataSourceRequestState = State & {
  *         }
  *
  *         fetchData(dataState) {
+ *             // DataSourceRequestState includes:
+ *             // - State properties: skip, take, sort, filter, group
+ *             // - Additional property: aggregates
  *             const queryStr = `${toDataSourceRequestString(dataState)}`; // Serialize the state
  *             const hasGroups = dataState.group && dataState.group.length;
  *
@@ -120,10 +152,52 @@ export type DataSourceRequestState = State & {
  */
 export declare const toDataSourceRequestString: (state: DataSourceRequestState) => string;
 /**
- * Converts a [DataSourceRequestState]({% slug api_kendo-data-query_datasourcerequeststate %}) into an object
+ * 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 {DataSourceRequestState} state - The state that will be serialized.
- * @returns {any} - The serialized state.
+ * @param {DataSourceRequestState} state The state that will be serialized.
+ * @returns {any} The serialized state.
+ *
+ * The following code snippet demonstrates how to use the `toDataSourceRequest` method.
+ *
+ * {% platform_content angular %}
+ * ```ts
+ * import { HttpClient } from '@angular/common/http';
+ * import { Observable } from 'rxjs';
+ * import { map } from 'rxjs/operators';
+ * import {
+ *     DataSourceRequestState,
+ *     toDataSourceRequest,
+ *     translateDataSourceResultGroups,
+ *     translateAggregateResults
+ * } from '@progress/kendo-data-query';
+ *
+ * export class ProductService {
+ *     private BASE_URL = 'https://api.example.com/products';
+ *
+ *     constructor(private http: HttpClient) { }
+ *
+ *     public fetch(state: DataSourceRequestState): Observable<GridDataResult> {
+ *
+ *         // DataSourceRequestState includes:
+ *         // - State properties: skip, take, sort, filter, group
+ *         // - Additional property: aggregates
+ *         const dataSourceRequest = toDataSourceRequest(state);
+ *
+ *         const hasGroups = state.group && state.group.length;
+ *
+ *         return this.http
+ *             .post<ServerResponse>(this.BASE_URL, dataSourceRequest)
+ *             .pipe(
+ *                 map(({ Data, Total, AggregateResults }) => ({
+ *                     data: hasGroups ? translateDataSourceResultGroups(Data) : Data,
+ *                     total: Total,
+ *                     aggregateResult: translateAggregateResults(AggregateResults)
+ *                 }))
+ *             );
+ *     }
+ * }
+ * ```
+ * {% endplatform_content %}
  */
 export declare const toDataSourceRequest: (state: DataSourceRequestState) => any;

package/dist/npm/mvc/operators.js

@@ -116,44 +116,50 @@ var rules = function (state, encode) {
     }[key]); };
 };
 /**
- * Converts a [DataSourceRequestState]({% slug api_kendo-data-query_datasourcerequeststate %}) into a string
+ * 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.
  *
- * @param {DataSourceRequestState} state - The state that will be serialized.
- * @returns {string} - The serialized state.
+ * @param {DataSourceRequestState} state The state that will be serialized.
+ * @returns {string} The serialized state.
+ *
+ * The following code snippet demonstrates how to use the `toDataSourceRequestString` method.
  *
  * {% platform_content angular %}
  * ```ts
- *  import {
- *      toDataSourceRequestString,
- *      translateDataSourceResultGroups,
- *      translateAggregateResults
+ * import { HttpClient } from '@angular/common/http';
+ * import { Observable } from 'rxjs';
+ * import { map } from 'rxjs/operators';
+ * import {
+ *     DataSourceRequestState,
+ *     toDataSourceRequestString,
+ *     translateDataSourceResultGroups,
+ *     translateAggregateResults
  * } from '@progress/kendo-data-query';
  *
- * export class Service {
- *  private BASE_URL: string = '...';
- *
- *  constructor(private http: Http) { }
- *
- *  // Omitted for brevity...
- *
- *  private fetch(state: DataSourceRequestState): Observable<DataResult> {
- *   const queryStr = `${toDataSourceRequestString(state)}`; //serialize the state
- *   const hasGroups = state.group && state.group.length;
- *
- *   return this.http
- *       .get(`${this.BASE_URL}?${queryStr}`) //send the state to the server
- *       .map(response => response.json())
- *       .map(({Data, Total, AggregateResults}) => // process the response
- *           (<GridDataResult>{
- *               //if there are groups convert them to compatible format
- *               data: hasGroups ? translateDataSourceResultGroups(Data) : Data,
- *               total: Total,
- *               // convert the aggregates if such exists
- *               aggregateResult: translateAggregateResults(AggregateResults)
- *           })
- *       );
- *  }
+ * export class ProductService {
+ *     private BASE_URL = 'https://api.example.com/products';
+ *
+ *     constructor(private http: HttpClient) { }
+ *
+ *     public fetch(state: DataSourceRequestState): Observable<GridDataResult> {
+ *
+ *         // DataSourceRequestState includes:
+ *         // - State properties: skip, take, sort, filter, group
+ *         // - Additional property: aggregates
+ *         const queryString = toDataSourceRequestString(state);
+ *
+ *         const hasGroups = state.group && state.group.length;
+ *
+ *         return this.http
+ *             .get<ServerResponse>(`${this.BASE_URL}?${queryString}`)
+ *             .pipe(
+ *                 map(({ Data, Total, AggregateResults }) => ({
+ *                     data: hasGroups ? translateDataSourceResultGroups(Data) : Data,
+ *                     total: Total,
+ *                     aggregateResult: translateAggregateResults(AggregateResults)
+ *                 }))
+ *             );
+ *     }
  * }
  * ```
  * {% endplatform_content %}
@@ -167,6 +173,9 @@ var rules = function (state, encode) {
  *     return class StatefullGrid extends React.Component {
  *         constructor(props) {
  *             super(props);
+ *             // DataSourceRequestState includes:
+ *             // - State properties: skip, take, sort, filter, group
+ *             // - Additional property: aggregates
  *             this.state = { dataState: { skip: 0, take: 20 } };
  *         }
  *
@@ -198,6 +207,9 @@ var rules = function (state, encode) {
  *         }
  *
  *         fetchData(dataState) {
+ *             // DataSourceRequestState includes:
+ *             // - State properties: skip, take, sort, filter, group
+ *             // - Additional property: aggregates
  *             const queryStr = `${toDataSourceRequestString(dataState)}`; // Serialize the state
  *             const hasGroups = dataState.group && dataState.group.length;
  *
@@ -224,11 +236,53 @@ var toDataSourceRequestString = function (state) { return (toQueryString(Object.
     .filter(utils_1.isPresent)).join('&')); };
 exports.toDataSourceRequestString = toDataSourceRequestString;
 /**
- * Converts a [DataSourceRequestState]({% slug api_kendo-data-query_datasourcerequeststate %}) into an object
+ * 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 {DataSourceRequestState} state - The state that will be serialized.
- * @returns {any} - The serialized state.
+ * @param {DataSourceRequestState} state The state that will be serialized.
+ * @returns {any} The serialized state.
+ *
+ * The following code snippet demonstrates how to use the `toDataSourceRequest` method.
+ *
+ * {% platform_content angular %}
+ * ```ts
+ * import { HttpClient } from '@angular/common/http';
+ * import { Observable } from 'rxjs';
+ * import { map } from 'rxjs/operators';
+ * import {
+ *     DataSourceRequestState,
+ *     toDataSourceRequest,
+ *     translateDataSourceResultGroups,
+ *     translateAggregateResults
+ * } from '@progress/kendo-data-query';
+ *
+ * export class ProductService {
+ *     private BASE_URL = 'https://api.example.com/products';
+ *
+ *     constructor(private http: HttpClient) { }
+ *
+ *     public fetch(state: DataSourceRequestState): Observable<GridDataResult> {
+ *
+ *         // DataSourceRequestState includes:
+ *         // - State properties: skip, take, sort, filter, group
+ *         // - Additional property: aggregates
+ *         const dataSourceRequest = toDataSourceRequest(state);
+ *
+ *         const hasGroups = state.group && state.group.length;
+ *
+ *         return this.http
+ *             .post<ServerResponse>(this.BASE_URL, dataSourceRequest)
+ *             .pipe(
+ *                 map(({ Data, Total, AggregateResults }) => ({
+ *                     data: hasGroups ? translateDataSourceResultGroups(Data) : Data,
+ *                     total: Total,
+ *                     aggregateResult: translateAggregateResults(AggregateResults)
+ *                 }))
+ *             );
+ *     }
+ * }
+ * ```
+ * {% endplatform_content %}
  */
 var toDataSourceRequest = function (state) { return (toObject(Object.keys(state)
     .map(rules(state, false))