igniteui-webcomponents-datasources 7.1.1-beta.1 → 7.1.1-beta.3

package/esm2015/lib/ODataVirtualDataSourceDataProviderWorker.js

@@ -1,713 +0,0 @@
-import { AsyncVirtualDataSourceProviderWorker } from "igniteui-webcomponents-core";
-import { SortDescriptionCollection } from "igniteui-webcomponents-core";
-import { ODataVirtualDataSourceProviderTaskDataHolder } from "./ODataVirtualDataSourceProviderTaskDataHolder";
-import { AsyncDataSourcePageTaskHolder } from "igniteui-webcomponents-core";
-import { AsyncVirtualDataTask } from "igniteui-webcomponents-core";
-import { ODataDataSourcePage } from "./ODataDataSourcePage";
-import { DefaultSectionInformation } from "igniteui-webcomponents-core";
-import { Convert } from "igniteui-webcomponents-core";
-import { ODataSchemaProvider } from "./ODataSchemaProvider";
-import { ODataDataSourceFilterExpressionVisitor } from "igniteui-webcomponents-core";
-import { ListSortDirection } from "igniteui-webcomponents-core";
-import { stringIsNullOrEmpty } from "igniteui-webcomponents-core";
-import { DataSourceSummaryOperand } from "igniteui-webcomponents-core";
-import { DataSourceSummaryScope } from "igniteui-webcomponents-core";
-import { DefaultSummaryResult } from "igniteui-webcomponents-core";
-import { TransactionType } from "igniteui-webcomponents-core";
-import { ODataDataSourceSchema } from "igniteui-webcomponents-core";
-let ODataVirtualDataSourceDataProviderWorker = /*@__PURE__*/ (() => {
-    class ODataVirtualDataSourceDataProviderWorker extends AsyncVirtualDataSourceProviderWorker {
-        get sortDescriptions() {
-            return this._sortDescriptions;
-        }
-        get filterExpressions() {
-            return this._filterExpressions;
-        }
-        get desiredProperties() {
-            return this._desiredPropeties;
-        }
-        initialize() {
-            super.initialize();
-        }
-        getTaskDataHolder() {
-            let holder = new ODataVirtualDataSourceProviderTaskDataHolder();
-            return holder;
-        }
-        getCompletedTaskData(holder, completed) {
-            super.getCompletedTaskData(holder, completed);
-        }
-        removeCompletedTaskData(holder, completed) {
-            super.removeCompletedTaskData(holder, completed);
-        }
-        getTasksData(holder) {
-            super.getTasksData(holder);
-        }
-        *iter(coll) {
-            for (let i = 0; i < coll.size(); i++) {
-                yield coll.get(i);
-            }
-        }
-        *iterFilter(coll) {
-            for (let i = 0; i < coll.size(); i++) {
-                yield coll.get(i);
-            }
-        }
-        *iterSummaries(summaries) {
-            for (let i = 0; i < summaries.size(); i++) {
-                yield summaries.get(i);
-            }
-        }
-        constructor(settings) {
-            super(settings);
-            this._baseUri = null;
-            this._entitySet = null;
-            this._sortDescriptions = null;
-            this._groupDescriptions = null;
-            this._filterExpressions = null;
-            this._summaryDescriptions = null;
-            this._desiredPropeties = null;
-            this._schemaIncludedProperties = null;
-            this._enableJsonp = true;
-            this._isAggregationSupported = false;
-            this._groupInformation = null;
-            this._summaryInformation = null;
-            this._filterString = null;
-            this._selectedString = null;
-            this.doWork = this.doWork.bind(this);
-            this._baseUri = settings.baseUri;
-            this._entitySet = settings.entitySet;
-            this._sortDescriptions = settings.sortDescriptions;
-            this._groupDescriptions = settings.groupDescriptions;
-            if (this._groupDescriptions != null && this._groupDescriptions.size() > 0) {
-                this._sortDescriptions = new SortDescriptionCollection();
-                for (let sd of this.iter(settings.sortDescriptions)) {
-                    this._sortDescriptions.add(sd);
-                }
-                for (let i = 0; i < this._groupDescriptions.size(); i++) {
-                    this._sortDescriptions.insert(i, this._groupDescriptions.get(i));
-                }
-            }
-            this._filterExpressions = settings.filterExpressions;
-            this._desiredPropeties = settings.propertiesRequested;
-            if (settings.schemaIncludedProperties != null) {
-                this._schemaIncludedProperties = new Set();
-                for (let i = 0; i < settings.schemaIncludedProperties.length; i++) {
-                    this._schemaIncludedProperties.add(settings.schemaIncludedProperties[i]);
-                }
-            }
-            this._summaryDescriptions = settings.summaryDescriptions;
-            this._summaryScope = settings.summaryScope;
-            this._enableJsonp = settings.enableJsonp;
-            this._isAggregationSupported = settings.isAggregationSupported;
-            window.setTimeout(this.doWork, 100);
-        }
-        processCompletedTask(completedTask, currentDelay, pageIndex, taskDataHolder) {
-            let h = taskDataHolder;
-            let schema = null;
-            let result = null;
-            let schemaFetchCount = -1;
-            let task = completedTask.task;
-            try {
-                if (task.hasErrors) {
-                    this.retryIndex(pageIndex, currentDelay);
-                    return;
-                }
-                if (pageIndex == ODataVirtualDataSourceDataProviderWorker.schemaRequestIndex) {
-                    result = task.result;
-                    schemaFetchCount = (result['@odata.count']);
-                }
-                else {
-                    result = task.result;
-                }
-            }
-            catch (e) {
-                this.retryIndex(pageIndex, currentDelay);
-                return;
-            }
-            if (schemaFetchCount >= 0) {
-                this.actualCount = schemaFetchCount;
-            }
-            else {
-                this.actualCount = (result['@odata.count']);
-            }
-            schema = this.actualSchema;
-            if (schema == null) {
-                let requests = 0;
-                this.resolveSchema((s) => {
-                    // resolveSchema success callback
-                    this.actualSchema = s;
-                    if (this._isAggregationSupported && (this._groupDescriptions.size() !== 0 || this._summaryDescriptions.size() !== 0)) {
-                        if (this._groupDescriptions.size() > 0) {
-                            requests++;
-                            this.resolveGroupInformation((g) => {
-                                // group info success
-                                requests--;
-                                if (requests === 0) {
-                                    this.finishProcessingCompletedTask(task, pageIndex, s, result);
-                                }
-                            }, () => {
-                                // group info failure
-                                this.retryIndex(pageIndex, currentDelay);
-                                return;
-                            });
-                        }
-                        if (this._summaryDescriptions.size() > 0) {
-                            requests++;
-                            this.resolveSummaryInformation((g) => {
-                                // summary info success
-                                requests--;
-                                if (requests === 0) {
-                                    this.finishProcessingCompletedTask(task, pageIndex, s, result);
-                                }
-                            }, () => {
-                                // summary info failure
-                                this.retryIndex(pageIndex, currentDelay);
-                                return;
-                            });
-                        }
-                    }
-                    else {
-                        this.finishProcessingCompletedTask(task, pageIndex, s, result);
-                    }
-                }, () => {
-                    // resolveSchema failure callback
-                    this.retryIndex(pageIndex, currentDelay);
-                    return;
-                });
-                return;
-            }
-            this.finishProcessingCompletedTask(task, pageIndex, schema, result);
-        }
-        finishProcessingCompletedTask(task, pageIndex, schema, result) {
-            let executionContext;
-            let pageLoaded;
-            let groupInformation;
-            let summaryInformation;
-            this.actualSchema = schema;
-            executionContext = this.executionContext;
-            groupInformation = this._groupInformation;
-            summaryInformation = this._summaryInformation;
-            pageLoaded = this.pageLoaded;
-            let page = null;
-            if (result != null) {
-                page = new ODataDataSourcePage(result, schema, groupInformation, summaryInformation, pageIndex);
-                if (!this.isLastPage(pageIndex) && page.count() > 0 && !this.populatedActualPageSize) {
-                    this.populatedActualPageSize = true;
-                    this.actualPageSize = page.count();
-                }
-            }
-            else {
-                page = new ODataDataSourcePage(null, schema, groupInformation, summaryInformation, pageIndex);
-            }
-            if (this.pageLoaded != null) {
-                if (this.executionContext != null) {
-                    if (executionContext == null || pageLoaded == null) {
-                        this.shutdown();
-                        return;
-                    }
-                    executionContext.execute(() => pageLoaded(page, this.actualCount, this.actualPageSize));
-                }
-                else {
-                    if (pageLoaded == null) {
-                        this.shutdown();
-                        return;
-                    }
-                    pageLoaded(page, this.actualCount, this.actualPageSize);
-                }
-            }
-        }
-        resolveGroupInformation(finishAction, failureAction) {
-            if (this._groupInformation != null) {
-                finishAction(this._groupInformation);
-                return;
-            }
-            let orderBy = "";
-            let groupBy = "";
-            let filter = null;
-            let summary = "";
-            if (this._groupDescriptions == null || this._groupDescriptions.size() == 0) {
-                finishAction(null);
-                return;
-            }
-            filter = this._filterString;
-            this.updateFilterString();
-            if (this._groupDescriptions != null) {
-                let first1 = true;
-                for (let group of this.iter(this._groupDescriptions)) {
-                    if (first1) {
-                        first1 = false;
-                    }
-                    else {
-                        orderBy += ", ";
-                        groupBy += ", ";
-                    }
-                    groupBy += group.propertyName;
-                    if (group.direction === ListSortDirection.Descending) {
-                        orderBy += group.propertyName + " desc";
-                    }
-                    else {
-                        orderBy += group.propertyName + " asc";
-                    }
-                }
-            }
-            if (this._summaryScope === DataSourceSummaryScope.Both || this._summaryScope === DataSourceSummaryScope.Groups) {
-                let summaryParameters = this.getSummaryQueryParameters(true);
-                if (!stringIsNullOrEmpty(summaryParameters)) {
-                    summary = ", " + summaryParameters;
-                }
-            }
-            let commandText = this._entitySet + "?$orderby=" + orderBy + "&$apply=";
-            if (!stringIsNullOrEmpty(filter)) {
-                commandText += "filter(" + filter + ")/";
-            }
-            commandText += "groupby((" + groupBy + "), aggregate($count as $__count" + summary + "))";
-            try {
-                let groupInformation = [];
-                let success_ = (data, response) => this.groupSuccess(data, response, finishAction, failureAction, groupInformation);
-                let failure_ = (err) => this.groupError(err, finishAction, failureAction, groupInformation);
-                let run_ = null;
-                var headers = { 'Content-Type': 'application/json', Accept: 'application/json' };
-                var request = {
-                    requestUri: this._baseUri + "/" + commandText,
-                    enableJsonpCallback: this._enableJsonp,
-                    method: 'GET',
-                    headers: headers,
-                    data: null
-                };
-                run_ = function () {
-                    odatajs.oData.request(request, success_, failure_);
-                };
-                run_();
-            }
-            catch (e) {
-                failureAction();
-            }
-        }
-        groupError(err, finishAction, failureAction, groupInformation) {
-            this._groupInformation = null;
-        }
-        groupSuccess(data, response, finishAction, failureAction, groupInformation) {
-            let groupNames = [];
-            for (let group of this.iter(this._groupDescriptions)) {
-                groupNames.push(group.propertyName);
-            }
-            let groupNamesArray = groupNames;
-            if (data && data.value && data.value.length > 0) {
-                let currentIndex = 0;
-                for (let i = 0; i < data.value.length; i++) {
-                    this.addGroup(groupInformation, groupNames, groupNames, currentIndex, data.value[i]);
-                }
-            }
-            this._groupInformation = groupInformation;
-            finishAction(this._groupInformation);
-        }
-        addGroup(groupInformation, groupNames, groupNamesArray, currentIndex, group) {
-            let groupValues = [];
-            for (let name of groupNames) {
-                if (group[name]) {
-                    groupValues.push(group[name]);
-                }
-            }
-            let groupCount = 0;
-            if (group["$__count"]) {
-                groupCount = Convert.toInt321(group["$__count"]);
-            }
-            let summaryResults = null;
-            if (this._summaryScope == DataSourceSummaryScope.Both || this._summaryScope == DataSourceSummaryScope.Groups) {
-                summaryResults = this.createSummaryResults(group);
-            }
-            let groupInfo = new DefaultSectionInformation(currentIndex, currentIndex + (groupCount - 1), groupNamesArray, groupValues, summaryResults);
-            groupInformation.push(groupInfo);
-        }
-        resolveSummaryInformation(finishAction, failureAction) {
-            if (this._summaryInformation != null) {
-                finishAction(this._summaryInformation);
-                return;
-            }
-            let filter = null;
-            let summary = null;
-            if (this._summaryDescriptions == null ||
-                this._summaryDescriptions.size() == 0 ||
-                this._summaryScope == DataSourceSummaryScope.Groups ||
-                this._summaryScope == DataSourceSummaryScope.None) {
-                finishAction(null);
-                return;
-            }
-            filter = this._filterString;
-            this.updateFilterString();
-            summary = this.getSummaryQueryParameters(false);
-            let commandText = this._entitySet + "?$apply=";
-            if (!stringIsNullOrEmpty(filter)) {
-                commandText += "filter(" + filter + ")/";
-            }
-            commandText += "aggregate(" + summary + ")";
-            try {
-                let summaryInformation = [];
-                let success_ = (data, response) => this.summarySuccess(data, response, finishAction, failureAction, summaryInformation);
-                let failure_ = (err) => this.summaryError(err, finishAction, failureAction, summaryInformation);
-                let run_ = null;
-                var headers = { 'Content-Type': 'application/json', Accept: 'application/json' };
-                var request = {
-                    requestUri: this._baseUri + "/" + commandText,
-                    enableJsonpCallback: this._enableJsonp,
-                    method: 'GET',
-                    headers: headers,
-                    data: null
-                };
-                run_ = function () {
-                    odatajs.oData.request(request, success_, failure_);
-                };
-                run_();
-            }
-            catch (e) {
-                failureAction();
-            }
-        }
-        summarySuccess(data, response, finishAction, failureAction, summaryInformation) {
-            if (data && data.value && data.value.length > 0) {
-                summaryInformation = this.createSummaryResults(data.value[0]);
-            }
-            this._summaryInformation = summaryInformation;
-            finishAction(this._summaryInformation);
-        }
-        summaryError(err, finishAction, failureAction, summaryInformation) {
-            this._summaryInformation = null;
-        }
-        getSummaryQueryParameters(ignoreCount) {
-            let result = "";
-            if (this._summaryDescriptions != null) {
-                let first = true;
-                let countExists = false;
-                for (let summary of this.iterSummaries(this._summaryDescriptions)) {
-                    if (summary.operand == DataSourceSummaryOperand.Count && (ignoreCount || countExists)) {
-                        continue;
-                    }
-                    if (!first) {
-                        result += ", ";
-                    }
-                    switch (summary.operand) {
-                        case DataSourceSummaryOperand.Average:
-                            result += summary.propertyName + " with average as " + summary.propertyName + "Average";
-                            break;
-                        case DataSourceSummaryOperand.Min:
-                            result += summary.propertyName + " with min as " + summary.propertyName + "Min";
-                            break;
-                        case DataSourceSummaryOperand.Max:
-                            result += summary.propertyName + " with max as " + summary.propertyName + "Max";
-                            break;
-                        case DataSourceSummaryOperand.Sum:
-                            result += summary.propertyName + " with sum as " + summary.propertyName + "Sum";
-                            break;
-                        case DataSourceSummaryOperand.Count:
-                            result += "$count as $__count";
-                            countExists = true;
-                            break;
-                    }
-                    first = false;
-                }
-            }
-            return result;
-        }
-        createSummaryResults(data) {
-            let summaryResults = [];
-            for (let summary of this.iterSummaries(this._summaryDescriptions)) {
-                let summaryName = summary.propertyName;
-                switch (summary.operand) {
-                    case DataSourceSummaryOperand.Average:
-                        summaryName += "Average";
-                        break;
-                    case DataSourceSummaryOperand.Min:
-                        summaryName += "Min";
-                        break;
-                    case DataSourceSummaryOperand.Max:
-                        summaryName += "Max";
-                        break;
-                    case DataSourceSummaryOperand.Sum:
-                        summaryName += "Sum";
-                        break;
-                    case DataSourceSummaryOperand.Count:
-                        summaryName = "$__count";
-                        break;
-                }
-                let summaryValue = null;
-                if (data && data[summaryName]) {
-                    summaryValue = data[summaryName];
-                }
-                let summaryResult = new DefaultSummaryResult(summary.propertyName, summary.operand, summaryValue);
-                summaryResults.push(summaryResult);
-            }
-            return summaryResults;
-        }
-        resolveSchema(finishAction, failureAction) {
-            let success_ = (res) => {
-                let sp = new ODataSchemaProvider(res);
-                let schema = sp.getODataDataSourceSchema(this._entitySet);
-                if (this._schemaIncludedProperties != null) {
-                    let propertyNames = [];
-                    let propertyTypes = [];
-                    for (let i = 0; i < schema.propertyNames.length; i++) {
-                        if (!this._schemaIncludedProperties.has(schema.propertyNames[i])) {
-                            continue;
-                        }
-                        propertyNames.push(schema.propertyNames[i]);
-                        propertyTypes.push(schema.propertyTypes[i]);
-                    }
-                    schema = new ODataDataSourceSchema(propertyNames, propertyTypes, schema.primaryKey);
-                }
-                finishAction(schema);
-            };
-            let failure_ = () => failureAction();
-            let baseUri_ = this._baseUri;
-            var request = new XMLHttpRequest();
-            request.onreadystatechange = function () {
-                if (request.readyState === 4) {
-                    if (request.status === 200) {
-                        success_(request.responseText);
-                    }
-                    else {
-                        failure_();
-                    }
-                }
-            };
-            request.open('Get', baseUri_ + '/$metadata');
-            request.send();
-            ;
-        }
-        makeTaskForRequest(request, retryDelay) {
-            let actualPageSize = 0;
-            let sortDescriptions = null;
-            actualPageSize = this.actualPageSize;
-            sortDescriptions = this.sortDescriptions;
-            let requestUrl = this._baseUri;
-            requestUrl += "/" + this._entitySet;
-            let queryStarted = false;
-            this.updateFilterString();
-            if (this._filterString != null) {
-                if (!queryStarted) {
-                    queryStarted = true;
-                    requestUrl += "?";
-                }
-                else {
-                    requestUrl += "&";
-                }
-                requestUrl += "$filter=" + this._filterString;
-            }
-            if (this.sortDescriptions != null) {
-                let sortString = null;
-                for (let sort of this.iter(this.sortDescriptions)) {
-                    if (sortString == null) {
-                        sortString = "";
-                    }
-                    else {
-                        sortString += ", ";
-                    }
-                    if (sort.direction == ListSortDirection.Descending) {
-                        sortString += sort.propertyName + " desc";
-                    }
-                    else {
-                        sortString += sort.propertyName;
-                    }
-                }
-                if (sortString != null) {
-                    if (!queryStarted) {
-                        queryStarted = true;
-                        requestUrl += "?";
-                    }
-                    else {
-                        requestUrl += "&";
-                    }
-                    requestUrl += "$orderby=" + sortString;
-                }
-            }
-            if (this.desiredProperties != null && this.desiredProperties.length > 0) {
-                let selectString = "";
-                let first = true;
-                let $t = this.desiredProperties;
-                for (let i = 0; i < $t.length; i++) {
-                    let select = $t[i];
-                    if (first) {
-                        first = false;
-                    }
-                    else {
-                        selectString += ", ";
-                    }
-                    selectString += select;
-                }
-                if (!queryStarted) {
-                    queryStarted = true;
-                    requestUrl += "?";
-                }
-                else {
-                    requestUrl += "&";
-                }
-                requestUrl += "$select=" + selectString;
-            }
-            let task = new AsyncVirtualDataTask();
-            if (request.index == ODataVirtualDataSourceDataProviderWorker.schemaRequestIndex) {
-                this.executeRequest(requestUrl, queryStarted, 0, actualPageSize, task);
-            }
-            else {
-                this.executeRequest(requestUrl, queryStarted, request.index * actualPageSize, actualPageSize, task);
-            }
-            request.taskHolder = new AsyncDataSourcePageTaskHolder();
-            request.taskHolder.task = task;
-            this.tasks.add(request);
-        }
-        updateFilterString() {
-            if (this.filterExpressions != null && this.filterExpressions.size() > 0 && this._filterString == null) {
-                let sb = "";
-                let first = true;
-                for (let expr of this.iterFilter(this.filterExpressions)) {
-                    if (first) {
-                        first = false;
-                    }
-                    else {
-                        sb += " AND ";
-                    }
-                    let visitor = new ODataDataSourceFilterExpressionVisitor(0);
-                    visitor.visit(expr);
-                    let txt = visitor.toString();
-                    if (this.filterExpressions.size() > 1) {
-                        txt = "(" + txt + ")";
-                    }
-                    sb += (txt);
-                }
-                this._filterString = sb;
-            }
-        }
-        executeRequest(requestUrl, queryStarted, skip, top, task) {
-            if (!queryStarted) {
-                queryStarted = true;
-                requestUrl += "?";
-            }
-            else {
-                requestUrl += "&";
-            }
-            requestUrl += "$skip=" + skip + "&$top=" + top + "&$count=true";
-            let requestUrl_ = requestUrl;
-            let self_ = this;
-            let success_ = (data, response) => this.success(task, data, response);
-            let failure_ = (err) => this.error(task, err);
-            let run_ = null;
-            var headers = { 'Content-Type': 'application/json', Accept: 'application/json' };
-            var request = {
-                requestUri: requestUrl_,
-                enableJsonpCallback: this._enableJsonp,
-                method: 'GET',
-                headers: headers,
-                data: null
-            };
-            run_ = function () {
-                odatajs.oData.request(request, success_, failure_);
-            };
-            task.run = run_;
-        }
-        success(t, data, response) {
-            t.result = data;
-            t.isCompleted = true;
-        }
-        error(t, result) {
-            t.isCompleted = true;
-            t.hasErrors = true;
-        }
-        createBatchRequest(changes) {
-            const requests = [];
-            for (let i = 0; i < changes.length; i++) {
-                let c = changes[i];
-                const headers = { "Content-Type": "application/json", "odata-version": "4.0" };
-                if (c.transactionType === TransactionType.Add) {
-                    requests.push({
-                        method: "POST",
-                        id: `r${i}`,
-                        atomicityGroup: "g1",
-                        url: `${this._baseUri}/${this._entitySet}`,
-                        headers: headers,
-                        body: c.value,
-                    });
-                }
-                else if (c.transactionType === TransactionType.Update) {
-                    if (c.version) {
-                        headers["If-Match"] = c.version;
-                    }
-                    requests.push({
-                        method: "PATCH",
-                        id: `r${i}`,
-                        atomicityGroup: "g1",
-                        url: `${this._baseUri}/${this.getRequestUriWithKey(c.id)}`,
-                        headers: headers,
-                        body: c.value,
-                    });
-                }
-                else if (c.transactionType === TransactionType.Delete) {
-                    if (c.version) {
-                        headers["If-Match"] = c.version;
-                    }
-                    requests.push({
-                        method: "DELETE",
-                        id: `r${i}`,
-                        atomicityGroup: "g1",
-                        url: `${this._baseUri}/${this.getRequestUriWithKey(c.id)}`,
-                        headers: headers,
-                    });
-                }
-            }
-            let request = {
-                requestUri: `${this._baseUri}/$batch`,
-                method: "POST",
-                headers: { "Content-Type": "application/json" },
-                body: JSON.stringify({ requests: requests })
-            };
-            let self = this;
-            odatajs.oData.request(request, function (data) {
-                if (data && data.responses) {
-                    if (data.responses.length > 0) {
-                        let success = true;
-                        let messages = [];
-                        for (let i = 0; i < data.responses.length; i++) {
-                            if (data.responses[i].status !== 200 &&
-                                data.responses[i].status !== 204) {
-                                success = false;
-                                let failedRequest = requests.filter(r => r.id == data.responses[i].id)[0];
-                                if (failedRequest) {
-                                    let msg = `${failedRequest.method} request failed with code ${data.responses[i].status}`;
-                                    messages.push(msg);
-                                    console.error(msg);
-                                }
-                                break;
-                            }
-                        }
-                        if (success) {
-                            self.batchCompleted(true, true, null);
-                        }
-                        else {
-                            self.batchCompleted(false, true, messages);
-                        }
-                    }
-                    else {
-                        self.batchCompleted(false, true, null);
-                    }
-                }
-            }, function (error) {
-                const messages = [];
-                if (error && error.message) {
-                    messages.push(error.message);
-                }
-                self.batchCompleted(false, true, messages);
-            });
-        }
-        getRequestUriWithKey(key) {
-            let result = "";
-            const keys = Object.keys(key);
-            for (let i = 0; i < keys.length; i++) {
-                if (i > 0) {
-                    result += ",";
-                }
-                result += `${keys[i]}=${key[keys[i]]}`;
-            }
-            return `${this._entitySet}(${result})`;
-        }
-    }
-    ODataVirtualDataSourceDataProviderWorker.schemaRequestIndex = -1;
-    return ODataVirtualDataSourceDataProviderWorker;
-})();
-export { ODataVirtualDataSourceDataProviderWorker };