@easyquery/core 7.2.5-beta01 → 7.2.5-rc01

package/dist/lib/main/context.js

@@ -1,1492 +0,0 @@
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-import { EasyDataTable, EventEmitter, utils as dataUtils } from '@easydata/core';
-import { i18n } from '@easydata/core';
-import { equtils } from '../utils/utils';
-import { EqServiceProvider } from '../common/eq_services';
-import { ExprTag } from '../types/expr_tag';
-import { QueryChangePart } from '../query/query_events';
-import { WidgetGroup } from '../types/widget_group';
-import { EmptyChunk } from '../export/exporter';
-import { EqServerExporter } from '../eqs/eqs_exporter';
-import { EasyQueryDataLoader } from '../data/eq_data_loader';
-import { EqActionResult } from './action';
-import { EqAction } from './eq_actions';
-/**
- * Encapsulates all information about EasyQuery components on some webpage
- * and provides some basic operation over those components
- * Each context includes the following main components:
- *  - one data model,
- *  - one query,
- *  - one result set
- *  - several UI widgets.
- */
-var EqContext = /** @class */ (function () {
-    function EqContext() {
-        var _this = this;
-        this.options = {
-            syncSortOrderWithColumnsOrder: true,
-            attributeFormat: '{entity} {attr}',
-            columnTitleFormat: null //means it will be the same as attributeFormat
-        };
-        this.servicesInitialized = false;
-        this.internalListCache = {};
-        this.loadModelOnStart = true;
-        this.loadQueryOnStart = false;
-        this.useStoredQueryOnFetch = false;
-        this.debugMode = false;
-        this._backendInfo = {
-            type: 'EQN-ANC',
-            subType: 'asp-net-core-razor'
-        };
-        //----------- endpoint processing functions --------------
-        this.endpointVarsRegex = /\{.*?\}/g;
-        this.elasticPaging = false;
-        this._predefinedListRequestHandlers = {
-            '_DSDE': function (params, onResult) {
-                var data = _this.getModel().getAllDateMacros()
-                    .map(function (macroId) {
-                    return { id: '${{' + macroId + '}}', text: i18n.getText(macroId) };
-                });
-                onResult(data);
-                return true;
-            },
-            '_DSTE': function (params, onResult) {
-                var data = _this.getModel().getAllTimeMacros()
-                    .map(function (macroId) {
-                    return { id: '${{' + macroId + '}}', text: i18n.getText(macroId) };
-                });
-                onResult(data);
-                return true;
-            }
-        };
-        this._listRequestHandler = function (options, onResult) {
-            if (options == null || !options.listName)
-                return;
-            var query = _this.getQuery();
-            var params = dataUtils.assign({ listName: options.listName }, options.editorParams);
-            var reqParams = {};
-            var attrPattern = /@{{(.+?)}}/;
-            for (var prop in params) {
-                if (!params[prop])
-                    continue;
-                var match = params[prop].match(attrPattern);
-                if (match) {
-                    var paramValue = query.getOneValueForAttr(match[1]);
-                    if (!paramValue) {
-                        paramValue = '';
-                    }
-                    reqParams[prop] = params[prop].replace(attrPattern, paramValue);
-                }
-            }
-            var requestParams = {
-                listName: reqParams.listName,
-                editorId: options.editorId,
-                queryParams: reqParams
-            };
-            var list = _this.getListFromCache(options);
-            if (list && list.length > 0) {
-                onResult(list);
-                return;
-            }
-            var processed = false;
-            var predefinedHandler = _this._predefinedListRequestHandlers[options.editorId];
-            if (predefinedHandler) {
-                processed = predefinedHandler(options, onResult);
-            }
-            if (!processed && _this.clientListRequestHandler) {
-                processed = _this.clientListRequestHandler(options, onResult);
-            }
-            if (!processed) {
-                _this.loadValueList({
-                    params: requestParams,
-                    success: function (data) {
-                        if (data) {
-                            _this.addListToCache(options, data);
-                        }
-                        onResult(data);
-                    },
-                    error: function (message) {
-                        onResult(null);
-                    }
-                });
-            }
-        };
-        this.baseEndpoint = 'api/easyquery';
-        this.eqServices = new EqServiceProvider(this);
-        this.widgets = new Array();
-        this.eventEmitter = new EventEmitter(this);
-        this.exporters = new Map();
-        this.endpoints = new Map();
-        this.dataLoader = new EasyQueryDataLoader(this);
-        this.resultTable = new EasyDataTable({
-            loader: this.dataLoader,
-            onUpdate: this.onResultTableUpdate.bind(this)
-        });
-        this.resultTable.id = 'ResultTable';
-        this.errorHandlerId = this.addEventListener('error', function (context, status) {
-            status.result = EqActionResult.Error;
-            var msgTitle = status.action ? status.action + ' error' : 'Error';
-            var msgText = status.text ? status.text : '';
-            if (status.sourceError && status.sourceError.message !== msgText) {
-                msgText += '\n' + status.sourceError;
-            }
-            console.error(msgTitle + ': ' + msgText);
-        });
-    }
-    EqContext.prototype.getServices = function () {
-        return this.eqServices;
-    };
-    EqContext.prototype.registerExporter = function (format, resolver) {
-        this.exporters.set(format, resolver);
-    };
-    EqContext.prototype.registerServerExporter = function (format, responseType) {
-        this.registerExporter(format, function (context) {
-            var exporter = new EqServerExporter(context);
-            exporter.setFormat(format, responseType);
-            return exporter;
-        });
-    };
-    EqContext.prototype.getExporter = function (format) {
-        var resolver = this.exporters.get(format);
-        if (resolver) {
-            return resolver(this);
-        }
-        return null;
-    };
-    EqContext.prototype.getExportFormats = function () {
-        return Array.from(this.exporters.keys());
-    };
-    EqContext.prototype.addDefaultExporters = function () {
-        this.registerServerExporter('csv', 'arraybuffer');
-        this.registerServerExporter('excel-html', 'arraybuffer');
-    };
-    EqContext.prototype.resolveEndpoint = function (endpointKey, options) {
-        options = options || {};
-        var result = this.endpoints.get(endpointKey);
-        if (!result) {
-            throw endpointKey + ' endpoint is not defined';
-        }
-        var matches = result.match(this.endpointVarsRegex);
-        if (matches) {
-            for (var _i = 0, matches_1 = matches; _i < matches_1.length; _i++) {
-                var match = matches_1[_i];
-                var opt = match.substring(1, match.length - 1);
-                var optVal = options[opt];
-                if (!optVal) {
-                    if (opt == 'modelId') {
-                        optVal = this.getModel().getId();
-                    }
-                    else if (opt == 'queryId') {
-                        optVal = this.getQuery().getId();
-                    }
-                    else {
-                        throw "Parameter [".concat(opt, "] is not defined");
-                    }
-                }
-                result = result.replace(match, optVal);
-            }
-        }
-        return result;
-    };
-    EqContext.prototype.setEndpoint = function (key, value) {
-        this.endpoints.set(key, value);
-    };
-    EqContext.prototype.setEnpointIfNotExist = function (key, value) {
-        if (!this.endpoints.has(key))
-            this.endpoints.set(key, value);
-    };
-    EqContext.prototype.setDefaultEndpoints = function (endpointBase) {
-        this.setEnpointIfNotExist('GetModel', equtils.combinePath(endpointBase, 'models/{modelId}'));
-        this.setEnpointIfNotExist('GetQuery', equtils.combinePath(endpointBase, 'models/{modelId}/queries/{queryId}'));
-        this.setEnpointIfNotExist('SaveQuery', equtils.combinePath(endpointBase, 'models/{modelId}/queries/{queryId}'));
-        this.setEnpointIfNotExist('SyncQuery', equtils.combinePath(endpointBase, 'models/{modelId}/queries/{queryId}/sync'));
-        this.setEnpointIfNotExist('NewQuery', equtils.combinePath(endpointBase, 'models/{modelId}/queries'));
-        this.setEnpointIfNotExist('RemoveQuery', equtils.combinePath(endpointBase, 'models/{modelId}/queries/{queryId}'));
-        this.setEnpointIfNotExist('GetQueryList', equtils.combinePath(endpointBase, 'models/{modelId}/queries'));
-        this.setEnpointIfNotExist('FetchData', equtils.combinePath(endpointBase, 'models/{modelId}/fetch'));
-        this.setEnpointIfNotExist('GetValueList', equtils.combinePath(endpointBase, 'models/{modelId}/valuelists/{listId}'));
-        this.setEnpointIfNotExist('ExportResult', equtils.combinePath(endpointBase, 'models/{modelId}/export/{format}'));
-        this.setEnpointIfNotExist('GetQueryFile', equtils.combinePath(endpointBase, 'models/{modelId}/getqueryfile/{format}'));
-        this.setEnpointIfNotExist('UploadQueryFile', equtils.combinePath(endpointBase, 'models/{modelId}/uploadqueryfile'));
-    };
-    EqContext.prototype.initStart = function () {
-        this.servicesInitialized = true;
-    };
-    /**
-     * Initializes the context
-     * @param options
-     */
-    EqContext.prototype.init = function (options) {
-        var _this = this;
-        if (!this.servicesInitialized)
-            this.initStart();
-        options = options || {};
-        this.setOptions(options);
-        if (typeof (options.debugMode) !== 'undefined') {
-            this.debugMode = options.debugMode;
-        }
-        if (typeof (options.chunkSize) !== 'undefined') {
-            this.resultTable.chunkSize = options.chunkSize;
-        }
-        if (typeof (options.elasticPaging) !== 'undefined') {
-            this.elasticPaging = options.elasticPaging;
-        }
-        if (options.listCache) {
-            this.setExternalListCache(options.listCache);
-        }
-        if (options.locale) {
-            i18n.setCurrentLocale(options.locale);
-        }
-        if (options.localeSettings) {
-            i18n.updateLocaleSettings(options.localeSettings);
-        }
-        if (options.endpoint) {
-            this.baseEndpoint = options.endpoint;
-            console.warn('The `endpoint` option is deprecated.\n'
-                + 'Please use `context.useEndpoint(endpointURL)` function instead.');
-        }
-        this.setDefaultEndpoints(this.baseEndpoint);
-        if (options.modelStorageResolver) {
-            var eqServices = this.getServices();
-            eqServices.registerModelStorageResolver(options.modelStorageResolver);
-        }
-        this.loadQueryOnStart = false;
-        if (options.loadQueryOnStart) {
-            this.loadQueryOnStart = options.loadQueryOnStart;
-        }
-        this.loadModelOnStart = true;
-        if (typeof options.loadModelOnStart !== 'undefined') {
-            this.loadModelOnStart = options.loadModelOnStart;
-        }
-        if (options.handlers) {
-            if (options.handlers.onInit) {
-                this.addEventListener('ready', options.handlers.onInit);
-            }
-            if (options.handlers.afterLoadModel) {
-                this.addEventListener('loadModel', options.handlers.afterLoadModel);
-            }
-            if (options.handlers.afterLoadQuery) {
-                this.addEventListener('loadQuery', options.handlers.afterLoadQuery);
-            }
-            if (options.handlers.afterSyncQuery) {
-                this.addEventListener('syncQuery', options.handlers.afterSyncQuery);
-            }
-            if (options.handlers.afterFetchData) {
-                this.addEventListener('fetchData', options.handlers.afterFetchData);
-            }
-            if (options.handlers.afterExportResult) {
-                this.addEventListener('exportResult', options.handlers.afterExportResult);
-            }
-            if (options.handlers.onProcessStart) {
-                this.addEventListener('processStart', options.handlers.onProcessStart);
-            }
-            if (options.handlers.onProcessEnd) {
-                this.addEventListener('processEnd', options.handlers.onProcessEnd);
-            }
-            if (options.handlers.onError) {
-                this.removeEventListener('error', this.errorHandlerId);
-                this.addEventListener('error', options.handlers.onError);
-            }
-            if (options.handlers.onListRequest) {
-                this.clientListRequestHandler = options.handlers.onListRequest;
-            }
-            if (options.handlers.beforeLoadModel) {
-                this.beforeLoadModel = options.handlers.beforeLoadModel;
-            }
-            if (options.handlers.beforeLoadQuery) {
-                this.beforeLoadQuery = options.handlers.beforeLoadQuery;
-            }
-            if (options.handlers.beforeSyncQuery) {
-                this.beforeSyncQuery = options.handlers.beforeSyncQuery;
-            }
-            if (options.handlers.beforeFetchData) {
-                this.beforeFetchData = options.handlers.beforeFetchData;
-            }
-            if (options.handlers.beforeExportResult) {
-                this.beforeExportResult = options.handlers.beforeExportResult;
-            }
-        }
-        this.initialQuery = options.initialQuery;
-        this.defaultQueryId = options.defaultQueryId || '';
-        this.defaultModelId = options.defaultModelId || '__default';
-        var modelLoader = this.eqServices.getModelLoader();
-        modelLoader.init(options);
-        var queryStorage = this.eqServices.getQueryStorage();
-        queryStorage.init(options);
-        if (options.useDefaultExporters !== false) {
-            this.addDefaultExporters();
-        }
-        if (options.serverExporters) {
-            this.exporters.clear();
-            for (var _i = 0, _a = options.serverExporters; _i < _a.length; _i++) {
-                var format = _a[_i];
-                this.registerServerExporter(format, "arraybuffer");
-            }
-        }
-        var query = this.getQuery();
-        if (options.defaultQueryId) {
-            query.setId(options.defaultQueryId);
-        }
-        //init widgets
-        this.widgets.forEach(function (widget) {
-            var widgetOptions = {};
-            if (options.widgets && options.widgets[widget.getWidgetType()]) {
-                widgetOptions = options.widgets[widget.getWidgetType()];
-            }
-            widget.init(_this, widgetOptions);
-        });
-        if (this.loadModelOnStart) {
-            this.loadDefaultModel();
-        }
-        else {
-            this.fireEvent('ready');
-        }
-    };
-    EqContext.prototype.setOptions = function (options) {
-        dataUtils.assignDeep(this.options, options);
-    };
-    Object.defineProperty(EqContext.prototype, "backendInfo", {
-        get: function () {
-            return this._backendInfo;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    /**
-     * Sets endpoint for all EasyQuery actions. Should be called before `init` and
-     * `useEnterprise` methods
-     * @param endpoint
-     * @example
-     * ```
-     * view.getContext()
-     *     .useEndpoint('/api/easyquery')
-     *     .useEnterprise(function () {
-     *          view.init();
-     *     });
-     * ```
-     */
-    EqContext.prototype.useEndpoint = function (endpoint) {
-        this.baseEndpoint = endpoint;
-        return this;
-    };
-    /**
-     * Allows to specify the type of backend service.
-     *
-     * @param backendInfo - the structure that contains information about the app used on the backend
-     * Possible values for `ptag` property: 'EQN-ANC' - ASP.NET Core or 'EQN-ASP' - for ASP.NET 4 backend
-     */
-    EqContext.prototype.useBackend = function (backendInfo) {
-        if (backendInfo.type) {
-            this._backendInfo.type = backendInfo.type;
-        }
-        if (backendInfo.subType) {
-            this._backendInfo.subType = backendInfo.subType;
-        }
-        else {
-            switch (this._backendInfo.type) {
-                case 'EQN-ANC':
-                    this._backendInfo.subType = 'asp-net-core-razor';
-                    break;
-                case 'EQN-ASP':
-                    this._backendInfo.subType = 'asp-net-4-mvc';
-                    break;
-                default:
-                    this._backendInfo.subType = 'other';
-                    break;
-            }
-        }
-        return this;
-    };
-    /**
-     * Add a new widget to the context.
-     * After that the widget will start to receive messages from other context components.
-     * @param widget
-     */
-    EqContext.prototype.addWidget = function (widget) {
-        this.widgets.push(widget);
-    };
-    /**
-     * Returns all widgets with current type.
-     * @param widgetType The widget type
-     */
-    EqContext.prototype.getAllWidgetsByType = function (widgetType) {
-        return this.widgets
-            .filter(function (widget) { return widget.getWidgetType() === widgetType; });
-    };
-    /**
-     * Returns first registerd widget with current type
-     * @param widgetType The widget type
-     */
-    EqContext.prototype.getWidgetByType = function (widgetType) {
-        var widgets = this.getAllWidgetsByType(widgetType);
-        return widgets.length > 0 ? widgets[0] : null;
-    };
-    /**
-     * This method is called automatically when some change was made either in context's data model or query
-     * @param groups
-     */
-    EqContext.prototype.refreshWidgets = function (groups) {
-        if (groups === void 0) { groups = WidgetGroup.All; }
-        this.widgets.forEach(function (widget) {
-            if (widget.belongsToGroup(groups)) {
-                widget.refresh();
-            }
-        });
-    };
-    /**
-     * Register a new handler for 'query changed' event
-     * @param callback
-     */
-    EqContext.prototype.addQueryChangedCallback = function (callback) {
-        this.getQuery().addChangedCallback(callback);
-    };
-    /**
-     * Removes the function from the list of registerd handlers for 'query changed' event
-     * @param callback
-     */
-    EqContext.prototype.removeQueryChangedCallback = function (callback) {
-        this.getQuery().removeChangedCallback(callback);
-    };
-    /**
-     * Creates a new query object using the current instance of EqServices
-     */
-    EqContext.prototype.createQuery = function () {
-        return this.eqServices.createQuery();
-    };
-    /**
-     * Gets the current query
-     */
-    EqContext.prototype.getQuery = function () {
-        if (!this.query) {
-            if (!this.servicesInitialized) {
-                throw new Error("Can't create query until the context is initialized");
-            }
-            this.query = this.createQuery();
-        }
-        return this.query;
-    };
-    /**
-     * Gets the current data model
-     */
-    EqContext.prototype.getModel = function () {
-        if (!this.dataModel) {
-            this.dataModel = this.eqServices.createDataModel();
-        }
-        return this.dataModel;
-    };
-    /**
-     * Sets the content of the current data model
-    */
-    EqContext.prototype.loadModelFromData = function (modelPlainData) {
-        this.getQuery().loadModelData(modelPlainData);
-        this.dataModel = this.getQuery().getModel();
-    };
-    /**
-     * Sets the ID of the default model
-     * @param modelId
-     */
-    EqContext.prototype.setDefaultModelId = function (modelId) {
-        this.defaultModelId = modelId;
-    };
-    /**
-     * Notifies context components about starting of some long process (e.g. model loading)
-     * This method raises onProcessStart event in the context and all its widgets
-     * @param message
-     * @param groups
-     */
-    EqContext.prototype.startProcess = function (message, groups) {
-        this.eventEmitter.fire('processStart', message);
-        this.widgets.forEach(function (widget) {
-            if (widget.belongsToGroup(groups)) {
-                widget.onProcessStart();
-            }
-        });
-    };
-    /**
-     * Notifies all context components about the finishing of some long process
-     * @param status
-     * @param groups
-     */
-    EqContext.prototype.endProcess = function (status, groups) {
-        this.eventEmitter.fire('processEnd', status);
-        if (status.result === EqActionResult.Error) {
-            this.throwError(status);
-        }
-        this.widgets.forEach(function (widget) {
-            if (widget.belongsToGroup(groups)) {
-                widget.onProcessEnd();
-            }
-        });
-    };
-    /**
-     * Throws the error passed in the function parameter.
-     * If onError event handler is defined - we call that method.
-     * Otherwise - just place the error message to the browser console.
-     * @param error
-     */
-    EqContext.prototype.throwError = function (status) {
-        status.result = EqActionResult.Error;
-        this.eventEmitter.fire('error', status);
-    };
-    /**
-     * If `defaultModelId` property is define - this method calls `loadModel` function in the broker
-     * to load the model with such ID.
-     */
-    EqContext.prototype.loadDefaultModel = function () {
-        var _this = this;
-        this.loadModel({
-            modelId: this.defaultModelId,
-            silent: true,
-            success: function () {
-                _this.refreshWidgets(WidgetGroup.Model);
-                var query = _this.getQuery();
-                _this.fireEvent('initialModelLoad');
-                if (_this.initialQuery) {
-                    query.loadFromData(_this.initialQuery, {
-                        changeStatus: false
-                    });
-                }
-                if (_this.loadQueryOnStart) {
-                    _this.loadQuery({
-                        queryId: _this.defaultQueryId,
-                        modelId: _this.defaultModelId,
-                        success: function () {
-                            _this.refreshWidgets(WidgetGroup.Query);
-                            //if we load query on start - then we should call 'ready' event only after its successful loading
-                            _this.fireEvent('ready');
-                        }
-                    });
-                }
-                else {
-                    _this.refreshWidgets(WidgetGroup.Query);
-                    _this.fireEvent('ready');
-                }
-            }
-        });
-    };
-    /**
-     * Clears the content of the current query
-     */
-    EqContext.prototype.clearQuery = function () {
-        var query = this.getQuery();
-        query.clear();
-        query.fireChangedEvent({
-            part: QueryChangePart.All
-        });
-    };
-    /**
-     * Clears all query results (the data set and the statement, if any)
-     */
-    EqContext.prototype.clearResult = function () {
-        this.resultTable.clear(); // do not set resultTable to null. Just clear
-        this.resultStatement = null;
-        this.resultContent = null;
-    };
-    /**
-     * Sets the external 'list cache' provider - an object which implements `ExternalListCache` inteface
-     * @param cache
-     */
-    EqContext.prototype.setExternalListCache = function (cache) {
-        this.externalListCache = cache;
-    };
-    EqContext.prototype.getListFromCache = function (params) {
-        var key = this.getListCacheKey(params);
-        if (this.externalListCache) {
-            return this.externalListCache.get(key);
-        }
-        else {
-            return this.internalListCache[key];
-        }
-    };
-    EqContext.prototype.getListCacheKey = function (params) {
-        var key = params.listName == 'SQL' ? 'SQL_' + params.editorId : params.listName;
-        if (params.queryParams) {
-            key += '_' + Object.keys(params.queryParams).filter(function (k) { return k != 'listName'; })
-                .map(function (k) { return params.queryParams[k]; })
-                .join('_');
-        }
-        return key;
-    };
-    EqContext.prototype.addListToCache = function (params, list) {
-        var key = this.getListCacheKey(params);
-        if (this.externalListCache) {
-            this.externalListCache.set(key, list);
-        }
-        else {
-            this.internalListCache[key] = list;
-        }
-    };
-    /**
-     * Clears the current list cache.
-     */
-    EqContext.prototype.resetListCache = function () {
-        if (this.externalListCache) {
-            this.externalListCache.clear();
-        }
-        else {
-            this.internalListCache = {};
-        }
-    };
-    /**
-     * Gets the handler for 'GetList' requests
-     */
-    EqContext.prototype.getListRequestHandler = function () {
-        return this._listRequestHandler;
-    };
-    /**
-     * Adds the translations of the EasyQuery messages for some locale
-     * @param locale - the ISO code of the locale (like `en` or `uk`)
-     * @param localeInfo - Locale settings and translations of EasyQuery texts and messages.
-     * We expected an object with the struture of LocaleInfo interface here.
-     */
-    EqContext.prototype.addLocale = function (locale, localeInfo) {
-        i18n.addLocale(locale, localeInfo);
-    };
-    EqContext.prototype.addEventListener = function (eventType, handler) {
-        var _this = this;
-        return this.eventEmitter.subscribe(eventType, function (event) { return handler(_this, event.data); });
-    };
-    /**
-     * Remove event handler for event type .
-     * @param eventType The event type.
-     * @param handlerId The handler id.
-     */
-    EqContext.prototype.removeEventListener = function (eventType, handlerId) {
-        this.eventEmitter.unsubscribe(eventType, handlerId);
-    };
-    EqContext.prototype.fireEvent = function (eventType, data) {
-        this.eventEmitter.fire(eventType, data);
-    };
-    EqContext.prototype.getBaseEndpoint = function () {
-        return this.baseEndpoint;
-    };
-    /**
-     * Sends a `loadValueList` requesthe server and processes the response.
-     * @param options A map of options to pass to `loadValueList` function.
-     */
-    EqContext.prototype.loadValueList = function (options) {
-        var _this = this;
-        options = options || {};
-        this.startProcess({
-            action: EqAction.GetValueList,
-            text: 'Loading values'
-        }, WidgetGroup.Result);
-        var valueListResolver = this.eqServices.getValueListResolver();
-        valueListResolver.loadValueList(options)
-            .then(function (values) {
-            _this.endProcess({
-                result: EqActionResult.Success,
-                action: EqAction.GetValueList,
-                text: 'Values loaded'
-            }, WidgetGroup.Result);
-            if (options.success) {
-                options.success(values);
-            }
-        })
-            .catch(function (error) {
-            var editorId = options && options.params ? options.params.editorId : 'undefined';
-            var errorMessage = "Can't load the value list for editor ".concat(editorId, ".\n ").concat(error.message);
-            _this.endProcess({
-                result: EqActionResult.Error,
-                action: EqAction.GetValueList,
-                text: errorMessage,
-                sourceError: error
-            }, WidgetGroup.Result);
-            if (options.error) {
-                options.error(errorMessage, 'GetValueList');
-            }
-        });
-    };
-    /**
-     * Starts the process of the model loading.
-     * This method can initiate a request to EasyQueryServer backend or get the model from OData or GraphQL endpoint
-     * The content of the `options` parameter depends on concrete loader implementation.
-     * @param options A map of options to pass to `loadModel` function (can be ommited)
-     * @example
-     * context.loadModel()
-     *    .then(model => {
-     *       alert("Model loaded!");
-     *    });
-     */
-    EqContext.prototype.loadModel = function (options) {
-        var _this = this;
-        if (this.beforeLoadModel) {
-            this.beforeLoadModel(this, options);
-        }
-        var modelId = options.modelId || '__default';
-        var silent = options.silent || false;
-        this.startProcess({
-            action: EqAction.LoadModel,
-            text: 'Loading model: ' + modelId
-        }, WidgetGroup.Model);
-        var modelLoader = this.eqServices.getModelLoader();
-        return modelLoader.startModelLoading(options)
-            .then(function (value) {
-            if (value) {
-                _this.loadModelFromData(value);
-                if (_this.dataModel.isEmpty()) {
-                    console.warn("Empty model has been loaded. Model ID: ".concat(_this.dataModel.getId()));
-                }
-            }
-            else {
-                console.warn('Model has not been changed.');
-            }
-            _this.fireEvent('loadModel');
-            _this.endProcess({
-                result: EqActionResult.Success,
-                action: EqAction.LoadModel,
-                text: 'Model loaded: ' + modelId
-            }, WidgetGroup.Model);
-            if (!silent) {
-                _this.clearQuery();
-                _this.clearResult();
-                _this.refreshWidgets();
-            }
-            if (options.success) {
-                options.success(_this.getModel());
-            }
-            return _this.getModel();
-        })
-            .catch(function (error) {
-            var errorMessage = "Can't load model ".concat(modelId, ".\n ").concat(error.message);
-            _this.endProcess({
-                result: EqActionResult.Error,
-                action: EqAction.LoadModel,
-                text: errorMessage,
-                sourceError: error
-            }, WidgetGroup.Model);
-            if (options.error) {
-                options.error(errorMessage, "LoadModel");
-            }
-            return _this.getModel();
-        });
-    };
-    EqContext.prototype.callWhenModelLoaded = function (callFunc) {
-        var modelLoader = this.eqServices.getModelLoader();
-        modelLoader.getModelPromise().then(function () {
-            callFunc();
-        });
-    };
-    /**
-     * Loads the query
-     * @param options
-     * The content of the `options` parameter depends on `QueryStorage` implementation.
-     * Usually it contains `success`, `error` callbacks and `queryId` property of the query to load.
-     * @example
-     * context.loadQuery({
-     *      queryId: "query-id"
-     * });
-     */
-    EqContext.prototype.loadQuery = function (options) {
-        var _this = this;
-        options = options || {};
-        var modelLoader = this.eqServices.getModelLoader();
-        this.clearResult();
-        modelLoader.getModelPromise()
-            .then(function () {
-            options = options || {};
-            var queryId = options.queryId;
-            var silent = options.silent || false;
-            if (_this.beforeLoadQuery) {
-                _this.beforeLoadQuery(_this, options);
-            }
-            _this.startProcess({
-                action: EqAction.LoadQuery,
-                text: "Query loading: " + queryId
-            }, WidgetGroup.Query);
-            var queryStorage = _this.eqServices.getQueryStorage();
-            queryStorage.loadQuery(options)
-                .then(function (data) {
-                if (data) {
-                    _this.query.loadFromData(data, {
-                        validate: false
-                    });
-                }
-                _this.limitCustomSqlColumns();
-                _this.fireEvent('loadQuery');
-                _this.endProcess({
-                    result: EqActionResult.Success,
-                    action: EqAction.LoadQuery,
-                    text: 'Query loaded: ' + queryId
-                }, WidgetGroup.Query);
-                _this.query.resetModified();
-                if (!silent) {
-                    _this.query.fireChangedEvent({
-                        part: QueryChangePart.Properties,
-                        wasModified: _this.query.isModified()
-                    });
-                    _this.refreshWidgets();
-                }
-                if (options.success) {
-                    options.success(_this.query);
-                }
-            })
-                .catch(function (error) {
-                var query = _this.getQuery();
-                error.message = "Can't load query [" + query.getId() + "]\n" + (error.message || "");
-                if (options.error) {
-                    options.error(error.message, EqAction.LoadQuery);
-                }
-                _this.endProcess({
-                    result: EqActionResult.Error,
-                    action: EqAction.LoadQuery,
-                    text: error.message,
-                    sourceError: error
-                }, WidgetGroup.Query);
-            });
-        })
-            .catch(function (error) {
-            console.error(error);
-        });
-    };
-    /**
-     * Loads the list of queries available for the current user.
-     * @param options
-     * The content of the `options` parameter depends on `QueryStorage` implementation.
-     * Usually it contains `success`, `error` callbacks
-     */
-    EqContext.prototype.loadQueryList = function (options) {
-        var _this = this;
-        var modelLoader = this.eqServices.getModelLoader();
-        modelLoader.getModelPromise()
-            .then(function () {
-            _this.startQueryListLoading(options);
-        })
-            .catch(function (error) {
-            var errorMessage = "Can't load the list of available queries.\n ".concat(error.message);
-            _this.throwError({
-                action: EqAction.LoadQueryList,
-                text: errorMessage,
-                sourceError: error
-            });
-        });
-    };
-    EqContext.prototype.startQueryListLoading = function (options) {
-        var _this = this;
-        options = options || {};
-        var queryStorage = this.eqServices.getQueryStorage();
-        var queryListLoadingPromise = queryStorage.getQueryList(options);
-        queryListLoadingPromise
-            .then(function (queries) {
-            if (options.success) {
-                options.success(queries);
-            }
-        })
-            .catch(function (error) {
-            var errorMessage = "Can't load the list of available queries.\n ".concat(error.message);
-            if (options.error) {
-                options.error(errorMessage, 'LoadQueryList');
-            }
-            else {
-                _this.throwError({
-                    action: EqAction.LoadQueryList,
-                    text: errorMessage,
-                    sourceError: error
-                });
-            }
-        });
-    };
-    /**
-     * Creates a new query and returns its content back to the client-side.
-     * @param options
-     * The content of the `options` parameter depends on `QueryStorage` implementation.
-     * Usually it contains `success`, `error` callbacks and `silent` option
-     * @example
-     * context.newQuery({
-     *    silent: true
-     * });
-     */
-    EqContext.prototype.newQuery = function (options) {
-        var _this = this;
-        options = options || {};
-        var clearQuery = typeof options.clearQuery !== 'undefined' ? options.clearQuery : true;
-        this.query.reset(clearQuery);
-        if (options.queryId) {
-            this.query.setId(options.queryId);
-        }
-        if (options.name) {
-            this.query.setName(options.name);
-        }
-        if (options.description) {
-            this.query.setDescription(options.description);
-        }
-        var silent = options.silent || false;
-        var useStorage = true;
-        if (typeof options.useStorage !== 'undefined') {
-            useStorage = options.useStorage;
-        }
-        var onNewQuery = function () {
-            var query = _this.getQuery();
-            query.isNewbie = true;
-            if (!silent) {
-                query.fireChangedEvent({
-                    part: QueryChangePart.All,
-                    wasModified: query.isModified()
-                });
-            }
-        };
-        if (useStorage) {
-            this.startProcess({
-                action: EqAction.NewQuery,
-                text: 'New query creation...'
-            }, WidgetGroup.Query);
-            var queryStorage = this.eqServices.getQueryStorage();
-            queryStorage.newQuery(options)
-                .then(function (queryData) {
-                if (queryData) {
-                    _this.query.loadFromData(queryData);
-                }
-                _this.endProcess({
-                    result: EqActionResult.Success,
-                    action: EqAction.NewQuery,
-                    text: 'A new query has been created'
-                }, WidgetGroup.Query);
-                onNewQuery();
-                if (options.success) {
-                    options.success();
-                }
-            })
-                .catch(function (error) {
-                var errorMessage = "Can't create a new query.\n".concat(error.message);
-                _this.endProcess({
-                    result: EqActionResult.Error,
-                    action: EqAction.NewQuery,
-                    text: errorMessage,
-                    sourceError: error
-                }, WidgetGroup.Query);
-                if (options.error) {
-                    options.error(errorMessage, "NewQuery");
-                }
-            });
-        }
-        else {
-            onNewQuery();
-        }
-        return this.query;
-    };
-    /**
-     * Saves the current query to some storage on the server-side.
-     * @param options
-     * The content of the `options` parameter depends on `QueryStorage` implementation.
-     * Usually it contains `success` and `error` callbacks
-     */
-    EqContext.prototype.saveQuery = function (options) {
-        var _this = this;
-        options = options || {};
-        var query = this.getQuery();
-        this.startProcess({
-            action: EqAction.SaveQuery,
-            text: 'Query saving: ' + query.getId()
-        }, WidgetGroup.Query);
-        var queryStorage = this.eqServices.getQueryStorage();
-        queryStorage.saveQuery(options)
-            .then(function (data) {
-            _this.endProcess({
-                action: EqAction.SaveQuery,
-                result: EqActionResult.Success,
-                text: "Query saved: " + query.getId()
-            }, WidgetGroup.Query);
-            if (data) {
-                query.loadFromData(data);
-            }
-            query.resetModified();
-            query.isNewbie = false;
-            if (options.success) {
-                options.success();
-            }
-        })
-            .catch(function (error) {
-            var errorMessage = "Can't save query ".concat(query.getId(), ".\n ").concat(error.message);
-            _this.endProcess({
-                action: EqAction.SaveQuery,
-                result: EqActionResult.Error,
-                text: errorMessage,
-                sourceError: error
-            }, WidgetGroup.Query);
-            if (options.error) {
-                options.error(errorMessage, EqAction.SaveQuery);
-            }
-        });
-    };
-    /**
-     * Removes the current query from some storage on the server-side.
-     * @param options
-     * The content of the `options` parameter depends on `QueryStorage` implementation.
-     * Usually it contains `success` and `error` callbacks
-     */
-    EqContext.prototype.removeQuery = function (options) {
-        var _this = this;
-        options = options || {};
-        var query = this.getQuery();
-        this.startProcess({
-            action: EqAction.RemoveQuery,
-            text: 'Query deleting: ' + query.getId()
-        }, WidgetGroup.Query);
-        var queryStorage = this.eqServices.getQueryStorage();
-        queryStorage.removeQuery(options)
-            .then(function () {
-            query.reset();
-            _this.endProcess({
-                action: EqAction.RemoveQuery,
-                result: EqActionResult.Success,
-                text: "Query deleted: " + query.getId()
-            }, WidgetGroup.Query);
-            if (options.success) {
-                options.success();
-            }
-        })
-            .catch(function (error) {
-            var errorMessage = "Can't remove query ".concat(query.getId(), ".\n ").concat(error.message);
-            _this.endProcess({
-                action: EqAction.RemoveQuery,
-                result: EqActionResult.Error,
-                text: errorMessage,
-                sourceError: error
-            }, WidgetGroup.Query);
-            if (options.error) {
-                options.error(errorMessage, 'RemoveQuery');
-            }
-        });
-    };
-    /**
-     * Syncronizes the current query.
-     * @param options
-     * The content of the `options` parameter depends on `QuerySyncronizer` implementation.
-     * Usually it contains `success` and `error` callbacks
-     */
-    EqContext.prototype.syncQuery = function (options) {
-        var _this = this;
-        options = options || {};
-        var query = this.getQuery();
-        if (this.beforeSyncQuery) {
-            this.beforeSyncQuery(this, options);
-        }
-        this.startProcess({
-            action: EqAction.SyncQuery,
-            text: 'Query syncing: ' + query.getId()
-        }, WidgetGroup.Query);
-        var querySyncrhonizer = this.eqServices.getQuerySynchronizer();
-        querySyncrhonizer.syncQuery(options)
-            .then(function (result) {
-            _this.resultStatement = result && result.statement
-                ? result.statement
-                : '';
-            _this.fireEvent('syncQuery');
-            _this.refreshWidgets(WidgetGroup.Statement);
-            _this.endProcess({
-                result: EqActionResult.Success,
-                action: EqAction.SyncQuery,
-                text: 'Query synced: ' + query.getId()
-            }, WidgetGroup.Query);
-            if (result) {
-                if (result.querySaved) {
-                    var q = result.query;
-                    if (q) {
-                        query.setId(q.id);
-                        query.setName(q.name);
-                        query.setDescription(q.desc);
-                        query.extraData = q.extraData;
-                    }
-                    query.resetModified();
-                    _this.refreshWidgets(WidgetGroup.QueryStatus);
-                }
-                if (options.success) {
-                    options.success(result);
-                }
-            }
-        })
-            .catch(function (error) {
-            var errorMessage = "Can't synchronize query ".concat(query.getId(), ".\n ").concat(error.message);
-            _this.endProcess({
-                result: EqActionResult.Error,
-                action: EqAction.SyncQuery,
-                text: errorMessage,
-                sourceError: error
-            }, WidgetGroup.Query);
-            if (options.error) {
-                options.error(errorMessage, 'SyncQuery');
-            }
-        });
-    };
-    /**
-     * Fetches the data (usuall by executing current query) and processes the result.
-     * @param options
-     * The `options` parameter in addition to the options defined in FetchDataOptions structure may also contain `success` and `error` callbacks.
-     * @example
-     * context.fetchData({ success: function(result) {
-     *   //do whatever you want with the result
-     * }})
-     *
-     */
-    EqContext.prototype.fetchData = function (options) {
-        var _this = this;
-        options = options || {};
-        var elasticPaging = typeof (options.elasticPaging) !== 'undefined'
-            ? options.elasticPaging
-            : this.elasticPaging;
-        this.resultTable.elasticChunks = elasticPaging;
-        options.chunk = options.chunk ||
-            {
-                offset: 0,
-                limit: this.resultTable.chunkSize,
-                needTotal: !elasticPaging
-            };
-        if (this.debugMode) {
-            options.debug = 'Fetching the result set. Initial chunk';
-        }
-        if (!this.query.tryValidate({
-            checkExpressions: true
-        })) {
-            return;
-        }
-        //just to support the old way of catching "group fetch" operation finish
-        if (options.groupFetchSuccess) {
-            this.afterGroupFetch = options.groupFetchSuccess;
-        }
-        if (this.resultTable.elasticChunks) {
-            options.chunk.limit++;
-        }
-        this.fetchDataChunk(__assign(__assign({}, options), { success: function (result) {
-                if (result.statement) {
-                    _this.resultStatement = result.statement;
-                    _this.refreshWidgets(WidgetGroup.Statement);
-                }
-                var aggrCalculator = _this.getServices().getAggregatesCalculator();
-                aggrCalculator.reset();
-                _this.resultContent = result;
-                if (result.resultSet) {
-                    _this.resultTable.clear();
-                    _this.resultTable.id = _this.query.getId();
-                    var resultSet = result.resultSet;
-                    for (var _i = 0, _a = resultSet.cols; _i < _a.length; _i++) {
-                        var col = _a[_i];
-                        _this.resultTable.columns.add(col);
-                    }
-                    if (result.meta && typeof (result.meta.totalRecords) !== 'undefined') {
-                        _this.resultTable.setTotal(result.meta.totalRecords);
-                    }
-                    var count = resultSet.rows.length;
-                    if (_this.resultTable.elasticChunks && count === options.chunk.limit) {
-                        resultSet.rows.splice(resultSet.rows.length - 1, 1);
-                    }
-                    for (var _b = 0, _c = resultSet.rows; _b < _c.length; _b++) {
-                        var row = _c[_b];
-                        _this.resultTable.addRow(row);
-                    }
-                    if (_this.resultTable.elasticChunks) {
-                        _this.resultTable['total'] = (count < options.chunk.limit)
-                            ? resultSet.rows.length
-                            : 0;
-                    }
-                    _this.resultTable.fireUpdated();
-                }
-                if (options.success) {
-                    options.success(result);
-                }
-            } }));
-    };
-    EqContext.prototype.getQueryFile = function (options) {
-        var _this = this;
-        var query = this.getQuery();
-        this.startProcess({
-            action: EqAction.GetQueryFile,
-            text: 'Getting query file: ' + query.getId()
-        }, WidgetGroup.Query);
-        var queryFileLoader = this.getServices().getQueryFileLoader();
-        queryFileLoader.getQueryFile(options)
-            .then(function () {
-            _this.endProcess({
-                result: EqActionResult.Success,
-                action: EqAction.GetQueryFile,
-                text: 'Getting query file: ' + query.getId()
-            }, WidgetGroup.Query);
-            if (options.success) {
-                options.success();
-            }
-        })
-            .catch(function (error) {
-            var errorMessage = "Can't get file for query ".concat(query.getId(), ".\n ").concat(error.message);
-            _this.endProcess({
-                result: EqActionResult.Error,
-                action: EqAction.GetQueryFile,
-                text: errorMessage,
-                sourceError: error
-            }, WidgetGroup.Query);
-            if (options.error) {
-                options.error(errorMessage, 'GetQueryFile');
-            }
-        });
-    };
-    EqContext.prototype.uploadQueryFile = function (options) {
-        var _this = this;
-        var query = this.getQuery();
-        this.startProcess({
-            action: EqAction.UploadQueryFile,
-            text: 'Uploading query file: ' + query.getId()
-        }, WidgetGroup.Query);
-        var queryFileLoader = this.getServices().getQueryFileLoader();
-        queryFileLoader.uploadQueryFile(options)
-            .then(function (data) {
-            query.loadFromData(data);
-            _this.fireEvent('loadQuery');
-            _this.refreshWidgets();
-            _this.endProcess({
-                result: EqActionResult.Success,
-                action: EqAction.UploadQueryFile,
-                text: 'Uploading query file: ' + query.getId()
-            }, WidgetGroup.Query);
-            if (options.success) {
-                options.success();
-            }
-        })
-            .catch(function (error) {
-            var errorMessage = "Can't upload a file for query ".concat(query.getId(), ".\n ").concat(error.message);
-            _this.endProcess({
-                result: EqActionResult.Error,
-                action: EqAction.UploadQueryFile,
-                text: errorMessage,
-                sourceError: error
-            }, WidgetGroup.Query);
-            if (options.error) {
-                options.error(errorMessage, 'UploadQueryFile');
-            }
-        });
-    };
-    EqContext.prototype.fetchDataChunk = function (options) {
-        var _this = this;
-        var queryId = this.getQuery().getId();
-        var fetchOptions = options || {};
-        if (this.useStoredQueryOnFetch) {
-            fetchOptions.queryId = this.query.getId();
-        }
-        if (this.beforeFetchData) {
-            this.beforeFetchData(this, fetchOptions);
-        }
-        this.startProcess({
-            action: EqAction.FetchData,
-            text: 'Fetching data for the query: ' + queryId
-        }, WidgetGroup.Result);
-        var dataFetcher = this.eqServices.getDataFetcher();
-        dataFetcher.fetchData(fetchOptions)
-            .then(function (result) {
-            if (result.statement) {
-                _this.resultStatement = result.statement;
-            }
-            _this.resultContent = result;
-            // we need to call success callback before firing fetchData,
-            // because otherwise, it won't update the result table 
-            // in the context before afterFetchData callback is called.
-            if (fetchOptions.success) {
-                fetchOptions.success(result);
-            }
-            _this.fireEvent('fetchData');
-            _this.endProcess({
-                result: EqActionResult.Success,
-                action: EqAction.FetchData,
-                text: 'Data fetching is finished for the query: ' + queryId
-            }, WidgetGroup.Result);
-        })
-            .catch(function (error) {
-            var errorMessage = "Data fetching error for the query ".concat(queryId, ". \n").concat(error.message);
-            _this.endProcess({
-                result: EqActionResult.Error,
-                action: EqAction.FetchData,
-                text: errorMessage,
-                sourceError: error
-            }, WidgetGroup.Result);
-            if (fetchOptions.error) {
-                fetchOptions.error(errorMessage, EqAction.FetchData);
-            }
-        });
-    };
-    EqContext.prototype.onResultTableUpdate = function () {
-        var _this = this;
-        var aggrSettings = this.query.getAggregationSettings();
-        var calculator = this.getServices().getAggregatesCalculator();
-        if (aggrSettings.needAggrCalculation() && calculator.needRecalculation()) {
-            calculator.calculate({
-                maxLevel: aggrSettings.getGroups().length + 1,
-                resultObtained: function (result, level) {
-                    if (_this.afterGroupFetch) {
-                        _this.afterGroupFetch(result);
-                    }
-                },
-                errorOccurred: function (error) {
-                    var errorMessage = "Data fetching error on group level ".concat(error.level, " query. \n").concat(error.message);
-                    _this.throwError({
-                        action: EqAction.FetchData,
-                        text: errorMessage,
-                        sourceError: error
-                    });
-                }
-            });
-        }
-    };
-    /**
-     * Fetches the data for a drill-down query (if defined) and processes the result.
-     * @param options
-     */
-    EqContext.prototype.fetchDrillDownData = function (options) {
-        var _this = this;
-        options = options || {};
-        options.chunk = options.chunk ||
-            {
-                offset: 0,
-                limit: this.resultTable.chunkSize,
-                needTotal: true
-            };
-        var query = options.query;
-        var queryId = query.getId();
-        this.startProcess({
-            action: EqAction.FetchData,
-            text: 'DrillDown executing: ' + queryId
-        }, WidgetGroup.Result);
-        var queryExecutor = this.eqServices.getDataFetcher();
-        queryExecutor.fetchData(options)
-            .then(function (result) {
-            _this.endProcess({
-                result: EqActionResult.Success,
-                action: EqAction.FetchData,
-                text: 'DrillDown execution error: ' + queryId
-            }, WidgetGroup.Result);
-            if (options.success) {
-                options.success(result);
-            }
-        })
-            .catch(function (error) {
-            var errorMessage = "Drill-down data fetching error for query ".concat(queryId, ". \n").concat(error.message);
-            _this.endProcess({
-                result: EqActionResult.Error,
-                action: EqAction.FetchData,
-                text: errorMessage,
-            }, WidgetGroup.Result);
-            if (options.error) {
-                options.error(errorMessage, 'DrillDown');
-            }
-            else {
-                _this.throwError({
-                    action: EqAction.FetchData,
-                    text: errorMessage
-                });
-            }
-        });
-    };
-    /**
-     * Fetches the data for defined by this context and exports them to the specified format.
-     * @param options
-     * The content of the `options` parameter depends on `EqExporter` implementation.
-     * Usually it contains `format` property which defines the format of the exported data (e.g. `csv`),
-     * and `success` and `error` callbacks
-     * @example
-     * context.exportResult({
-     *      format: csv
-     * });
-     *
-     */
-    EqContext.prototype.exportResult = function (options) {
-        var _this = this;
-        options = options || {};
-        options.chunk = options.chunk || EmptyChunk;
-        if (this.beforeExportResult) {
-            this.beforeExportResult(this, options);
-        }
-        var format = options.format;
-        if (format) {
-            var exporter = this.getExporter(format);
-            if (exporter) {
-                var queryId_1 = this.getQuery().getId();
-                if (this.useStoredQueryOnFetch) {
-                    options.queryId = queryId_1;
-                }
-                this.startProcess({
-                    action: EqAction.ExportResult,
-                    text: 'Exporting result for query: ' + queryId_1
-                }, WidgetGroup.Result);
-                var localeSettings = i18n.getLocaleSettings();
-                options.settings = localeSettings;
-                var aggrSettings = this.query.getAggregationSettings();
-                if (aggrSettings.hasAggregates()
-                    && (aggrSettings.hasGrandTotals() || aggrSettings.hasGroups())) {
-                    options.aggregates = aggrSettings.saveToData();
-                }
-                exporter.export(options)
-                    .then(function (result) {
-                    _this.fireEvent('exportResult');
-                    _this.endProcess({
-                        result: EqActionResult.Success,
-                        action: EqAction.ExportResult,
-                        text: "The result set for query [".concat(queryId_1, "] has been successfully exported")
-                    }, WidgetGroup.Result);
-                    if (options.success) {
-                        options.success();
-                    }
-                })
-                    .catch(function (error) {
-                    var errorMessage = "Error on exporting data for query  ".concat(queryId_1, ". \n").concat(error.message);
-                    _this.endProcess({
-                        result: EqActionResult.Error,
-                        action: EqAction.ExportResult,
-                        text: errorMessage,
-                        sourceError: error
-                    }, WidgetGroup.Result);
-                    if (options.error) {
-                        options.error(errorMessage, 'ExportResult');
-                    }
-                });
-            }
-        }
-    };
-    EqContext.prototype.limitCustomSqlColumns = function () {
-        if (!this.options.allowCustomExpressions) {
-            this.query.getColumns().forEach(function (col) {
-                if (col.expr.tag === ExprTag.CustomSql) {
-                    col.enabled = false;
-                }
-            });
-        }
-    };
-    EqContext.prototype.getAttributeTitle = function (attr) {
-        var format = this.options.attributeFormat;
-        return this.getModel().getAttributeText(attr, format);
-    };
-    EqContext.prototype.getColumnTitle = function (attr) {
-        var format = this.options.columnTitleFormat || this.options.attributeFormat;
-        return this.getModel().getAttributeText(attr, format);
-    };
-    EqContext.prototype.getDefaultColumnCaption = function (column) {
-        var attr;
-        var model = this.getModel();
-        switch (column.expr.tag) {
-            case ExprTag.Constant:
-                return "Contant Column";
-            case ExprTag.CustomSql:
-                return "SQL Column";
-            case ExprTag.ParentColumn:
-                return "Parent Column";
-            case ExprTag.Query:
-                return "Query Column";
-            case ExprTag.EntityAttribute:
-            case ExprTag.ParentEntityAttribute:
-                attr = model.getAttributeById(column.expr.value);
-                return this.getColumnTitle(attr);
-            case ExprTag.AggregateFunction:
-                attr = model.getAttributeById(column.expr.args[0].value);
-                return this.getColumnTitle(attr) + ' ' + model.getAggrFunctionCaption(column.expr.func);
-            default:
-                return 'Column';
-        }
-    };
-    return EqContext;
-}());
-export { EqContext };
-//# sourceMappingURL=context.js.map