jqwidgets-ng 12.2.0

package/jqwidgets/jqximport.js

@@ -0,0 +1,2946 @@
+
+/* tslint:disable */
+/* eslint-disable */
+(function ($) {
+    class DataAdapter {
+    constructor ( config ) {
+        if ( !config ) {
+            config = {};
+        }
+
+        const that = Object.assign( this, config );
+
+        const generateKey = function () {
+            const S4 = function () {
+                return ( ( ( 1 + Math.random() ) * 0x10000 ) | 0 ).toString( 16 ).substring( 1 );
+            };
+            return S4();
+        };
+
+        that.key = generateKey();
+
+        that.boundSource = [];
+        that.dataItemById = [];
+
+        if ( that.allowAdd === undefined ) {
+            that.allowAdd = true;
+        }
+
+        if ( that.allowRemove === undefined ) {
+            that.allowRemove = true;
+        }
+
+        if ( that.allowUpdate === undefined ) {
+            that.allowUpdate = true;
+        }
+
+        if ( config.observable === undefined ) {
+            that.observable = true;
+        }
+
+
+        if ( !config.dataSource ) {
+            that.dataSource = [];
+        }
+
+        if ( !config.dataFields ) {
+            that.dataFields = [];
+        }
+        else {
+            /* if (config.dataSource && config.dataSource.length > 0) {
+                 const keys = Object.keys(config.dataSource[0]);
+
+                 //     that.dataFields = [];
+
+                 for (let i = 0; i < keys.length; i++) {
+
+                 }
+             }
+             */
+        }
+
+        if ( !config.dataSourceType ) {
+            that.dataSourceType = 'array';
+        }
+
+        if ( !config.id ) {
+            that.id = null;
+        }
+
+        if ( !config.autoFetch ) {
+            that.autoFetch = true;
+        }
+
+        if ( config.dataFields ) {
+            that.dataFields = config.dataFields;
+        }
+
+        Object.defineProperty( that, 'groupBy', {
+            configurable: false,
+            enumerable: true,
+            get() {
+                if ( !that._groupBy ) {
+                    return [];
+                }
+
+                return that._groupBy;
+            },
+            set( value ) {
+                const updateGrouping = () => {
+                    that.boundHierarchy = null;
+                    that.refreshHierarchy();
+
+                    if ( that.onGroup ) {
+                        that.onGroup();
+                    }
+                }
+
+                that._groupBy = [].concat(value);
+              
+                if ( that.isInitialized ) {
+                    updateGrouping();
+                }
+            }
+        } );
+
+        if ( !config.groupBy ) {
+            that.groupBy = [];
+        }
+        else {
+            if ( config.groupBy.toArray ) {
+                that.groupBy = config.groupBy.toArray();
+            }
+            else {
+                that.groupBy = config.groupBy;
+            }
+        }
+
+        if ( config && config.autoBind !== false ) {
+            that.dataBind();
+        }
+
+        that.isInitialized = true;
+    }
+
+    get dataFields() {
+        const that = this;
+
+        return that._dataFields;
+    }
+
+    set dataFields( value ) {
+        const that = this;
+
+        that._dataFields = that._getDataFieldObjects( value );
+
+        return that._dataFields;
+    }
+
+    _getDataFieldObjects( dataFields ) {
+        //const that = this;
+
+        let dataFieldObjects = [];
+
+        if ( typeof dataFields === 'number' ) {
+            const charCode = 'A'.charCodeAt( 0 );
+            let prefix = '';
+            let index = 0;
+
+            for ( let i = 0; i < dataFields; i++ ) {
+                const letter = String.fromCharCode( charCode + index );
+
+                index++;
+
+                const label = prefix + letter;
+
+                dataFieldObjects.push( { name: label, dataType: 'string' } )
+
+                if ( index >= 26 ) {
+                    index = 0;
+                    prefix += 'A';
+                }
+            }
+        }
+        else if ( dataFields.length > 0 ) {
+            for ( let i = 0; i < dataFields.length; i++ ) {
+                const dataField = dataFields[ i ];
+
+                if ( typeof dataField === 'string' ) {
+                    const dataFieldParts = dataField.split( ':' );
+                    const name = dataFieldParts[ 0 ].trim();
+                    const dataType = dataFieldParts.length > 1 ? dataFieldParts[ 1 ].trim() : 'string';
+
+                    dataFieldObjects.push( { name: name, dataType: dataType } );
+                }
+                else {
+                    dataFieldObjects.push( dataField );
+                }
+            }
+        }
+
+        return dataFieldObjects;
+    }
+
+    get dataSource() {
+        const that = this;
+
+        if ( !that._dataSource ) {
+            that._dataSource = [];
+        }
+
+        return that._dataSource;
+    }
+
+    set dataSource( value ) {
+        const that = this;
+
+        that._dataSource = value;
+
+        if ( that.isInitialized ) {
+            that.boundSource = false === that.observable ? [] : new JQX.ObservableArray();
+            that.dataItemById = [];
+            that.bindingCompleted = false;
+            that.dataBind();
+        }
+    }
+
+    get canNotify() {
+        const that = this;
+
+        if ( that._canNotify === undefined ) {
+            that._canNotify = true;
+        }
+
+        return that._canNotify;
+    }
+
+    set canNotify( value ) {
+        const that = this;
+
+        that._canNotify = value;
+    }
+
+    _notify( changeArgs ) {
+        const that = this;
+
+        if ( !that.canNotify ) {
+            return;
+        }
+
+        if ( that.notifyFn ) {
+            that.notifyFn( changeArgs );
+        }
+    }
+
+    notify( notifyFn ) {
+        const that = this;
+
+        if ( notifyFn ) {
+            that.notifyFn = notifyFn;
+        }
+    }
+
+    toArray() {
+        const that = this;
+
+        return that.boundSource.toArray();
+    }
+
+    dataBind() {
+        const that = this;
+
+        that.clear();
+
+        const completed = () => {
+       
+
+            that._onBindingComplete();
+        }
+
+        if ( typeof that.dataSource === 'string' && ( that.dataSource.indexOf( '.json' ) >= 0 ) ) {
+            that.url = that.dataSource;
+            that.dataSourceType = 'json';
+
+            new Ajax( that, ( data/*, status*/ ) => {
+                that.dataSource = data;
+
+                that._bindToJSON();
+            } );
+        }
+        else if ( typeof that.dataSource === 'string' && ( that.dataSource.indexOf( '.xlsx' ) >= 0 ) ) {
+            that.url = that.dataSource;
+            that.dataSourceType = 'xlsx';
+
+            new Ajax( that, ( data/*, status*/ ) => {
+                if ( !data[ 0 ] ) {
+                    data = [];
+                    that._bindToArray();
+                    completed();
+                    return;
+                }
+
+                const keys = Object.keys( data[ 0 ] );
+                const dataFieldMap = {};
+                const dataRows = [];
+
+                if ( that.exportHeader !== false ) {
+                    let index = 0;
+
+                    for ( let key in keys ) {
+                        const name = keys[ key ];
+
+                        dataFieldMap[ name ] = that.dataFields[ index++ ].name;
+                    }
+
+                    for ( let i = 1; i < data.length; i++ ) {
+                        const row = data[ i ];
+                        const dataRow = {};
+
+                        for ( let key in keys ) {
+                            const name = keys[ key ];
+
+                            dataRow[ dataFieldMap[ name ] ] = row[ name ];
+                        }
+
+                        dataRows.push( dataRow );
+                    }
+
+                    that.dataSource = dataRows;
+                }
+
+                that._bindToArray();
+                completed();
+            } );
+        }
+        else if ( typeof that.dataSource === 'string' && ( that.dataSource.indexOf( '.csv' ) >= 0 ) ) {
+            that.dataSourceType = 'csv';
+
+            new Ajax( that, (/*data, status*/ ) => {
+                that._bindToArray();
+            } );
+        }
+        else if ( typeof that.dataSource === 'string' && ( that.dataSource.indexOf( '.tsv' ) >= 0 ) ) {
+            that.dataSourceType = 'tsv';
+
+            new Ajax( that, (/*data, status*/ ) => {
+            } );
+        }
+        else if ( that.dataSourceType === 'array' ) {
+            that._bindToArray();
+            completed();
+        }
+        else if ( that.dataSourceType === 'json' ) {
+            that._bindToJSON();
+            completed();
+        }
+    }
+
+    _onBindingComplete() {
+        const that = this;
+
+        that._buildHierarchy();
+
+        if ( that.onBindingComplete ) {
+            that.onBindingComplete( { data: that.boundSource } );
+        }
+
+        if ( that._notify ) {
+            that._notify( { action: 'bindingComplete', data: that.boundSource } );
+        }
+
+        that.bindingCompleted = true;
+    }
+
+    refreshHierarchy() {
+        const that = this;
+
+        that._buildHierarchy();
+    }
+
+    find() {
+        const that = this;
+
+        return that.boundSource.find.apply( that.boundSource, arguments );
+    }
+
+    onVirtualDataSourceRequested( requestCallback, details ) {
+        const that = this;
+
+        let first = details ? details.first : Infinity;
+        let last = details ? details.last : Infinity;
+        let row = details ? details.row : null;
+
+        if ( undefined === first ) {
+            first = Infinity;
+        }
+
+        if ( undefined === last ) {
+            last = Infinity;
+        }
+
+        that.virtualFirstIndex = first;
+        that.virtualLastIndex = last;
+
+        if ( that.virtualDataSource ) {
+            const getDataSource = function ( ExcelAdapterSettings ) {
+                if ( ExcelAdapterSettings.virtualDataSourceLength !== undefined ) {
+                    that.virtualDataSourceLength = ExcelAdapterSettings.virtualDataSourceLength;
+                }
+
+                new JQX.ExcelAdapter(
+                    {
+                        dataSource: ExcelAdapterSettings.dataSource,
+                        dataFields: ExcelAdapterSettings.dataFields || that.dataFields,
+                        data: details,
+                        onBindingComplete( event ) {
+
+                            if ( that.virtualDataSourceOnExpand && row ) {
+                                if ( event.data && event.data.length > 0 ) {
+                                    that.add( event.data, row.$.id );
+                                }
+                                else {
+                                    row.leaf = true;
+                                }
+
+                                if ( that.onFilter ) {
+                                    that.onFilter()
+                                }
+
+                                requestCallback();
+
+                                return;
+                            }
+
+                            if ( first === Infinity ) {
+                                that.add( event.data );
+                            }
+                            else {
+                                let items = [];
+                                let indexes = [];
+
+                                for ( let i = 0; i < event.data.length; i++ ) {
+                                    const item = event.data[ i ];
+
+                                    if ( first + i <= last ) {
+                                        items.push( item );
+                                        indexes.push( first + i );
+                                    }
+                                }
+
+                                that.update( indexes, items );
+                            }
+
+
+                            if ( that.onFilter ) {
+                                that.onFilter()
+                            }
+
+                            requestCallback();
+                        }
+                    } );
+            }
+
+            let hasCache = false;
+
+            const isEmpty = ( obj ) => Object.entries( obj ).length === 0 && ( obj.constructor === Object || obj.constructor === Array );
+            const canCache = isEmpty( details.sorting ) && isEmpty( details.filtering ) && isEmpty( details.grouping ) && !details.row && ( details.action !== 'filter' && details.action !== 'sort' && details.action !== 'group' );
+
+            if ( that.virtualDataSourceCache && first !== Infinity && canCache ) {
+                let cachedCount = 0;
+
+                for ( let i = first; i < last; i++ ) {
+                    if ( !that[ i ].$.isEmpty ) {
+                        cachedCount++;
+                    }
+                }
+
+                if ( cachedCount === last - first ) {
+                    hasCache = true;
+                }
+            }
+
+            if ( hasCache ) {
+                requestCallback();
+            }
+            else {
+                if ( details.action === 'expand' ) {
+                    that.virtualDataSourceOnExpand( getDataSource, {
+                        first: first,
+                        last: last,
+                        row: details.row,
+                        sorting: details.sorting,
+                        filtering: details.filtering,
+                        grouping: details.grouping,
+                        action: details.action
+                    } );
+                }
+                else {
+                    that.virtualDataSource( getDataSource, {
+                        first: first,
+                        last: last,
+                        sorting: details.sorting,
+                        filtering: details.filtering,
+                        filterOperator: details.filterOperator || 'and',
+                        grouping: details.grouping,
+                        action: details.action
+                    } );
+                }
+            }
+        }
+        else {
+            requestCallback();
+        }
+    }
+
+    add( item, parentId ) {
+        const that = this;
+
+        if ( !item ) {
+            return;
+        }
+
+        let result = true;
+
+        const addItem = function ( item ) {
+            const itemObject = that._getDataItem( item, that.boundSource.length );
+
+            that[ that.boundSource.length ] = itemObject;
+            that.dataItemById[ itemObject.$.id ] = itemObject;
+
+            const pushResult = that.boundSource.push( itemObject );
+
+            if ( parentId !== undefined ) {
+                itemObject.$.parentId = parentId;
+            }
+
+            if ( !pushResult ) {
+                result = false;
+            }
+
+            return itemObject;
+        }
+
+        if ( item.length ) {
+            let itemObjects = [];
+
+            for ( let i = 0; i < item.length; i++ ) {
+                const itemObject = addItem( item[ i ] );
+
+                itemObjects.push( itemObject );
+            }
+
+            that._notify( { action: 'add', data: itemObjects } );
+        }
+        else {
+            const itemObject = addItem( item );
+
+            that._notify( { action: 'add', data: itemObject } );
+        }
+
+        that.refreshHierarchy();
+
+        return result;
+    }
+
+    refreshIndexes() {
+        const that = this;
+
+        for (let i = 0; i < that.boundSource.length; i++) {
+            that[i] = that.boundSource[i];
+            that[i].$.index = i;
+            that.dataItemById[that[i].$.id] = that[i];
+        }
+
+        let i = that.boundSource.length;
+
+        while (that[i]) {
+            delete that[i];
+            i++;
+        }
+    }
+
+    removeLast() {
+        const that = this;
+
+        delete that[that.boundSource.length - 1];
+        const result = that.boundSource.pop();
+        delete that.dataItemById[result.$.id];
+
+        that._notify({ action: 'removeLast', data: result });
+
+        that.refreshHierarchy();
+
+        return result;
+    }
+
+    removeAt(index) {
+        const that = this;
+
+        const item = that.boundSource[index];
+
+        if (!item) {
+            throw new Error('Invalid Item Index');
+        }
+
+        that.boundSource.splice(index, 1);
+        delete that.dataItemById[item.$.id];
+        that.refreshIndexes();
+
+        that._notify({ action: 'remove', index: index, data: item });
+
+        that.refreshHierarchy();
+    }
+
+    update( index, dataSourceItem ) {
+        const that = this;
+
+        if ( JQX.Utilities.Types.isArray( index ) && JQX.Utilities.Types.isArray( dataSourceItem ) ) {
+            if ( index.length === 0 && dataSourceItem.length === 0 ) {
+                that.refreshHierarchy();
+                return;
+            }
+        }
+
+        if ( dataSourceItem.length && index.length ) {
+            let itemObjects = [];
+
+            for ( let i = 0; i < index.length; i++ ) {
+                const itemObject = that._getDataItem( dataSourceItem[ i ], index[ i ] );
+                const currentIndex = index[ i ];
+
+                itemObjects.push( itemObject );
+
+                that.boundSource[ currentIndex ] = itemObject;
+                that[ currentIndex ] = that.boundSource[ currentIndex ];
+                that.dataItemById[ itemObject.$.id ] = that[ currentIndex ];
+            }
+
+            that._notify( { action: 'update', index: index, data: itemObjects } );
+
+            that.refreshHierarchy();
+
+            return;
+        }
+
+        const itemObject = that._getDataItem( dataSourceItem, index );
+
+        that.boundSource[ index ] = itemObject;
+        that[ index ] = that.boundSource[ index ];
+        that.dataItemById[ itemObject.$.id ] = that[ index ];
+
+        that._notify( { action: 'update', index: index, data: itemObject } );
+
+        that.refreshHierarchy();
+
+        return itemObject;
+    }
+
+    insert( index, item ) {
+        const that = this;
+
+        item = that._getDataItem( item, index );
+
+        const result = that.boundSource.splice( index, 0, item );
+
+        that.refreshIndexes();
+
+        that._notify( { action: 'insert', index: index, data: item } );
+
+        that.refreshHierarchy();
+
+        return result;
+    }
+
+    move( from, to ) {
+        if ( to > from && to - from === 1 || from === to ) {
+            return;
+        }
+
+        const that = this,
+            recordToMove = that.boundSource.splice( from, 1 )[ 0 ];
+
+        if ( to > from ) {
+            to--;
+            that.boundSource.splice( to, 0, recordToMove );
+        }
+        else {
+            that.boundSource.splice( to, 0, recordToMove );
+        }
+
+        that.refreshIndexes();
+
+        that._notify( { action: 'move', index: to, data: that.boundSource[ to ] } );
+
+        that.refreshHierarchy();
+    }
+
+    indexOf( item ) {
+        const that = this;
+        const index = that.boundSource.indexOf( item );
+
+        return index;
+    }
+
+    get length() {
+        const that = this;
+
+        if ( that.virtualDataSourceLength !== undefined ) {
+            return that.virtualDataSourceLength;
+        }
+
+        if ( that.dataSourceLength ) {
+            return that.dataSourceLength;
+        }
+
+        if ( typeof ( that.dataSource ) === 'number' ) {
+            return that.dataSource;
+        }
+
+        if ( that.bindingCompleted ) {
+            return that.boundSource.length;
+        }
+
+        if ( that.dataSource && typeof that.dataSource !== 'string' && that.dataSource.length ) {
+            return that.dataSource.length;
+        }
+
+        return that.boundSource.length;
+    }
+
+    clear() {
+        const that = this;
+
+        if ( !that.isInitialized ) {
+            that._cachedValues = [];
+            that.dataItemById = [];
+            return;
+        }
+
+        for ( let i = 0; i < that.boundSource.length; i++ ) {
+            delete that[ i ];
+        }
+
+        that._cachedValues = [];
+        that.boundSource = that.observable ? new JQX.ObservableArray() : [];
+        that.dataItemById = [];
+        that.refreshHierarchy();
+    }
+
+    _getId( id, item, index ) {
+        if ( id !== null && id.name !== undefined ) {
+            if ( id.name && item.getAttribute ) {
+                let result = item.getAttribute( id.name );
+                if ( result !== null && result.toString().length > 0 ) {
+                    return result;
+                }
+                else if ( id.map ) {
+                    try {
+                        let result = item.getAttribute( id.map );
+                        if ( result !== null && result.toString().length > 0 ) {
+                            return result;
+                        }
+                    }
+                    catch ( error ) {
+                        return index;
+                    }
+                }
+                return;
+            }
+        }
+
+        if ( id ) {
+            if ( id.toString().length > 0 && item.getAttribute ) {
+                let result = item.getAttribute( id );
+                if ( result !== null && result.toString().length > 0 ) {
+                    return result.trim().split( ' ' ).join( '' ).replace( /([ #;?%&,.+*~\':'!^$[\]()=>|\/@])/g, '' );
+                }
+                else {
+                    let splitMap = id.split( this.mapChar );
+                    if ( splitMap.length > 1 ) {
+                        let d = item;
+                        for ( let p = 0; p < splitMap.length; p++ ) {
+                            if ( d !== undefined ) {
+                                d = d[ splitMap[ p ] ];
+                            }
+                        }
+                        if ( d !== undefined ) {
+                            return d;
+                        }
+                    }
+                    else {
+                        if ( item[ id ] !== undefined ) {
+                            return item[ id ];
+                        }
+                    }
+                }
+            }
+        }
+
+        return index;
+    }
+
+    _buildHierarchy() {
+        const that = this;
+
+        if ( !that.reservedNames ) {
+            that.reservedNames = {
+                leaf: 'leaf',
+                parent: 'parent',
+                expanded: 'expanded',
+                checked: 'checked',
+                selected: 'selected',
+                level: 'level',
+                icon: 'icon',
+                data: 'data'
+            }
+        }
+        else {
+            const names = that.reservedNames;
+
+            if ( !names.leaf ) {
+                names.leaf = 'leaf';
+            }
+            if ( !names.parent ) {
+                names.parent = 'parent';
+            }
+            if ( !names.expanded ) {
+                names.expanded = 'expanded';
+            }
+            if ( !names.checked ) {
+                names.checked = 'checked';
+            }
+            if ( !names.selected ) {
+                names.selected = 'selected';
+            }
+            if ( !names.level ) {
+                names.level = 'level';
+            }
+            if ( !names.data ) {
+                names.data = 'data';
+            }
+
+        }
+
+        const names = that.reservedNames;
+
+        if ( that.childrenDataField ) {
+            const hierarchy = [];
+
+            for ( let i = 0; i < that.boundSource.length; i++ ) {
+                const item = Object.assign( {}, that.boundSource[ i ] );
+
+                if ( !item ) {
+                    continue;
+                }
+
+                hierarchy.push( item );
+
+                const addItems = function ( item ) {
+                    const splitMap = that.childrenDataField.split( that.mapChar );
+                    let children = null;
+
+                    if ( splitMap.length > 1 ) {
+                        let data = item;
+
+                        for ( let p = 0; p < splitMap.length; p++ ) {
+                            if ( data !== undefined ) {
+                                data = data[ splitMap[ p ] ];
+                            }
+                        }
+
+                        children = data;
+                    }
+                    else {
+                        children = item[ 'children' ];
+                    }
+
+                    item[ 'children' ] = children;
+
+                    if ( item[ 'children' ] === null || item[ 'children' ] === undefined || ( item[ 'children' ] && item[ 'children' ].length === 0 ) ) {
+                        item[ names.leaf ] = true;
+                    }
+                }
+
+                addItems( item );
+                item[ names.level ] = 0;
+
+                if ( !item.$ ) {
+                    item.$ = {};
+                }
+
+                item[ names.parent ] = null;
+                item[ names.data ] = item;
+
+                if ( item[ names.expanded ] === undefined ) {
+                    item[ names.expanded ] = false;
+                }
+
+                const drillThrough = function ( parent, children ) {
+                    if ( !children ) {
+                        parent[ 'children' ] = new Array();
+                        return;
+                    }
+
+                    for ( let i = 0; i < children.length; i++ ) {
+                        let item = that._getDataItem( children[ i ], i );
+
+                        if ( !item ) {
+                            continue;
+                        }
+
+                        addItems( item );
+                        item[ names.level ] = parent[ names.level ] + 1;
+                        item[ names.parent ] = parent;
+                        item[ names.data ] = item;
+
+                        if ( parent ) {
+                            parent[ 'children' ][ i ] = item;
+                        }
+
+
+                        if ( item[ names.expanded ] === undefined ) {
+                            item[ names.expanded ] = false;
+                        }
+
+                        drillThrough( item, item[ 'children' ] );
+                    }
+                }
+
+                drillThrough( item, item[ 'children' ] );
+            }
+
+
+            that.boundHierarchy = hierarchy;
+
+            if ( !that._boundSourceUpdate ) {
+                for ( let i = 0; i < that.boundHierarchy.length; i++ ) {
+                    const item = that.boundHierarchy[ i ];
+
+                    if ( item.children ) {
+                        const drillThrough = function ( item ) {
+                            if ( !that.dataItemById[ item.$.id ] ) {
+                                that.boundSource.canNotify = false;
+                                that.dataItemById[ item.$.id ] = item;
+                                that[ that.boundSource.length ] = item;
+                                that.boundSource.push( item );
+                                that.boundSource.canNotify = true;
+                            }
+
+                            if ( item.children ) {
+                                for ( let i = 0; i < item.children.length; i++ ) {
+                                    const child = item.children[ i ];
+
+                                    if ( child.children ) {
+                                        drillThrough( child );
+                                    }
+                                }
+                            }
+                        }
+
+                        drillThrough( item );
+                    }
+                }
+
+                that._boundSourceUpdate = true;
+            }
+        }
+
+        if ( that.xmlRoot && that.dataSourceType === 'xml' ) {
+            that.boundHierarchy = this._getHierarchy( 'uid', '_parentuid', 'children', null, that.boundSource );
+        }
+
+        if ( that.keyDataField && that.parentDataField ) {
+            that.boundHierarchy = this._getHierarchy( that.keyDataField, that.parentDataField, 'children', null, that.boundSource );
+        }
+
+        if ( that.groupBy && that.groupBy.length > 0 ) {
+            that.boundHierarchy = this._getGroupHierarchy( that.groupBy, 'children', 'label', null, 'data', null, 'parent', that.boundSource );
+        }
+
+        if ( that.virtualDataSourceOnExpand ) {
+            that.boundHierarchy = this._getHierarchy( 'id', 'parentId', 'children', null, that.boundSource );
+        }
+    }
+
+
+    _getGroupHierarchy( groups, collectionName, groupName, mappingFields, itemName, valueName, parentName, data, startIndex ) {
+        let that = this;
+
+        if ( !startIndex ) {
+            startIndex = 0;
+        }
+
+        let names = that.reservedNames;
+
+        const guid = function () {
+            function s4() {
+                return Math.floor( ( 1 + Math.random() ) * 0x10000 )
+                    .toString( 16 )
+                    .substring( 1 );
+            }
+
+            return s4() + s4() + '-' + s4() + '-' + s4() + '-' + s4() + '-' + s4() + s4() + s4();
+        }
+
+        let groupHashCodes = new Array();
+        for ( let iGroupColumn = 0; iGroupColumn < groups.length; iGroupColumn++ ) {
+            groupHashCodes[ iGroupColumn ] = guid();
+        }
+
+        if ( !collectionName ) {
+            collectionName = 'children';
+        }
+
+        if ( !groupName ) {
+            groupName = 'group';
+        }
+
+        if ( !itemName ) {
+            itemName = 'item';
+        }
+
+        if ( !parentName ) {
+            parentName = 'parent';
+        }
+
+        if ( undefined === valueName ) {
+            valueName = 'value';
+        }
+
+        const groupboundSource = new Array();
+        const hashItemGroups = new Array();
+
+        let groupboundSourceIndex = 0;
+
+        const getItem = function ( item ) {
+            let itemObj = item;
+            if ( mappingFields ) {
+                for ( let mappingField in mappingFields ) {
+                    const mappingObject = mappingFields[ mappingField ];
+
+                    if ( mappingObject.name && mappingObject.map ) {
+                        itemObj[ mappingObject.map ] = itemObj[ mappingObject.name ];
+                    }
+                }
+            }
+
+            return itemObj;
+        }
+
+        for ( let obj = 0; obj < data.length; obj++ ) {
+            let item = Object.assign( {}, getItem( data[ obj ] ) );
+
+            item[ names.leaf ] = false;
+
+            let itemKeysHierarchy = new Array();
+            let keys = 0;
+
+            for ( let iGroupColumn = 0; iGroupColumn < groups.length; iGroupColumn++ ) {
+                const group = groups[ iGroupColumn ];
+                const value = item[ group ];
+
+                if ( null === value ) {
+                    continue;
+                }
+
+                itemKeysHierarchy[ keys++ ] = { value: value, group: group, hash: groupHashCodes[ iGroupColumn ] };
+            }
+
+            if ( itemKeysHierarchy.length !== groups.length ) {
+                break;
+            }
+
+            let parentItem = null;
+            let lookupKey = '';
+
+            for ( let q = 0; q < itemKeysHierarchy.length; q++ ) {
+                const itemKey = itemKeysHierarchy[ q ].value;
+                const groupDataField = itemKeysHierarchy[ q ].group;
+                const columnHash = itemKeysHierarchy[ q ].hash;
+
+                lookupKey = lookupKey + '_' + columnHash + '_' + itemKey;
+
+                if ( hashItemGroups[ lookupKey ] !== undefined && hashItemGroups[ lookupKey ] !== null ) {
+                    parentItem = hashItemGroups[ lookupKey ];
+                    continue;
+                }
+
+                if ( parentItem === null ) {
+                    parentItem = { $: {} };
+
+                    parentItem[ names.level ] = 0;
+                    parentItem[ names.leaf ] = false;
+                    parentItem[ parentName ] = null;
+                    parentItem[ groupName ] = itemKey;
+                    parentItem[ itemName ] = item;
+                    parentItem[ 'groupDataField' ] = groupDataField;
+
+                    if ( !parentItem[ groupDataField ] ) {
+                        parentItem[ groupDataField ] = parentItem.data[ groupDataField ];
+                    }
+
+                    if ( item[ names.expanded ] !== undefined ) {
+                        parentItem[ names.expanded ] = item[ names.expanded ];
+                    }
+                    else {
+                        parentItem[ names.expanded ] = false;
+                    }
+
+                    if ( valueName ) {
+                        parentItem[ valueName ] = item[ valueName ];
+                    }
+
+                    parentItem[ collectionName ] = new Array();
+
+                    let uid = groupboundSource.length + startIndex;
+
+                    if ( !this.id || typeof item.$.id === 'number' || isFinite( item.$.id ) ) {
+                        uid = 'Item' + uid;
+                    }
+                    if ( parentItem.$.id === undefined ) {
+                        parentItem.$.id = uid;
+                    }
+
+                    groupboundSource[ groupboundSourceIndex++ ] = parentItem;
+                }
+                else {
+                    const subItem = { $: {} };
+
+                    subItem[ names.level ] = parentItem[ names.level ] + 1;
+                    subItem[ parentName ] = parentItem;
+                    subItem[ groupName ] = itemKey;
+                    subItem[ collectionName ] = new Array();
+                    subItem[ itemName ] = item;
+                    subItem[ 'groupDataField' ] = groupDataField;
+                    subItem[ names.leaf ] = false;
+
+                    if ( !subItem[ groupDataField ] ) {
+                        subItem[ groupDataField ] = subItem.data[ groupDataField ];
+                    }
+
+                    if ( item[ names.expanded ] !== undefined ) {
+                        subItem[ names.expanded ] = item[ names.expanded ];
+                    }
+                    else {
+                        subItem[ names.expanded ] = false;
+                    }
+
+                    if ( valueName ) {
+                        subItem[ valueName ] = item[ valueName ];
+                    }
+
+                    if ( subItem.$.id === undefined ) {
+                        subItem.$.id = parentItem.$.id + '_' + parentItem[ collectionName ].length;
+                    }
+
+                    parentItem[ collectionName ][ parentItem[ collectionName ].length ] = subItem;
+                    parentItem = subItem;
+                }
+
+                hashItemGroups[ lookupKey ] = parentItem;
+            }
+
+            if ( item ) {
+                item[ names.leaf ] = true;
+            }
+
+            if ( parentItem !== null ) {
+                if ( this.id === null ) {
+                    if ( undefined === item.$.id ) {
+                        item.$.id = parentItem.$.id + '_' + parentItem[ collectionName ].length;
+                    }
+                }
+                else {
+                    if ( undefined === item.$.id ) {
+                        if ( item.$.id.toString().indexOf( parentItem.$.id ) === -1 ) {
+                            item.$.id = parentItem.$.id + '_' + item.$.id;
+                        }
+                    }
+                }
+
+                item[ parentName ] = parentItem;
+                item[ names.level ] = parentItem[ names.level ] + 1;
+                parentItem[ collectionName ][ parentItem[ collectionName ].length ] = item;
+            }
+            else {
+                if ( undefined === item.$.id ) {
+                    item.$.id = guid();
+                }
+            }
+        }
+
+        return groupboundSource;
+    }
+
+    _getHierarchy( fieldName, parentFieldName, collectionName, mappingFields, boundSource ) {
+        const that = this;
+
+        const databoundHierarchy = new Array();
+        let flatData = this.boundSource;
+
+        if ( boundSource ) {
+            flatData = boundSource;
+        }
+
+        if ( this.boundSource.length === 0 )
+            return null;
+
+        const childrenName = collectionName !== null ? collectionName : 'children';
+        let items = new Array();
+        let data = flatData;
+        let dataLength = data.length;
+        let names = that.reservedNames;
+
+        const getItem = function ( item ) {
+            let itemObj = item;
+            if ( mappingFields ) {
+                for ( let mappingField in mappingFields ) {
+                    const mappingObject = mappingFields[ mappingField ];
+
+                    if ( mappingObject.name && mappingObject.map ) {
+                        itemObj[ mappingObject.map ] = itemObj[ mappingObject.name ];
+                    }
+                }
+            }
+
+            return itemObj;
+        }
+
+        // build hierarchical source.
+        for ( let i = 0; i < dataLength; i++ ) {
+            let item = data[ i ];
+            let parentId = item[ parentFieldName ];
+            let id = item[ fieldName ];
+
+            if ( parentFieldName === 'parentId' ) {
+                parentId = item.$.parentId;
+            }
+
+            if ( fieldName === 'id' ) {
+                id = item.$.id;
+            }
+
+            item[ childrenName ] = new Array();
+
+            items[ id ] = { parentId: parentId, item: item };
+        }
+
+        for ( let i = 0; i < dataLength; i++ ) {
+            const item = data[ i ];
+            let parentId = item[ parentFieldName ];
+            let id = item[ fieldName ];
+
+            if ( parentFieldName === 'parentId' ) {
+                parentId = item.$.parentId;
+            }
+
+            if ( fieldName === 'id' ) {
+                id = item.$.id;
+            }
+
+            if ( items[ parentId ] !== undefined ) {
+                let item = { parentId: parentId, item: items[ id ].item };
+                let parentItem = items[ parentId ].item;
+                if ( !parentItem[ childrenName ] ) {
+                    parentItem[ childrenName ] = new Array();
+                }
+                let length = parentItem[ childrenName ].length;
+                item = item.item;
+
+                if ( !names ) {
+                    if ( item.parent === undefined ) {
+                        item.parent = parentItem;
+                    }
+                }
+                else {
+                    if ( item[ names.parent ] === undefined ) {
+                        item[ names.parent ] = parentItem;
+                    }
+                }
+
+                const itemObj = getItem( item );
+
+                parentItem[ childrenName ][ length ] = itemObj;
+                items[ parentId ].item = parentItem;
+                items[ id ].item = item;
+
+            }
+            else {
+                let item = items[ id ].item;
+                if ( !names ) {
+                    if ( item.parent === undefined ) {
+                        item.parent = null;
+                    }
+                }
+                else {
+                    if ( item[ names.parent ] === undefined ) {
+                        item[ names.parent ] = null;
+                    }
+                }
+
+                const itemObj = getItem( item );
+
+                if ( !names ) {
+                    itemObj.level = 0;
+                }
+                else {
+                    itemObj[ names.level ] = 0;
+                }
+
+                databoundHierarchy[ databoundHierarchy.length ] = itemObj;
+            }
+        }
+        if ( databoundHierarchy.length !== 0 ) {
+            let updateLevels = function ( level, children ) {
+                for ( let i = 0; i < children.length; i++ ) {
+                    const child = children[ i ];
+
+                    if ( !names ) {
+                        child.level = level;
+                    }
+                    else {
+                        child[ names.level ] = level;
+                    }
+
+                    const childChildren = child[ childrenName ];
+
+                    if ( childChildren ) {
+                        if ( childChildren.length > 0 ) {
+                            updateLevels( level + 1, childChildren );
+                        }
+                        else {
+                            if ( that.virtualDataSourceOnExpand ) {
+                                if ( child.leaf === undefined ) {
+                                    child.leaf = false;
+                                }
+                            }
+                            else {
+                                if ( !names ) {
+                                    child.leaf = true;
+                                }
+                                else {
+                                    child[ names.leaf ] = true;
+                                }
+                            }
+                        }
+                    }
+                    else {
+                        if ( that.virtualDataSourceOnExpand ) {
+                            if ( child.leaf === undefined ) {
+                                child.leaf = false;
+                            }
+                        }
+                        else {
+                            if ( !names ) {
+                                child.leaf = true;
+                            }
+                            else {
+                                child[ names.leaf ] = true;
+                            }
+                        }
+                    }
+                }
+            };
+            updateLevels( 0, databoundHierarchy );
+        }
+        return databoundHierarchy;
+    }
+
+    summarize( summaryItems, boundSource ) {
+        const that = this;
+
+        if ( !Array.isArray( summaryItems ) ) {
+            summaryItems = [ summaryItems ];
+        }
+
+        let tempSummaryItems = [];
+
+        for ( let i = 0; i < summaryItems.length; i++ ) {
+            const summaryItem = summaryItems[ i ];
+
+            for ( let name in summaryItem ) {
+                const functions = summaryItem[ name ];
+
+                tempSummaryItems.push( { dataField: name, functions: functions } )
+            }
+        }
+
+        summaryItems = tempSummaryItems;
+
+        let data = {};
+        let summaryByDataField = new Array();
+
+        if ( !boundSource ) {
+            boundSource = that.boundSource;
+        }
+
+        let length = boundSource.length;
+
+        if ( length === 0 ) {
+            return;
+        }
+
+        if ( length === undefined ) {
+            return;
+        }
+
+        for ( let i = 0; i < length; i++ ) {
+            let dataItem = boundSource[ i ];
+
+            for ( let j = 0; j < summaryItems.length; j++ ) {
+                const summaryItem = summaryItems[ j ];
+                let value = dataItem[ summaryItem.dataField ];
+
+                if ( summaryItem.functions ) {
+                    data[ summaryItem.dataField ] = data[ summaryItem.dataField ] || {};
+                    summaryByDataField[ summaryItem.dataField ] = summaryByDataField[ summaryItem.dataField ] || 0;
+                    summaryByDataField[ summaryItem.dataField ]++;
+
+                    const _summaryItemFunction = function ( summaryItemObject ) {
+                        for ( let name in summaryItemObject ) {
+                            let oldValue = data[ summaryItem.dataField ][ name ];
+
+                            if ( oldValue === null || oldValue === undefined ) {
+                                data[ summaryItem.dataField ][ name ] = 0;
+                                oldValue = 0;
+                            }
+
+                            if ( typeof summaryItemObject[ name ] === 'function' ) {
+                                oldValue = summaryItemObject[ name ]( oldValue, value, summaryItem.dataField, dataItem );
+                            }
+                            data[ summaryItem.dataField ][ name ] = oldValue;
+                        }
+                    }
+
+                    let canParse = parseFloat( value );
+
+                    if ( isNaN( canParse ) ) {
+                        canParse = false;
+                    }
+                    else {
+                        canParse = true;
+                    }
+
+                    if ( canParse ) {
+                        value = parseFloat( value );
+                    }
+
+                    if ( typeof value === 'number' && isFinite( value ) ) {
+                        summaryItem.functions.forEach( function ( summaryItemFunction ) {
+                            let oldValue = data[ summaryItem.dataField ][ summaryItemFunction ];
+
+                            if ( oldValue === null || oldValue === undefined ) {
+                                oldValue = 0;
+
+                                if ( summaryItemFunction === 'min' ) {
+                                    oldValue = 9999999999999;
+                                }
+
+                                if ( summaryItemFunction === 'max' ) {
+                                    oldValue = -9999999999999;
+                                }
+
+                                if (summaryItemFunction === 'median') {
+                                    oldValue = [];
+                                }
+                            }
+
+                            if ( summaryItemFunction === 'sum' || summaryItemFunction === 'avg' || summaryItemFunction === 'stdev'
+                                || summaryItemFunction === 'stdevp' || summaryItemFunction === 'var' || summaryItemFunction === 'varp' ) {
+                                oldValue += parseFloat( value );
+                            }
+                            else if ( summaryItemFunction === 'product' ) {
+                                if ( i === 0 )
+                                    oldValue = parseFloat( value );
+                                else
+                                    oldValue *= parseFloat( value );
+                            }
+                            else if ( summaryItemFunction === 'min' ) {
+                                oldValue = Math.min( oldValue, parseFloat( value ) );
+                            }
+                            else if ( summaryItemFunction === 'max' ) {
+                                oldValue = Math.max( oldValue, parseFloat( value ) );
+                            }
+                            else if ( summaryItemFunction === 'count' ) {
+                                oldValue++;
+                            }
+                            else if (summaryItemFunction === 'median') {
+                                oldValue.push(parseFloat(value));
+                            }
+                            else if ( typeof ( summaryItemFunction ) === 'object' ) {
+                                _summaryItemFunction( summaryItemFunction );
+                                return;
+                            }
+
+                            data[ summaryItem.dataField ][ summaryItemFunction ] = oldValue;
+                        } );
+                    }
+                    else {
+                        summaryItem.functions.forEach( function ( summaryItemFunction ) {
+                            if ( summaryItemFunction === 'min' || summaryItemFunction === 'max' || summaryItemFunction === 'count' || summaryItemFunction === 'product' || summaryItemFunction === 'sum'
+                                || summaryItemFunction === 'avg' || summaryItemFunction === 'stdev'
+                                || summaryItemFunction === 'stdevp' || summaryItemFunction === 'var' || summaryItemFunction === 'varp' ) {
+                                if ( value === null ) {
+                                    return true;
+                                }
+
+                                let oldValue = data[ summaryItem.dataField ][ summaryItemFunction ];
+
+                                if ( oldValue === null || oldValue === undefined ) {
+                                    oldValue = 0;
+                                }
+
+                                data[ summaryItem.dataField ][ summaryItemFunction ] = oldValue;
+
+                                return true;
+                            }
+
+                            if ( typeof ( summaryItemFunction ) === 'object' ) {
+                                _summaryItemFunction( summaryItemFunction );
+                            }
+                        } );
+                    }
+                }
+            }
+        }
+
+        for ( let j = 0; j < summaryItems.length; j++ ) {
+            const summaryItem = summaryItems[ j ];
+
+            if ( !summaryItem.functions ) {
+                continue;
+            }
+            if ( !data[ summaryItem.dataField ] ) {
+                data[ summaryItem.dataField ] = {};
+
+                summaryItem.functions.forEach( function ( summaryItemFunction ) {
+                    data[ summaryItem.dataField ][ summaryItemFunction ] = 0;
+                } );
+            }
+
+            if ( data[ summaryItem.dataField ][ 'avg' ] !== undefined ) {
+                const value = data[ summaryItem.dataField ][ 'avg' ];
+                const dataValues = summaryByDataField[ summaryItem.dataField ];
+
+                if ( dataValues === 0 || dataValues === undefined ) {
+                    data[ summaryItem.dataField ][ 'avg' ] = 0;
+                }
+                else {
+                    data[ summaryItem.dataField ][ 'avg' ] = value / dataValues;
+                }
+            }
+            else if ( data[ summaryItem.dataField ][ 'count' ] !== undefined ) {
+                data[ summaryItem.dataField ][ 'count' ] = length;
+            }
+            else if (data[summaryItem.dataField]['median'] !== undefined) {
+                let population = data[summaryItem.dataField]['median'];
+
+                population.sort(function (a, b) {
+                    return a - b;
+                });
+
+                data[summaryItem.dataField]['median'] =
+                    0.5 * (population[Math.floor((population.length + 1) / 2) - 1] + population[Math.ceil((population.length + 1) / 2) - 1]);
+            }
+
+            // stdev, stdevp, var, varp.
+            // stdev - Standard deviation on a sample.
+            // varp - Variance on an entire population.
+            // let - Variance on a sample.
+            if ( data[ summaryItem.dataField ][ 'stdev' ] || data[ summaryItem.dataField ][ 'stdevp' ]
+                || data[ summaryItem.dataField ][ 'var' ] || data[ summaryItem.dataField ][ 'varp' ] ) {
+                summaryItem.functions.forEach( function ( summaryItemFunction ) {
+                    if ( summaryItemFunction === 'stdev' || summaryItemFunction === 'var' || summaryItemFunction === 'varp' || summaryItemFunction === 'stdevp' ) {
+                        const value = data[ summaryItem.dataField ][ summaryItemFunction ];
+                        const count = length;
+                        const average = ( value / length );
+                        let sumSq = 0.0;
+
+                        for ( let i = 0; i < length; i++ ) {
+                            let dataItem = boundSource[ i ];
+                            let value = dataItem[ summaryItem.dataField ];
+
+                            sumSq += ( value - average ) * ( value - average );
+                        }
+
+                        let denominator = ( summaryItemFunction === 'stdevp' || summaryItemFunction === 'varp' ) ? count : count - 1;
+
+                        if ( denominator === 0 ) {
+                            denominator = 1;
+                        }
+
+                        if ( summaryItemFunction === 'var' || summaryItemFunction === 'varp' ) {
+                            data[ summaryItem.dataField ][ summaryItemFunction ] = sumSq / denominator;
+                        }
+                        else if ( summaryItemFunction === 'stdevp' || summaryItemFunction === 'stdev' ) {
+                            data[ summaryItem.dataField ][ summaryItemFunction ] = Math.sqrt( sumSq / denominator );
+                        }
+                    }
+                } );
+            }
+        }
+        return data;
+    }
+
+    deserialize(stringValue, type, nullable) {
+        const nullValue = stringValue === 'null';
+
+        if (stringValue === undefined || (nullValue && !nullable)) {
+            return undefined;
+        }
+
+        if (nullValue && nullable) {
+            return null;
+        }
+
+        if (type === 'boolean' || type === 'bool') {
+            if (stringValue === null) {
+                return false;
+            }
+
+            // Boolean properties are set based on the presence of the attribute: if the attribute exists at all, the value is true.
+            return true;
+        }
+        else if (type === 'number' || type === 'float') {
+            if (stringValue === 'NaN') {
+                return NaN;
+            }
+
+            if (stringValue === 'Infinity') {
+                return Infinity;
+            }
+
+            if (stringValue === '-Infinity') {
+                return -Infinity;
+            }
+
+            return parseFloat(stringValue);
+        }
+        else if (type === 'int' || type === 'integer') {
+            if (stringValue === 'NaN') {
+                return NaN;
+            }
+
+            if (stringValue === 'Infinity') {
+                return Infinity;
+            }
+
+            if (stringValue === '-Infinity') {
+                return -Infinity;
+            }
+
+            return parseInt(stringValue);
+        }
+        else if (type === 'string') {
+            return stringValue;
+        }
+        else if (type === 'any') {
+            return stringValue;
+        }
+        else if (type === 'date') {
+            return new Date(stringValue);
+        }
+        else if (type === 'function') {
+            if (typeof window[stringValue] === 'function') {
+                return window[stringValue];
+            }
+        }
+        else if (type === 'array' || type === 'object') {
+            try {
+                const jsonObject = JSON.parse(stringValue);
+
+                if (jsonObject) {
+                    return jsonObject;
+                }
+            }
+            catch (er) {
+                if (window[stringValue] && (typeof window[stringValue] === 'object')) {
+                    return window[stringValue];
+                }
+                else if (type === 'array' && stringValue.indexOf('[') >= 0) {
+                    if (stringValue.indexOf('{') >= 0) {
+                        let array = stringValue.replace(/{/ig, '').replace('[', '').replace(']', '').replace(/'/ig, '').replace(/"/ig, '').trim();
+
+                        array = array.split('},');
+
+                        for (let i = 0; i < array.length; i++) {
+                            let parsedObject = {
+                            };
+
+                            let parts = array[i].trim().split(',');
+
+                            for (let j = 0; j < parts.length; j++) {
+                                const key = parts[j].split(':')[0].trim();
+                                const value = parts[j].split(':')[1].trim();
+
+                                parsedObject[key] = value;
+                            }
+
+                            array[i] = parsedObject;
+                        }
+
+                        return array;
+                    }
+
+                    const array = stringValue.replace('[', '').replace(']', '').replace(/'/ig, '').replace(/"/ig, '').trim().split(',');
+
+                    return array;
+                }
+            }
+        }
+
+        return undefined;
+    }
+
+    _getDataItem( dataSourceItem, index ) {
+        const that = this;
+        const itemObject = {};
+        const unboundMode = typeof ( that.dataSource ) === 'number' || that.dataSourceLength;
+
+        if ( !dataSourceItem ) {
+            return { $: { id: index, isEmpty: true, index: index } }
+        }
+
+        if ( typeof dataSourceItem === 'string' ) {
+            dataSourceItem = { '': dataSourceItem };
+        }
+
+        if ( unboundMode ) {
+            for ( let j = 0; j < that.dataFields.length; j++ ) {
+                const dataField = that.dataFields ? that.dataFields[ j ] : {};
+
+                itemObject[ dataField.name ] = '';
+            }
+
+            itemObject.$ = {};
+            itemObject.$.id = index;
+            itemObject.$.index = index;
+
+            return itemObject;
+        }
+
+        const dataItem = dataSourceItem;
+
+        if ( dataItem.expanded !== undefined ) {
+            itemObject.expanded = dataItem.expanded;
+
+            if ( dataItem.expanded === 'true' || dataItem.expanded === true || dataItem.expanded === 1 ) {
+                itemObject.expanded = true;
+            }
+            else {
+                itemObject.expanded = false;
+            }
+        }
+
+        if ( that.childrenDataField ) {
+            if ( dataItem[ that.childrenDataField ] !== undefined ) {
+                itemObject.children = dataItem[ that.childrenDataField ];
+            }
+        }
+        else {
+            if ( dataItem.children !== undefined ) {
+                itemObject.children = dataItem.children;
+            }
+            else if ( dataItem.items !== undefined ) {
+                itemObject.children = dataItem.items;
+            }
+        }
+        if ( dataItem.leaf !== undefined ) {
+            itemObject.leaf = dataItem.leaf;
+        }
+
+        if ( dataItem.level !== undefined ) {
+            itemObject.level = dataItem.level;
+        }
+
+        if ( that.keyDataField ) {
+            if ( dataItem[ that.keyDataField ] !== undefined ) {
+                itemObject[ that.keyDataField ] = dataItem[ that.keyDataField ];
+            }
+        }
+
+        if ( that.parentDataField ) {
+            if ( dataItem[ that.parentDataField ] !== undefined ) {
+                itemObject[ that.parentDataField ] = dataItem[ that.parentDataField ];
+            }
+        }
+
+        if ( that.dataFields.length === 0 ) {
+            const names = Object.getOwnPropertyNames( dataSourceItem );
+
+            for ( let i = 0; i < names.length; i++ ) {
+                if ( names[ i ] === '$' ) {
+                    continue;
+                }
+
+                that.dataFields.push( { name: names[ i ], dataType: 'string' } );
+            }
+        }
+
+        for ( let j = 0; j < that.dataFields.length; j++ ) {
+            const dataField = that.dataFields ? that.dataFields[ j ] : {};
+            let value = '';
+
+            dataField.dataType = dataField.type;
+            
+            if ( undefined === dataField || dataField === null ) {
+                continue;
+            }
+
+            if ( dataSourceItem.length ) {
+                value = dataSourceItem[ j ];
+            }
+
+            if ( dataField.map ) {
+                let splitMap = dataField.map.split( that.mapChar );
+
+                if ( splitMap.length > 0 ) {
+                    let dataMappedItem = dataItem;
+
+                    for ( let p = 0; p < splitMap.length; p++ ) {
+                        if ( !dataItem ) {
+                            continue;
+                        }
+
+                        dataMappedItem = dataMappedItem[ splitMap[ p ] ];
+                    }
+
+                    value = dataMappedItem;
+                }
+                else {
+                    value = dataItem[ dataField.map ];
+                }
+            }
+
+            if ( value !== undefined && value !== null ) {
+                value = value.toString();
+            }
+            else {
+                if ( value === undefined && value !== null ) {
+                    value = '';
+                }
+            }
+
+
+            let isEmptyString = false;
+            // searches by both selectors when necessary.
+            if ( value === '' ) {
+                isEmptyString = true;
+                value = dataSourceItem[ dataField.name ];
+
+                if ( value !== undefined && value !== null ) {
+                    if ( dataField.dataType !== 'array' ) {
+                        if ( dataField.dataType !== 'date' ) {
+                            value = value.toString();
+                        }
+                    }
+                }
+                else {
+                    value = '';
+                }
+            }
+
+            if ( value === '[object Object]' && dataField.map && isEmptyString ) {
+                value = '';
+            }
+
+            if ( that._cachedValues[ '' + value + '_' + dataField.dataType ] ) {
+                value = that._cachedValues[ '' + value + '_' + dataField.dataType ];
+            }
+            else {
+                if ( dataField.dataType === 'bool' || dataField.dataType === 'boolean' ) {
+                    if ( value === 'true' || value === '1' ) {
+                        value = true;
+                    }
+                    else if ( value === 'false' || value === '0' ) {
+                        value = false;
+                    }
+                }
+                else {
+                    value = that.deserialize( '' + value, dataField.dataType, true );
+                }
+
+                that._cachedValues[ value + '_' + dataField.dataType ] = value;
+            }
+
+            if ( dataField.dataType !== 'string' && dataField.dataType !== 'boolean' && dataField.dataType !== 'bool' ) {
+                if ( isNaN( value ) || value === -Infinity || value === Infinity ) {
+                    value = 0;
+                }
+            }
+
+            itemObject[ dataField.name ] = value;
+        }
+
+        let itemObjectId = index;
+
+        if ( that.id ) {
+            itemObjectId = dataItem[ that.id ];
+            if ( typeof ( itemObjectId ) === 'object' ) {
+                itemObjectId = index;
+            }
+        }
+        else if ( !that.virtualDataSource && that.dataItemById && that.dataItemById[ itemObjectId ] ) {
+            itemObjectId = that.length;
+        }
+
+        if ( !itemObject.$ ) {
+            itemObject.$ = {};
+        }
+
+        itemObject.$.id = itemObjectId;
+        itemObject.$.index = index;
+
+        return new Object( itemObject );
+    }
+
+    _bindToArray() {
+        const that = this;
+
+        const unboundMode = typeof ( that.dataSource ) === 'number' || that.dataSourceLength;
+        const dataArray = [];
+
+        that.boundSource.canNotify = false;
+
+        for ( let i = 0; i < that.length; i++ ) {
+            const dataSourceItem = unboundMode ? {} : that.dataSource[ i ];
+            const itemObject = that._getDataItem( dataSourceItem, i );
+
+            dataArray.push( itemObject );
+        }
+
+        if ( unboundMode && that.dataSourceLength && that.dataSource.length > 0 ) {
+            for ( let i = 0; i < that.dataSource.length; i++ ) {
+                const cell = that.dataSource[ i ].cell;
+                const value = that.dataSource[ i ].value;
+
+                const row = cell.replace( /[^0-9]/g, '' );
+                const dataField = cell.replace( /[0-9]/g, '' );
+
+                dataArray[ row - 1 ][ dataField ] = value;
+            }
+        }
+
+        that.boundSource = dataArray;
+
+        for ( let i = 0; i < that.length; i++ ) {
+            that[ i ] = that.boundSource[ i ];
+            that.dataItemById[ that[ i ].$.id ] = that[ i ];
+        }
+
+        that.boundSource.canNotify = true;
+    }
+
+    _bindToJSON() {
+        const that = this;
+
+        const dataArray = [];
+
+        const dataEntries = Object.entries( that.dataSource );
+
+        that.boundSource.canNotify = false;
+
+        for ( let i = 0; i < dataEntries.length; i++ ) {
+            const dataSourceItem = dataEntries[ i ];
+            const itemObject = that._getDataItem( dataSourceItem, i );
+
+            dataArray.push( itemObject );
+        }
+
+        that.boundSource = false === that.observable ? dataArray : new JQX.ObservableArray( dataArray );
+
+        for ( let i = 0; i < that.length; i++ ) {
+            that[ i ] = that.boundSource[ i ];
+            that.dataItemById[ that[ i ].$.id ] = that[ i ];
+        }
+
+        that.boundSource.canNotify = true;
+    }
+
+    sortBy( dataField, dataType, orderBy ) {
+        const that = this;
+
+        if ( !dataType ) {
+            for ( let i = 0; i < that.dataFields.length; i++ ) {
+                const field = that.dataFields[ i ];
+
+                if ( field.name === dataField ) {
+                    dataType = field.dataType;
+                    break;
+                }
+            }
+        }
+
+        if ( that.boundHierarchy ) {
+            if ( ( !dataField || dataField.length === 0 ) && that.groupBy.length > 0 ) {
+                that.refreshHierarchy();
+                return;
+            }
+
+            const sortBy = function ( hierarchy ) {
+                that._sort( hierarchy, dataField, orderBy, dataType );
+
+                for ( let i = 0; i < hierarchy.length; i++ ) {
+                    const item = hierarchy[ i ];
+
+                    if ( item[ 'children' ] ) {
+                        sortBy( item[ 'children' ], dataField, orderBy, dataType );
+                    }
+                }
+            }
+
+            sortBy( that.boundHierarchy );
+        }
+        else {
+            that._sort( that.boundSource, dataField, orderBy, dataType );
+        }
+    }
+
+    _createFilter( dataType, filterExpressions ) {
+        const filterOperators = {
+            '=': 'EQUAL',
+            '<>': 'NOT_EQUAL',
+            '<': 'LESS_THAN',
+            '>': 'GREATER_THAN',
+            '<=': 'LESS_THAN_OR_EQUAL',
+            '>=': 'GREATER_THAN_OR_EQUAL',
+            'equal': 'EQUAL',
+            'not equal': 'NOT_EQUAL',
+            'less than': 'LESS_THAN',
+            'greater than': 'GREATER_THAN',
+            'greater than or equal': 'GREATER_THAN_OR_EQUAL',
+            'less than or equal': 'LESS_THAN_OR_EQUAL',
+            'starts with': 'STARTS_WITH',
+            'ends with': 'ENDS_WITH',
+            'null': 'null',
+            '': 'EMPTY',
+            'isblank': 'EMPTY',
+            'isnotblank': 'NOT_EMPTY',
+            'contains': 'CONTAINS',
+            'notcontains': 'DOES_NOT_CONTAIN',
+            'startswith': 'STARTS_WITH',
+            'endswith': 'ENDS_WITH',
+            'NULL': 'NULL',
+            'NOT_NULL': 'NOT_NULL'
+        };
+
+        let filterExpressionsArray = [];
+
+        for ( let i = 0; i < filterExpressions.length; i++ ) {
+            const filterExpression = filterExpressions[ i ];
+
+            const filterExpressionParts = filterExpression.indexOf( '"' ) === -1 ? filterExpression.split( ' ' ) : filterExpression.split( '"' );
+            let filter = [];
+
+            for ( let j = 0; j < filterExpressionParts.length; j++ ) {
+                const part = filterExpressionParts[ j ];
+
+                if ( part !== '' ) {
+                    filter.push( part.trim() );
+                }
+            }
+
+            filterExpressionsArray.push( filter );
+        }
+
+        const filterGroup = new JQX.FilterGroup();
+        const filterGroupOperators = [];
+        const filterSubGroups = [];
+
+        for ( let i = 0; i < filterExpressionsArray.length; i++ ) {
+            const filterExpression = filterExpressionsArray[ i ];
+
+
+            if ( filterExpression.length > 1 ) {
+                const filterSubGroup = new JQX.FilterGroup();
+
+                let operator = 'and';
+                let filterExpressionPartsCounter = 0;
+
+                for ( let j = 0; j < filterExpression.length; j++ ) {
+                    const value = filterExpression[ j ];
+
+                    if ( value === 'and' || value === 'or' ) {
+                        operator = value;
+                        continue;
+                    }
+
+                    filterExpressionPartsCounter++;
+
+                    if ( filterExpressionPartsCounter === 2 ) {
+                        const filter = filterSubGroup.createFilter( dataType, value, filterOperators[ filterExpression[ j - 1 ] ] );
+
+                        filterExpressionPartsCounter = 0;
+
+                        if ( operator ) {
+                            filterSubGroup.addFilter( operator, filter );
+                        }
+                    }
+                }
+
+                filterSubGroups.push( filterSubGroup );
+            }
+            else {
+                const filterGroupOperator = filterExpression[ 0 ];
+
+                if ( filterGroupOperator !== 'and' && filterGroupOperator !== 'or' ) {
+                    throw new Error( 'Filter Exprresion expects "AND" or "OR", but the token is: ' + filterGroupOperator );
+                }
+
+                filterGroupOperators.push( filterGroupOperator );
+            }
+        }
+
+        let operatorsCounter = 0;
+
+        if ( filterSubGroups.length === 1 ) {
+            return filterSubGroups[ 0 ];
+        }
+
+        for ( let i = 0; i < filterSubGroups.length; i++ ) {
+            let operator = filterGroupOperators[ operatorsCounter ];
+
+            if ( ( i + 1 ) % 2 === 0 ) {
+                operatorsCounter++;
+            }
+
+            if ( !operator ) {
+                operator = 'and';
+            }
+
+            filterGroup.addFilter( operator, filterSubGroups[ i ] );
+        }
+
+        return filterGroup;
+    }
+
+    filterBy( dataField, ...filterExpressions ) {
+        const that = this;
+
+
+        const dataType = ( () => {
+            for ( let i = 0; i < that.dataFields.length; i++ ) {
+                const field = that.dataFields[ i ];
+
+                if ( field.name === dataField ) {
+                    return field.dataType;
+                }
+            }
+        } )();
+
+
+        const filterGroup = that._createFilter( dataType, filterExpressions );
+
+        let filteredData = that.boundSource.filter( ( value ) => {
+            const evaluation = filterGroup.evaluate( value[ dataField ] );
+
+            return evaluation;
+        } );
+
+        return filteredData;
+    }
+
+    _filter( filters, operator = 'and' ) {
+        const that = this;
+        const filterGroups = [];
+        const dataFields = [];
+
+        if ( filters.length === 0 ) {
+            that.clearFilter();
+            return;
+        }
+
+        const dataType = ( dataField ) => {
+            for ( let i = 0; i < that.dataFields.length; i++ ) {
+                const field = that.dataFields[ i ];
+
+                if ( field.name === dataField ) {
+                    return field.dataType;
+                }
+            }
+        };
+        let defaultResult, operatorSpecificEval;
+
+        if ( operator === 'and' ) {
+            defaultResult = true;
+            operatorSpecificEval = function ( result, filterGroup, row ) {
+                return result && filterGroup.evaluate( row[ filterGroup.dataField ] );
+            };
+        }
+        else {
+            defaultResult = false;
+            operatorSpecificEval = function ( result, filterGroup, row ) {
+                return result || filterGroup.evaluate( row[ filterGroup.dataField ] );
+            };
+        }
+
+        for ( let i = 0; i < filters.length; i++ ) {
+            const filter = filters[ i ];
+            const dataField = filter[ 0 ];
+            let filterGroup = null;
+
+            if ( filter[ 1 ] instanceof JQX.FilterGroup ) {
+                filterGroup = filter[ 1 ];
+            }
+            else {
+                filterGroup = that._createFilter( dataType( dataField ), filter.splice( 1 ) );
+            }
+
+            if ( filterGroup ) {
+                dataFields.push( dataField );
+                filterGroup.dataField = dataField;
+                filterGroups.push( filterGroup );
+            }
+        }
+
+        if ( that.boundHierarchy ) {
+            const filter = function ( row ) {
+                let result = defaultResult;
+
+                for ( let j = 0; j < filterGroups.length; j++ ) {
+                    const filterGroup = filterGroups[ j ];
+
+                    result = operatorSpecificEval( result, filterGroup, row );
+                }
+
+                row.$.filtered = result;
+
+                return result;
+            }
+
+            const filterBy = function ( hierarchy, parentItem, root ) {
+                let filteredCount = 0;
+
+                for ( let i = 0; i < hierarchy.length; i++ ) {
+                    const item = hierarchy[ i ];
+
+                    filter( item );
+
+                    if ( item.$.filtered ) {
+                        filteredCount++;
+                    }
+
+                    if ( item[ 'children' ] ) {
+                        filterBy( item[ 'children' ], item, parentItem );
+                    }
+                }
+
+                if ( filteredCount > 0 && that.groupBy.length > 0 && parentItem ) {
+                    parentItem.$.filtered = true;
+
+                    if ( root && !root.$.filtered ) {
+                        root.$.filtered = true;
+                    }
+                }
+                else {
+                    if ( filteredCount > 0 && filteredCount !== hierarchy.length && parentItem ) {
+                        parentItem.$.filtered = null;
+
+                        if ( root && !root.$.filtered ) {
+                            root.$.filtered = null;
+                        }
+                    }
+                }
+            }
+
+            filterBy( that.boundHierarchy, null, null );
+        }
+        else {
+            for ( let i = 0; i < that.boundSource.length; i++ ) {
+                const row = that.boundSource[ i ];
+
+                let result = defaultResult;
+
+                for ( let j = 0; j < filterGroups.length; j++ ) {
+                    const filterGroup = filterGroups[ j ];
+
+                    result = operatorSpecificEval( result, filterGroup, row );
+                }
+
+                row.$.filtered = result;
+            }
+        }
+
+        if ( that.onFilter ) {
+            that.onFilter()
+        }
+    }
+
+    clearGroup() {
+        const that = this;
+
+        that.groupBy = [];
+        that.boundHierarchy = null;
+        that.refreshHierarchy();
+
+        if ( that.onGroup ) {
+            that.onGroup()
+        }
+    }
+
+    clearFilter() {
+        const that = this;
+
+        for ( let i = 0; i < that.boundSource.length; i++ ) {
+            const row = that.boundSource[ i ];
+
+            row.$.filtered = true;
+        }
+
+        if ( that.boundHierarchy ) {
+            const filterBy = function ( hierarchy, parentItem, root ) {
+                //let filteredCount = 0;
+
+                for ( let i = 0; i < hierarchy.length; i++ ) {
+                    const item = hierarchy[ i ];
+
+                    item.$.filtered = true;
+
+                    if ( item.$.filtered ) {
+                        //filteredCount++;
+                    }
+
+                    if ( item[ 'children' ] ) {
+                        filterBy( item[ 'children' ], item, parentItem );
+                    }
+                }
+
+                if ( parentItem ) {
+                    parentItem.$.filtered = true;
+
+                    if ( root && !root.$.filtered ) {
+                        root.$.filtered = true;
+                    }
+                }
+            }
+
+            filterBy( that.boundHierarchy, null, null );
+        }
+
+        if ( that.onFilter ) {
+            that.onFilter()
+        }
+    }
+
+    clearSort() {
+        const that = this;
+
+        that._sort( that.boundSource, [], [], [] );
+    }
+
+    _sort( dataSource, sortColumns, directions, dataTypes, customSortingCallback ) {
+        const that = this;
+
+        let isObservableArray = false;
+
+        if ( dataSource.length === 0 ) {
+            return;
+        }
+
+        if ( dataSource && dataSource.constructor && dataSource instanceof JQX.ObservableArray ) {
+            isObservableArray = true;
+        }
+
+        if ( !dataSource || !( Array.isArray( dataSource ) ) || dataSource.length === 0 ||
+            !sortColumns || Array.isArray( sortColumns ) && sortColumns.length === 0 ) {
+            if ( !isObservableArray && !that.boundHierarchy ) {
+                throw new Error( 'sort: Missing or Invalid arguments!' );
+            }
+        }
+
+        if ( typeof sortColumns === 'string' ) {
+            sortColumns = [ sortColumns ];
+        }
+
+        const directionCoefficients = [],
+            compareFunctions = [];
+
+        if ( directions === undefined ) {
+            directions = [];
+        }
+
+        const getCompareFunction = function ( a, knownDataType ) {
+            // gets data type of column (not necessary if the Grid provides this information)
+            const dataType = knownDataType || typeof a;
+            let compareFunction;
+
+            switch ( dataType ) {
+                case 'string':
+                    compareFunction = new Intl.Collator().compare;
+                    break;
+                case 'number':
+                    compareFunction = function ( a, b ) {
+                        return a - b;
+                    };
+                    break;
+                case 'boolean':
+                case 'bool':
+                    compareFunction = function ( a, b ) {
+                        if ( a === b ) {
+                            return 0;
+                        }
+                        else if ( a === false ) {
+                            return -1;
+                        }
+                        else {
+                            return 1;
+                        }
+                    };
+                    break;
+                case 'date':
+                case 'time':
+                case 'dateTime':
+                    if ( a instanceof Date ) {
+                        compareFunction = function ( a, b ) {
+                            return a.getTime() - b.getTime();
+                        };
+                    }
+                    else if ( a instanceof JQX.Utilities.DateTime ||
+                        a instanceof JQX.Utilities.BigNumber ) {
+                        compareFunction = function ( a, b ) {
+                            return a.compare( b );
+                        };
+                    }
+                    break;
+                case 'object':
+                    if ( a instanceof Date ) {
+                        compareFunction = function ( a, b ) {
+                            return a.getTime() - b.getTime();
+                        };
+                    }
+                    else if ( a instanceof JQX.Utilities.DateTime ||
+                        a instanceof JQX.Utilities.BigNumber ) {
+                        compareFunction = function ( a, b ) {
+                            return a.compare( b );
+                        };
+                    }
+                    else if ( a instanceof JQX.Utilities.Complex || ( window.NIComplex && a instanceof window.NIComplex ) ) {
+                        const complexNumericProcessor = new JQX.Utilities.ComplexNumericProcessor();
+
+                        compareFunction = function ( a, b ) {
+                            return complexNumericProcessor.compareComplexNumbers( a, b );
+                        }
+                    }
+
+                    break;
+            }
+
+            return compareFunction;
+        }
+
+        for ( let i = 0; i < sortColumns.length; i++ ) {
+            if ( directions[ i ] === undefined || directions[ i ] === 'asc' || directions[ i ] === 'ascending' ) {
+                directionCoefficients[ i ] = 1;
+            }
+            else {
+                directionCoefficients[ i ] = -1;
+            }
+
+            const value = dataSource[ 0 ][ sortColumns[ i ] ];
+
+            compareFunctions[ i ] = getCompareFunction( value, dataTypes[ i ] );
+        }
+
+        if ( customSortingCallback ) {
+            customSortingCallback( dataSource, sortColumns, directions, compareFunctions );
+            return;
+        }
+
+        dataSource.sort( function ( a, b ) {
+            for ( let i = 0; i < sortColumns.length; i++ ) {
+                const result = compareFunctions[ i ]( a[ sortColumns[ i ] ], b[ sortColumns[ i ] ] );
+
+                if ( result === 0 ) {
+                    if ( sortColumns[ i + 1 ] ) {
+                        continue;
+                    }
+                    else if ( a._index !== undefined ) {
+                        // makes sorting stable
+                        return ( a._index - b._index ) * directionCoefficients[ i ];
+                    }
+
+                    return 0;
+                }
+
+                return result * directionCoefficients[ i ];
+            }
+
+            if ( sortColumns.length === 0 ) {
+                if ( a.$.index < b.$.index ) {
+                    return -1;
+                }
+
+                if ( a.$.index > b.$.index ) {
+                    return 1;
+                }
+
+                return 0;
+
+            }
+        } );
+
+        for ( let i = 0; i < dataSource.length; i++ ) {
+            that[ i ] = dataSource[ i ];
+        }
+    }
+
+    static Filter( dataSource, filterColumns, filterGroups, customFilteringCallback, operator = 'and' ) {
+        let defaultResult, operatorSpecificEval;
+
+        if ( operator === 'and' ) {
+            defaultResult = true;
+            operatorSpecificEval = function ( result, dataItem, filterColumn, filterGroup ) {
+                if ( customFilteringCallback ) {
+                    return result && customFilteringCallback( dataItem, filterColumn, filterGroup );
+                }
+
+                return result && filterGroup.evaluate( dataItem[ filterColumn ] );
+            };
+        }
+        else {
+            defaultResult = false;
+            operatorSpecificEval = function ( result, dataItem, filterColumn, filterGroup ) {
+                if ( customFilteringCallback ) {
+                    return result || customFilteringCallback( dataItem, filterColumn, filterGroup );
+                }
+
+                return result || filterGroup.evaluate( dataItem[ filterColumn ] );
+            };
+        }
+
+        const filteredData = dataSource.filter( ( dataItem ) => {
+            let result = defaultResult;
+
+            for ( let i = 0; i < filterGroups.length; i++ ) {
+                const filterGroup = filterGroups[ i ];
+                const filterColumn = filterColumns[ i ];
+
+                result = operatorSpecificEval( result, dataItem, filterColumn, filterGroup );
+            }
+
+            return result;
+        } );
+
+        return filteredData;
+    }
+
+    filter( filterColumns, filterGroups, customFilteringCallback ) {
+        JQX.ExcelAdapter.Filter( this.boundSource, filterColumns, filterGroups, customFilteringCallback );
+    }
+
+    sort( sortColumns, directions, customSortingCallback ) {
+        JQX.ExcelAdapter.Sort( this.boundSource, sortColumns, directions, customSortingCallback );
+    }
+
+    static Sort( dataSource, sortColumns, directions, customSortingCallback ) {
+        const getCompareFunction = function ( a ) {
+            // gets data type of column (not necessary if the Grid provides this information)
+            const dataType = typeof a;
+            let compareFunction;
+
+            switch ( dataType ) {
+                case 'string':
+                    compareFunction = new Intl.Collator().compare;
+                    break;
+                case 'number':
+                    compareFunction = function ( a, b ) {
+                        return a - b;
+                    };
+                    break;
+                case 'boolean':
+                    compareFunction = function ( a, b ) {
+                        if ( a === b ) {
+                            return 0;
+                        }
+                        else if ( a === false ) {
+                            return -1;
+                        }
+                        else {
+                            return 1;
+                        }
+                    };
+                    break;
+                case 'object':
+                    if ( a instanceof Date ) {
+                        compareFunction = function ( a, b ) {
+                            return a.getTime() - b.getTime();
+                        };
+                    }
+                    else if ( a instanceof JQX.Utilities.DateTime ||
+                        a instanceof BigNumberNG ) {
+                        compareFunction = function ( a, b ) {
+                            return a.compare( b );
+                        };
+                    }
+                    else if ( a instanceof JQX.Utilities.Complex || ( window.NIComplex && a instanceof window.NIComplex ) ) {
+                        const complexNumericProcessor = new JQX.Utilities.ComplexNumericProcessor();
+
+                        compareFunction = function ( a, b ) {
+                            return complexNumericProcessor.compareComplexNumbers( a, b );
+                        }
+                    }
+
+                    break;
+            }
+
+            return compareFunction;
+        }
+
+        if ( !dataSource || !( Array.isArray( dataSource ) ) || dataSource.length === 0 ||
+            !sortColumns || Array.isArray( sortColumns ) && sortColumns.length === 0 ) {
+            return;
+        }
+
+        if ( typeof sortColumns === 'string' ) {
+            sortColumns = [ sortColumns ];
+        }
+
+        const directionCoefficients = [],
+            compareFunctions = [];
+
+        if ( directions === undefined ) {
+            directions = [];
+        }
+
+        for ( let i = 0; i < sortColumns.length; i++ ) {
+            if ( directions[ i ] === undefined || directions[ i ] === 'asc' || directions[ i ] === 'ascending' ) {
+                directionCoefficients[ i ] = 1;
+            }
+            else {
+                directionCoefficients[ i ] = -1;
+            }
+
+            compareFunctions[ i ] = getCompareFunction( dataSource[ 0 ][ sortColumns[ i ] ] );
+        }
+
+        if ( customSortingCallback ) {
+            customSortingCallback( dataSource, sortColumns, directions, compareFunctions );
+            return;
+        }
+
+        const sortedData = dataSource.slice( 0 );
+
+        sortedData.sort( function ( a, b ) {
+            for ( let i = 0; i < sortColumns.length; i++ ) {
+                const result = compareFunctions[ i ]( a[ sortColumns[ i ] ], b[ sortColumns[ i ] ] );
+
+                if ( result === 0 ) {
+                    if ( sortColumns[ i + 1 ] ) {
+                        continue;
+                    }
+                    else if ( a._index !== undefined ) {
+                        // makes sorting stable
+                        return ( a._index - b._index ) * directionCoefficients[ i ];
+                    }
+
+                    return 0;
+                }
+
+                return result * directionCoefficients[ i ];
+            }
+        } );
+
+        return sortedData;
+    }
+}
+
+window.jqxDataSource = DataAdapter;
+
+class Ajax {
+    constructor ( config, callback ) {
+        const that = this;
+
+        that.config = config;
+        that.callback = callback;
+
+        if ( config.autoFetch === false ) {
+            return;
+        }
+
+        that.call( config );
+    }
+
+    call( config ) {
+        const that = this;
+
+        if ( !config ) {
+            config = that.config;
+        }
+
+        let method = 'GET',
+            url = config.url,
+            body = null,
+            async = true;
+
+        if ( config.type ) {
+            method = config.type;
+        }
+
+        if ( config.data ) {
+            if ( method === 'GET' ) {
+                url += '?';
+
+                for ( let prop in config.data ) {
+                    if ( config.data.hasOwnProperty( prop ) ) {
+                        url += encodeURI( prop + '=' + config.data[ prop ] + '&' );
+                    }
+                }
+
+                if ( url.charAt( url.length - 1 ) === '&' ) {
+                    url = url.slice( 0, url.length - 1 );
+                }
+            }
+            else if ( method === 'POST' ) {
+                body = JSON.stringify( config.data );
+            }
+        }
+
+        if ( config && config.async === false && config.dataSourceType !== 'xlsx' ) {
+            async = false;
+        }
+
+        if ( window.fetch !== undefined && async ) {
+            that.ajaxFetch( config, method, url, body );
+        }
+        else {
+            that.ajaxXMLHttpRequest( config, method, url, body, async );
+        }
+    }
+
+    ajaxFetch( config, method, url, body ) {
+        // prepare fetch config
+        const that = this;
+        const fetchInit = { method: method };
+        let parseMethod;
+
+        switch ( config.dataSourceType ) {
+            case 'json':
+                parseMethod = 'json';
+                break;
+            case 'xlsx':
+                parseMethod = 'arrayBuffer';
+                break;
+            default:
+                parseMethod = 'text';
+        }
+
+        if ( config ) {
+            if ( config.contentType ) {
+                fetchInit.headers = new Headers( {
+                    'Content-Type': config.contentType
+                } );
+            }
+        }
+
+        if ( body !== null ) {
+            fetchInit.body = body;
+        }
+
+        let status, fetchTimeout, timeouted;
+
+        if ( config.timeout ) {
+            fetchTimeout = setTimeout( function () {
+                timeouted = true;
+            }, config.timeout );
+        }
+
+        if ( config.beforeSend ) {
+            const beforeSendResult = config.beforeSend( fetchInit, config );
+
+            if ( beforeSendResult === false ) {
+                return;
+            }
+        }
+
+        // fetch resource
+        fetch( url, fetchInit )
+            .then( function ( response ) {
+                if ( timeouted ) {
+                    status = 408;
+                    throw new Error( 'timeout' );
+                }
+
+                if ( fetchTimeout ) {
+                    clearTimeout( fetchTimeout );
+                }
+
+                status = response.status;
+
+                if ( !response.ok ) {
+                    throw new Error( response.statusText );
+                }
+
+                return response[ parseMethod ]();
+            } )
+            .then( function ( data ) {
+                if ( parseMethod === 'arrayBuffer' ) {
+                    return JSZip.loadAsync( data ).then( function ( zipData ) {
+                        // "data" represents the whole XLSX/ZIP file
+                        return zipData.files[ 'xl/worksheets/sheet1.xml' ].async( 'text' ).then( function ( sheet1 ) {
+                            return zipData.files[ 'xl/sharedStrings.xml' ].async( 'text' ).then( function ( sharedStrings ) {
+                                const parsedData = that.parseXLSXData( sheet1, sharedStrings );
+
+                                that.ajaxComplete( config, parsedData, status );
+                            } );
+                        } );
+                    } );
+                }
+                else {
+                    that.ajaxComplete( config, data, status );
+                }
+            } )
+            .catch( function ( error ) {
+                if ( error.message === 'JSZip is not defined' ) {
+                    error.message = 'JSZip is not defined. Please include a reference to JSZip to be able to load data from XLSX files.';
+                }
+
+                if ( config && config.loadError ) {
+                    config.loadError( status, error );
+                }
+
+                if ( that.callback ) {
+                    that.callback( error, status );
+                }
+            } );
+    }
+
+    ajaxXMLHttpRequest( config, method, url, body, async ) {
+        const request = new XMLHttpRequest();
+        const that = this;
+
+        request.open( method, url, async );
+
+        request.ontimeout = function () {
+            if ( config && config.loadError ) {
+                config.loadError( 408, 'timeout' );
+            }
+        };
+
+        request.onload = function () {
+            if ( request.readyState === 4 ) {
+                const status = request.status;
+                let data = request.response;
+
+                if ( status >= 200 && status <= 299 ) {
+                    if ( config.dataSourceType === 'json' ) {
+                        data = JSON.parse( data );
+                    }
+
+                    that.ajaxComplete( config, data, status );
+                }
+                else if ( config && config.loadError ) {
+                    config.loadError( status, data );
+                }
+            }
+        };
+
+        request.onerror = function () {
+            if ( config && config.loadError ) {
+                config.loadError( request.status, request.response );
+            }
+        };
+
+        if ( config && config.contentType ) {
+            request.setRequestHeader( 'Content-Type', config.contentType );
+        }
+
+        if ( async && config.timeout ) {
+            request.timeout = config.timeout;
+        }
+
+        if ( config.beforeSend ) {
+            const beforeSendResult = config.beforeSend( request, config );
+
+            if ( beforeSendResult === false ) {
+                return;
+            }
+        }
+
+        request.send( body );
+    }
+
+    ajaxComplete( config, data, status ) {
+        if ( !config ) {
+            return;
+        }
+
+        if ( config.beforeLoadComplete ) {
+            const processedData = config.beforeLoadComplete( data );
+
+            if ( processedData ) {
+                data = processedData;
+            }
+        }
+
+        if ( config.loadComplete ) {
+            config.loadComplete( data, status );
+        }
+
+        if ( this.callback ) {
+            this.callback( data, status );
+        }
+    }
+
+    parseXLSXData( sheet1, sharedStrings ) {
+        const parser = new DOMParser(),
+            sharedStringsDocument = parser.parseFromString( sharedStrings, 'text/xml' ),
+            sharedStringsContainers = Array.from( sharedStringsDocument.getElementsByTagName( 'si' ) ),
+            sharedStringsCollection = [],
+            sheet1Document = parser.parseFromString( sheet1, 'text/xml' ),
+            rows = Array.from( sheet1Document.getElementsByTagName( 'row' ) ),
+            parsedData = [];
+
+        sharedStringsContainers.forEach( function ( si ) {
+            let texts = si.getElementsByTagName( 't' );
+
+            if ( texts.length === 1 ) {
+                sharedStringsCollection.push( texts[ 0 ].innerHTML );
+            }
+            else {
+                let text = '';
+
+                texts = Array.from( texts );
+                texts.forEach( function ( t ) {
+                    text += t.innerHTML;
+                } );
+                sharedStringsCollection.push( text );
+            }
+        } );
+
+        rows.forEach( function ( row ) {
+            const rowObject = {},
+                cells = Array.from( row.getElementsByTagName( 'c' ) );
+
+            cells.forEach( function ( cell/*, index*/ ) {
+                const column = cell.getAttribute( 'r' ).match( /\D+/ )[ 0 ],
+                    type = cell.getAttribute( 't' ),
+                    xmlValue = cell.getElementsByTagName( 'v' )[ 0 ].innerHTML;
+                let value;
+
+                switch ( type ) {
+                    case 's':
+                        // string
+                        value = sharedStringsCollection[ parseFloat( xmlValue ) ];
+                        break;
+                    case 'b':
+                        // boolean
+                        value = parseFloat( xmlValue ) === 1;
+                        break;
+                    default:
+                        // number or date
+                        value = parseFloat( xmlValue );
+                }
+
+                rowObject[ column ] = value;
+            } );
+
+            parsedData.push( rowObject );
+        } );
+
+        return parsedData;
+    }
+}
+if ($.jqx && $.jqx.dataAdapter) {
+    $.jqx.dataAdapter.Importer = DataAdapter;
+}
+})(jqxBaseFramework);