bms: comparison www/jqwidgets/jqximport.js

comparison: www/jqwidgets/jqximport.js

www/jqwidgets/jqximport.js

changeset 733: 67bf19c50fcc

equal deleted inserted replaced

-:db4de4f37b65
+:67bf19c50fcc
+/* 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);