igniteui-webcomponents-datasources 1.4.1 → 1.4.2

package/esm2015/lib/RestVirtualDataSourceDataProviderWorkerSettings.js

@@ -0,0 +1,154 @@
+import { AsyncVirtualDataSourceDataProviderWorkerSettings } from "igniteui-webcomponents-core";
+import { markType } from "igniteui-webcomponents-core";
+export let RestVirtualDataSourceDataProviderWorkerSettings = /*@__PURE__*/ (() => {
+    class RestVirtualDataSourceDataProviderWorkerSettings extends AsyncVirtualDataSourceDataProviderWorkerSettings {
+        constructor() {
+            super(...arguments);
+            this._baseUri = null;
+            this._entitySet = null;
+            this._sortDescriptions = null;
+            this._filterExpressions = null;
+            this._propertiesRequested = null;
+            this._groupDescriptions = null;
+            this._summaryDescriptions = null;
+            this._fixedFullCount = -1;
+            this._provideFullCount = null;
+            this._provideOrderByParameter = null;
+            this._provideFilterParameter = null;
+            this._provideAggregationParameter = null;
+            this._provideAggregatedCount = null;
+            this._provideUri = null;
+            this._providePagingParameter = null;
+            this._provideDesiredPropertiesParameter = null;
+            this._performFetch = null;
+        }
+        get baseUri() {
+            return this._baseUri;
+        }
+        set baseUri(value) {
+            this._baseUri = value;
+        }
+        get entitySet() {
+            return this._entitySet;
+        }
+        set entitySet(value) {
+            this._entitySet = value;
+        }
+        get sortDescriptions() {
+            return this._sortDescriptions;
+        }
+        set sortDescriptions(value) {
+            this._sortDescriptions = value;
+        }
+        get filterExpressions() {
+            return this._filterExpressions;
+        }
+        set filterExpressions(value) {
+            this._filterExpressions = value;
+        }
+        get propertiesRequested() {
+            return this._propertiesRequested;
+        }
+        set propertiesRequested(value) {
+            this._propertiesRequested = value;
+        }
+        get groupDescriptions() {
+            return this._groupDescriptions;
+        }
+        set groupDescriptions(value) {
+            this._groupDescriptions = value;
+        }
+        get summaryDescriptions() {
+            return this._summaryDescriptions;
+        }
+        set summaryDescriptions(value) {
+            this._summaryDescriptions = value;
+        }
+        get summaryScope() {
+            return this._summaryscope;
+        }
+        set summaryScope(value) {
+            this._summaryscope = value;
+        }
+        get enableJsonp() {
+            return this._enableJsonp;
+        }
+        set enableJsonp(isEnabled) {
+            this._enableJsonp = isEnabled;
+        }
+        get isAggregationSupported() {
+            return this._isAggregationSupported;
+        }
+        set isAggregationSupported(isSupported) {
+            this._isAggregationSupported = isSupported;
+        }
+        get fixedFullCount() {
+            return this._fixedFullCount;
+        }
+        set fixedFullCount(value) {
+            this._fixedFullCount = value;
+        }
+        get provideFullCount() {
+            return this._provideFullCount;
+        }
+        set provideFullCount(value) {
+            this._provideFullCount = value;
+        }
+        get provideOrderByParameter() {
+            return this._provideOrderByParameter;
+        }
+        set provideOrderByParameter(value) {
+            this._provideOrderByParameter = value;
+        }
+        get provideFilterParameter() {
+            return this._provideFilterParameter;
+        }
+        set provideFilterParameter(value) {
+            this._provideFilterParameter = value;
+        }
+        get provideAggregationParameter() {
+            return this._provideAggregationParameter;
+        }
+        set provideAggregationParameter(value) {
+            this._provideAggregationParameter = value;
+        }
+        get provideAggregatedCount() {
+            return this._provideAggregatedCount;
+        }
+        set provideAggregatedCount(value) {
+            this._provideAggregatedCount = value;
+        }
+        get provideUri() {
+            return this._provideUri;
+        }
+        set provideUri(value) {
+            this._provideUri = value;
+        }
+        get providePagingParameter() {
+            return this._providePagingParameter;
+        }
+        set providePagingParameter(value) {
+            this._providePagingParameter = value;
+        }
+        get provideDesiredPropertiesParameter() {
+            return this._provideDesiredPropertiesParameter;
+        }
+        set provideDesiredPropertiesParameter(value) {
+            this._provideDesiredPropertiesParameter = value;
+        }
+        get provideItems() {
+            return this._provideItems;
+        }
+        set provideItems(value) {
+            this._provideItems = value;
+        }
+        get performFetch() {
+            return this._performFetch;
+        }
+        set performFetch(value) {
+            this._performFetch = value;
+        }
+    }
+    RestVirtualDataSourceDataProviderWorkerSettings.$t = /*@__PURE__*/ markType(RestVirtualDataSourceDataProviderWorkerSettings, 'RestVirtualDataSourceDataProviderWorkerSettings', AsyncVirtualDataSourceDataProviderWorkerSettings.$type);
+    return RestVirtualDataSourceDataProviderWorkerSettings;
+})();

package/esm2015/lib/RestVirtualDataSourcePage.js

@@ -0,0 +1,67 @@
+import { DataSourceSchemaPropertyType } from "igniteui-webcomponents-core";
+export class RestVirtualDataSourcePage {
+    constructor(sourceData_, schema, groupInformation, summaryInformation, pageIndex) {
+        this._actualData = null;
+        this._schema = null;
+        this._pageIndex = 0;
+        this._groupInformation = null;
+        this._summaryInformation = null;
+        if (sourceData_ == null) {
+            this._actualData = null;
+        }
+        else {
+            let count = (sourceData_.items.length);
+            this._actualData = [];
+            let dateProps = new Set();
+            for (let i = 0; i < schema.propertyNames.length; i++) {
+                if (schema.propertyTypes[i] == DataSourceSchemaPropertyType.DateTimeValue || schema.propertyTypes[i] == DataSourceSchemaPropertyType.DateTimeOffsetValue) {
+                    dateProps.add(schema.propertyNames[i]);
+                }
+            }
+            let value_;
+            for (let i_ = 0; i_ < count; i_++) {
+                let currItem_ = sourceData_.items[i_];
+                let dict = new Map();
+                let properties = Array.from(Object.keys(currItem_));
+                let values = (properties.map((k) => currItem_[k]));
+                for (let i1 = 0; i1 < properties.length; i1++) {
+                    value_ = values[i1];
+                    if (dateProps.has(properties[i1])) {
+                        value_ = new Date(value_);
+                    }
+                    dict.set(properties[i1], value_);
+                }
+                this._actualData[i_] = dict;
+            }
+        }
+        this._schema = schema;
+        this._groupInformation = groupInformation;
+        this._summaryInformation = summaryInformation;
+        this._pageIndex = pageIndex;
+    }
+    count() {
+        return this._actualData.length;
+    }
+    getItemAtIndex(index) {
+        return this._actualData[index];
+    }
+    getItemValueAtIndex(index, valueName) {
+        let item = this._actualData[index];
+        if (!item.has(valueName)) {
+            return null;
+        }
+        return item.get(valueName);
+    }
+    pageIndex() {
+        return this._pageIndex;
+    }
+    schema() {
+        return this._schema;
+    }
+    getGroupInformation() {
+        return this._groupInformation;
+    }
+    getSummaryInformation() {
+        return this._summaryInformation;
+    }
+}

package/esm2015/lib/RestVirtualDataSourceProviderTaskDataHolder.js

@@ -0,0 +1,8 @@
+import { AsyncVirtualDataSourceProviderTaskDataHolder } from "igniteui-webcomponents-core";
+import { markType } from "igniteui-webcomponents-core";
+export let RestVirtualDataSourceProviderTaskDataHolder = /*@__PURE__*/ (() => {
+    class RestVirtualDataSourceProviderTaskDataHolder extends AsyncVirtualDataSourceProviderTaskDataHolder {
+    }
+    RestVirtualDataSourceProviderTaskDataHolder.$t = /*@__PURE__*/ markType(RestVirtualDataSourceProviderTaskDataHolder, 'ODataVirtualDataSourceProviderTaskDataHolder', AsyncVirtualDataSourceProviderTaskDataHolder.$type);
+    return RestVirtualDataSourceProviderTaskDataHolder;
+})();

package/esm2015/lib/Schema.js

@@ -52,4 +52,3 @@ export class Schema {
         ;
     }
 }
-//# sourceMappingURL=Schema.js.map

package/esm2015/lib/util.js

@@ -114,4 +114,3 @@ export class LinkedListNode {
         this._next = value;
     }
 }
-//# sourceMappingURL=util.js.map

package/esm2015/public_api.js

@@ -8,6 +8,11 @@ export * from './lib/ODataVirtualDataSourceDataProvider';
 export * from './lib/ODataVirtualDataSourceDataProviderWorker';
 export * from './lib/ODataVirtualDataSourceDataProviderWorkerSettings';
 export * from './lib/ODataVirtualDataSourceProviderTaskDataHolder';
+export * from './lib/RestVirtualDataSource';
+export * from './lib/RestVirtualDataSourceDataProvider';
+export * from './lib/RestVirtualDataSourceDataProviderWorker';
+export * from './lib/RestVirtualDataSourceDataProviderWorkerSettings';
+export * from './lib/RestVirtualDataSourcePage';
+export * from './lib/RestVirtualDataSourceProviderTaskDataHolder';
 export * from './lib/Schema';
 export * from './lib/util';
-//# sourceMappingURL=public_api.js.map

package/esm5/igniteui-webcomponents-datasources.js

@@ -1,2 +1 @@
 export * from './public_api';
-//# sourceMappingURL=igniteui-webcomponents-datasources.js.map

package/esm5/lib/Entity.js

@@ -77,4 +77,3 @@ var Entity = /** @class */ /*@__PURE__*/ (function () {
     return Entity;
 }());
 export { Entity };
-//# sourceMappingURL=Entity.js.map

package/esm5/lib/EntityProperty.js

@@ -39,4 +39,3 @@ var EntityProperty = /** @class */ /*@__PURE__*/ (function () {
     return EntityProperty;
 }());
 export { EntityProperty };
-//# sourceMappingURL=EntityProperty.js.map

package/esm5/lib/EntitySet.js

@@ -66,4 +66,3 @@ var EntitySet = /** @class */ /*@__PURE__*/ (function () {
     return EntitySet;
 }());
 export { EntitySet };
-//# sourceMappingURL=EntitySet.js.map

package/esm5/lib/ODataDataSourcePage.js

@@ -71,4 +71,3 @@ var ODataDataSourcePage = /** @class */ /*@__PURE__*/ (function () {
     return ODataDataSourcePage;
 }());
 export { ODataDataSourcePage };
-//# sourceMappingURL=ODataDataSourcePage.js.map

package/esm5/lib/ODataSchemaProvider.js

@@ -157,4 +157,3 @@ var ODataSchemaProvider = /** @class */ /*@__PURE__*/ (function () {
     return ODataSchemaProvider;
 }());
 export { ODataSchemaProvider };
-//# sourceMappingURL=ODataSchemaProvider.js.map

package/esm5/lib/ODataVirtualDataSource.js

@@ -167,4 +167,3 @@ var ODataVirtualDataSource = /** @class */ /*@__PURE__*/ (function (_super) {
     return ODataVirtualDataSource;
 }(VirtualDataSource));
 export { ODataVirtualDataSource };
-//# sourceMappingURL=ODataVirtualDataSource.js.map

package/esm5/lib/ODataVirtualDataSourceDataProvider.js

@@ -544,4 +544,3 @@ var ODataVirtualDataSourceDataProvider = /** @class */ /*@__PURE__*/ (function (
     return ODataVirtualDataSourceDataProvider;
 }(Base));
 export { ODataVirtualDataSourceDataProvider };
-//# sourceMappingURL=ODataVirtualDataSourceDataProvider.js.map

package/esm5/lib/ODataVirtualDataSourceDataProviderWorker.js

@@ -899,4 +899,3 @@ var ODataVirtualDataSourceDataProviderWorker = /** @class */ /*@__PURE__*/ (func
     return ODataVirtualDataSourceDataProviderWorker;
 }(AsyncVirtualDataSourceProviderWorker));
 export { ODataVirtualDataSourceDataProviderWorker };
-//# sourceMappingURL=ODataVirtualDataSourceDataProviderWorker.js.map

package/esm5/lib/ODataVirtualDataSourceDataProviderWorkerSettings.js

@@ -118,4 +118,3 @@ var ODataVirtualDataSourceDataProviderWorkerSettings = /** @class */ /*@__PURE__
     return ODataVirtualDataSourceDataProviderWorkerSettings;
 }(AsyncVirtualDataSourceDataProviderWorkerSettings));
 export { ODataVirtualDataSourceDataProviderWorkerSettings };
-//# sourceMappingURL=ODataVirtualDataSourceDataProviderWorkerSettings.js.map

package/esm5/lib/ODataVirtualDataSourceProviderTaskDataHolder.js

@@ -10,4 +10,3 @@ var ODataVirtualDataSourceProviderTaskDataHolder = /** @class */ /*@__PURE__*/ (
     return ODataVirtualDataSourceProviderTaskDataHolder;
 }(AsyncVirtualDataSourceProviderTaskDataHolder));
 export { ODataVirtualDataSourceProviderTaskDataHolder };
-//# sourceMappingURL=ODataVirtualDataSourceProviderTaskDataHolder.js.map

package/esm5/lib/RestVirtualDataSource.js

@@ -0,0 +1,357 @@
+import * as tslib_1 from "tslib";
+import { VirtualDataSource } from "igniteui-webcomponents-core";
+import { RestVirtualDataSourceDataProvider } from "./RestVirtualDataSourceDataProvider";
+var RestVirtualDataSource = /** @class */ /*@__PURE__*/ (function (_super) {
+    tslib_1.__extends(RestVirtualDataSource, _super);
+    function RestVirtualDataSource() {
+        var _this = _super.call(this) || this;
+        _this._baseUri = null;
+        _this._isFilteringSupportedByServer = false;
+        _this._entitySet = null;
+        _this._timeoutMilliseconds = 10000;
+        _this._isAggregationSupportedByServer = false;
+        _this._enableJsonp = true;
+        _this._fixedFullCount = -1;
+        _this._provideFullCount = null;
+        _this._provideOrderByParameter = null;
+        _this._provideFilterParameter = null;
+        _this._provideAggregationParameter = null;
+        _this._provideAggregatedCount = null;
+        _this._provideUri = null;
+        _this._performFetch = null;
+        _this._providePagingParameter = null;
+        _this._provideDesiredPropertiesParameter = null;
+        _this.dataProvider = ((function () {
+            var $ret = new RestVirtualDataSourceDataProvider();
+            $ret.executionContext = _this.executionContext;
+            $ret.enableJsonp = _this.enableJsonp;
+            $ret.isAggregationSupported = _this.isGroupingSupported;
+            return $ret;
+        })());
+        _this.externalDataSource = _this;
+        return _this;
+    }
+    RestVirtualDataSource.prototype.onBaseUriChanged = function (oldValue, newValue) {
+        if (this.actualDataProvider) {
+            this.actualDataProvider.baseUri = this.baseUri;
+            this.queueAutoRefresh();
+        }
+    };
+    Object.defineProperty(RestVirtualDataSource.prototype, "baseUri", {
+        get: function () {
+            return this._baseUri;
+        },
+        set: function (value) {
+            var oldValue = this._baseUri;
+            this._baseUri = value;
+            if (oldValue != this._baseUri) {
+                this.onBaseUriChanged(oldValue, this._baseUri);
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    RestVirtualDataSource.prototype.onEntitySetChanged = function (oldValue, newValue) {
+        if (this.actualDataProvider) {
+            this.actualDataProvider.entitySet = this.entitySet;
+            this.queueAutoRefresh();
+        }
+        this.queueAutoRefresh();
+    };
+    Object.defineProperty(RestVirtualDataSource.prototype, "isFilteringSupportedByServer", {
+        get: function () {
+            return this._isFilteringSupportedByServer;
+        },
+        set: function (v) {
+            this._isFilteringSupportedByServer = v;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    RestVirtualDataSource.prototype.get_isFilteringSupported = function () {
+        if (this._isFilteringSupportedByServer) {
+            return true;
+        }
+        return false;
+    };
+    Object.defineProperty(RestVirtualDataSource.prototype, "entitySet", {
+        get: function () {
+            return this._entitySet;
+        },
+        set: function (value) {
+            var oldValue = this._entitySet;
+            this._entitySet = value;
+            if (this._entitySet != oldValue) {
+                this.onEntitySetChanged(oldValue, this._entitySet);
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    RestVirtualDataSource.prototype.onTimeoutMillisecondsChanged = function (oldValue, newValue) {
+        if (this.actualDataProvider) {
+            this.actualDataProvider.timeoutMilliseconds = this.timeoutMilliseconds;
+        }
+    };
+    Object.defineProperty(RestVirtualDataSource.prototype, "timeoutMilliseconds", {
+        get: function () {
+            return this._timeoutMilliseconds;
+        },
+        set: function (value) {
+            var oldValue = this._timeoutMilliseconds;
+            this._timeoutMilliseconds = value;
+            if (oldValue != this._timeoutMilliseconds) {
+                this.onTimeoutMillisecondsChanged(oldValue, this._timeoutMilliseconds);
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(RestVirtualDataSource.prototype, "isSortingSupportedOverride", {
+        get: function () {
+            return true;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(RestVirtualDataSource.prototype, "isFilteringSupportedOverride", {
+        get: function () {
+            return true;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(RestVirtualDataSource.prototype, "isGroupingSupportedOverride", {
+        get: function () {
+            return this.isAggregationSupportedByServer;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(RestVirtualDataSource.prototype, "isAggregationSupportedByServer", {
+        get: function () {
+            return this._isAggregationSupportedByServer;
+        },
+        set: function (isSupported) {
+            this._isAggregationSupportedByServer = isSupported;
+            if (this.actualDataProvider) {
+                this.actualDataProvider.isAggregationSupported = this.isAggregationSupportedByServer;
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(RestVirtualDataSource.prototype, "enableJsonp", {
+        get: function () {
+            return this._enableJsonp;
+        },
+        set: function (isEnabled) {
+            this._enableJsonp = isEnabled;
+            if (this.actualDataProvider) {
+                this.actualDataProvider.enableJsonp = this.enableJsonp;
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(RestVirtualDataSource.prototype, "fixedFullCount", {
+        get: function () {
+            return this._fixedFullCount;
+        },
+        set: function (value) {
+            this._fixedFullCount = value;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(RestVirtualDataSource.prototype, "provideFullCount", {
+        get: function () {
+            return this._provideFullCount;
+        },
+        set: function (value) {
+            this._provideFullCount = value;
+            if (this.actualDataProvider) {
+                this.actualDataProvider.provideFullCount = this.provideFullCount;
+                this.queueAutoRefresh();
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(RestVirtualDataSource.prototype, "provideOrderByParameter", {
+        get: function () {
+            return this._provideOrderByParameter;
+        },
+        set: function (value) {
+            this._provideOrderByParameter = value;
+            if (this.actualDataProvider) {
+                this.actualDataProvider.provideOrderByParameter = this.provideOrderByParameter;
+                this.queueAutoRefresh();
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(RestVirtualDataSource.prototype, "provideFilterParameter", {
+        get: function () {
+            return this._provideFilterParameter;
+        },
+        set: function (value) {
+            this._provideFilterParameter = value;
+            if (this.actualDataProvider) {
+                this.actualDataProvider.provideFilterParameter = this.provideFilterParameter;
+                this.queueAutoRefresh();
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(RestVirtualDataSource.prototype, "provideAggregationParameter", {
+        get: function () {
+            return this._provideAggregationParameter;
+        },
+        set: function (value) {
+            this._provideAggregationParameter = value;
+            if (this.actualDataProvider) {
+                this.actualDataProvider.provideAggregationParameter = this.provideAggregationParameter;
+                this.queueAutoRefresh();
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(RestVirtualDataSource.prototype, "provideAggregatedCount", {
+        get: function () {
+            return this._provideAggregatedCount;
+        },
+        set: function (value) {
+            this._provideAggregatedCount = value;
+            if (this.actualDataProvider) {
+                this.actualDataProvider.provideAggregatedCount = this.provideAggregatedCount;
+                this.queueAutoRefresh();
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(RestVirtualDataSource.prototype, "provideUri", {
+        get: function () {
+            return this._provideUri;
+        },
+        set: function (value) {
+            this._provideUri = value;
+            if (this.actualDataProvider) {
+                this.actualDataProvider.provideUri = this.provideUri;
+                this.queueAutoRefresh();
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(RestVirtualDataSource.prototype, "performFetch", {
+        get: function () {
+            return this._performFetch;
+        },
+        set: function (value) {
+            this._performFetch = value;
+            if (this.actualDataProvider) {
+                this.actualDataProvider.performFetch = this.performFetch;
+                this.queueAutoRefresh();
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(RestVirtualDataSource.prototype, "providePagingParameter", {
+        get: function () {
+            return this._providePagingParameter;
+        },
+        set: function (value) {
+            this._providePagingParameter = value;
+            if (this.actualDataProvider) {
+                this.actualDataProvider.providePagingParameter = this.providePagingParameter;
+                this.queueAutoRefresh();
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(RestVirtualDataSource.prototype, "provideDesiredPropertiesParameter", {
+        get: function () {
+            return this._provideDesiredPropertiesParameter;
+        },
+        set: function (value) {
+            this._provideDesiredPropertiesParameter = value;
+            if (this.actualDataProvider) {
+                this.actualDataProvider.provideDesiredPropertiesParameter = this.provideDesiredPropertiesParameter;
+                this.queueAutoRefresh();
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(RestVirtualDataSource.prototype, "provideItems", {
+        get: function () {
+            return this._provideItems;
+        },
+        set: function (value) {
+            this._provideItems = value;
+            if (this.actualDataProvider) {
+                this.actualDataProvider.provideItems = this.provideItems;
+                this.queueAutoRefresh();
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    RestVirtualDataSource.prototype.clone = function () {
+        var dataSource = new RestVirtualDataSource();
+        dataSource.executionContext = this.executionContext;
+        dataSource.includeSummaryRowsInSection = this.includeSummaryRowsInSection;
+        dataSource.isSectionCollapsable = this.isSectionCollapsable;
+        dataSource.isSectionExpandedDefault = this.isSectionExpandedDefault;
+        //dataSource.isSectionHeaderNormalRow = this.isSectionHeaderNormalRow;
+        dataSource.isSectionSummaryRowsAtBottom = this.isSectionSummaryRowsAtBottom;
+        //dataSource.isSectionContentVisible = this.isSectionContentVisible;
+        dataSource.primaryKey = this.primaryKey;
+        dataSource.propertiesRequested = this.propertiesRequested;
+        dataSource.sectionHeaderDisplayMode = this.sectionHeaderDisplayMode;
+        dataSource.shouldEmitSectionFooters = this.shouldEmitSectionFooters;
+        dataSource.shouldEmitSectionHeaders = this.shouldEmitSectionHeaders;
+        dataSource.shouldEmitShiftedRows = this.shouldEmitShiftedRows;
+        dataSource.summaryScope = this.summaryScope;
+        for (var i = 0; i < this.groupDescriptions.size(); i++) {
+            dataSource.groupDescriptions.add(this.groupDescriptions.get(i));
+        }
+        for (var i = 0; i < this.sortDescriptions.size(); i++) {
+            dataSource.sortDescriptions.add(this.sortDescriptions.get(i));
+        }
+        for (var i = 0; i < this.filterExpressions.size(); i++) {
+            dataSource.filterExpressions.add(this.filterExpressions.get(i));
+        }
+        for (var i = 0; i < this.summaryDescriptions.size(); i++) {
+            dataSource.summaryDescriptions.add(this.summaryDescriptions.get(i));
+        }
+        dataSource.pageSizeRequested = this.pageSizeRequested;
+        dataSource.maxCachedPages = this.maxCachedPages;
+        dataSource.baseUri = this.baseUri;
+        dataSource.entitySet = this.entitySet;
+        dataSource.timeoutMilliseconds = this.timeoutMilliseconds;
+        dataSource.isAggregationSupportedByServer = this.isAggregationSupportedByServer;
+        dataSource.enableJsonp = this.enableJsonp;
+        dataSource.fixedFullCount = this.fixedFullCount;
+        dataSource.provideAggregationParameter = this.provideAggregationParameter;
+        dataSource.provideAggregatedCount = this.provideAggregatedCount;
+        dataSource.provideFilterParameter = this.provideFilterParameter;
+        dataSource.provideFullCount = this.provideFullCount;
+        dataSource.provideOrderByParameter = this.provideOrderByParameter;
+        dataSource.provideUri = this.provideUri;
+        dataSource.performFetch = this.performFetch;
+        dataSource.providePagingParameter = this.providePagingParameter;
+        dataSource.provideItems = this.provideItems;
+        dataSource.provideDesiredPropertiesParameter = this.provideDesiredPropertiesParameter;
+        return dataSource;
+    };
+    return RestVirtualDataSource;
+}(VirtualDataSource));
+export { RestVirtualDataSource };