@progress/telerik-jquery-report-viewer 21.24.130 → 22.24.514

package/dist/es/controller.js

@@ -0,0 +1,1203 @@
+import { extend, tryParseInt, each, logError, isInvalidClientException, isInternalServerError, isApplicationException, getExceptionInstance, stringFormat, parseJSON, escapeHtml, isSystemArgumentException, exceptionTypeNamesMatch, isSvgSupported } from './utils.js';
+import { stringResources } from './stringResources.js';
+import { PrintManager } from './print.js';
+import { ParameterValidators } from './parameterValidators.js';
+import { ViewModes, PageModes, PrintModes, ScaleModes } from './enums.js';
+import { ServiceClientSentinel } from './service-client-sentinel.js';
+import { EventEmitter } from './event-emitter.js';
+
+var defaultOptions = {
+  pagePollIntervalMs: 500,
+  documentInfoPollIntervalMs: 2e3
+};
+function ReportViewerController(options) {
+  var controller = {};
+  var clientId;
+  var reportInstanceId;
+  var reportDocumentId;
+  var registerClientPromise;
+  var registerInstancePromise;
+  var documentFormatsPromise;
+  var report;
+  var parameterValues;
+  var processedParameterValues;
+  var currentPageNumber;
+  var pageCount;
+  var viewMode = ViewModes.INTERACTIVE;
+  var pageMode = PageModes.CONTINUOUS_SCROLL;
+  var loader;
+  var printMode = PrintModes.AUTO_SELECT;
+  var bookmarkNodes;
+  var renderingExtensions;
+  var clientHasExpired = false;
+  var parameterValidators = ParameterValidators;
+  var eventEmitter = new EventEmitter();
+  var serviceClientSentinel;
+  clearReportState();
+  options = extend({}, defaultOptions, options);
+  var settings = options.settings;
+  if (typeof settings.getPrintMode === "function") {
+    printMode = settings.getPrintMode();
+  }
+  var client = options.serviceClient;
+  if (!client) {
+    throw stringResources.noServiceClient;
+  }
+  clientId = settings.getClientId();
+  initializeAndStartSentinel();
+  function setClientId(id) {
+    clientId = id;
+    stopSentinel();
+    settings.setClientId(clientId);
+    initializeAndStartSentinel();
+  }
+  function clearClientId() {
+    clientId = null;
+    registerClientPromise = null;
+    stopSentinel();
+    serviceClientSentinel = null;
+    settings.setClientId(null);
+  }
+  function initializeAndStartSentinel() {
+    if (typeof settings.getKeepClientAlive !== "function") {
+      throw new Error("Required settings.getKeepClientAlive() is not supplied for ReportViewerController");
+    }
+    if (settings.getKeepClientAlive() && clientId) {
+      return client.getClientsSessionTimeoutSeconds().then(function(sessionTimeout) {
+        serviceClientSentinel = new ServiceClientSentinel(client, clientId, sessionTimeout);
+        serviceClientSentinel.start();
+      });
+    }
+  }
+  function stopSentinel() {
+    if (settings.getKeepClientAlive() && !!serviceClientSentinel) {
+      serviceClientSentinel.stop();
+    }
+  }
+  function getFormat() {
+    if (viewMode === ViewModes.PRINT_PREVIEW) {
+      return "HTML5";
+    }
+    return "HTML5Interactive";
+  }
+  function handleRequestError(xhrData, localizedMessage, suppressErrorBubbling) {
+    var errorMessage = "";
+    if (!xhrData.xhr) {
+      errorMessage = xhrData;
+      controller.raiseError(formatXhrError({ "responseText": errorMessage }, null, null, null));
+      throw errorMessage;
+    }
+    var xhr = xhrData.xhr;
+    if (isInvalidClientException(xhr)) {
+      onClientExpired();
+    }
+    var formattedError = formatXhrError(
+      xhr,
+      xhrData.status,
+      isInternalServerError(xhrData.error) ? "" : xhrData.error,
+      localizedMessage
+    );
+    controller.raiseError(formattedError);
+    if (!suppressErrorBubbling) {
+      if (isApplicationException(xhr)) {
+        var exception = getExceptionInstance(xhr);
+        if (exception) {
+          throw exception;
+        }
+      }
+      throw xhr.responseJSON && xhr.responseJSON.exceptionMessage ? xhr.responseJSON.exceptionMessage : stringResources.promisesChainStopError;
+    }
+  }
+  function initializeClientAsync() {
+    if (!registerClientPromise) {
+      registerClientPromise = client.registerClient().catch(function(xhrErrorData) {
+        handleRequestError(xhrErrorData, stringResources.errorRegisteringViewer);
+      }).then(function(clientId2) {
+        setClientId(clientId2);
+      }).catch(clearClientId);
+    }
+    return registerClientPromise;
+  }
+  function registerInstanceAsync() {
+    if (!registerInstancePromise) {
+      registerInstancePromise = createReportInstanceAsync(report, parameterValues).then(function(instanceId) {
+        reportInstanceId = instanceId;
+      });
+      registerInstancePromise.catch(function(errorMessage) {
+        registerInstancePromise = null;
+      });
+    }
+    return registerInstancePromise;
+  }
+  function clearReportState() {
+    reportDocumentId = null;
+    reportInstanceId = null;
+    registerInstancePromise = null;
+    resetPageNumbers();
+  }
+  function resetPageNumbers() {
+    currentPageNumber = pageCount = 0;
+  }
+  function formatError(args) {
+    var len = args.length;
+    if (len === 1) {
+      return args[0];
+    }
+    if (len > 1) {
+      return stringFormat(args[0], Array.prototype.slice.call(args, 1));
+    }
+    return "";
+  }
+  function createReportInstanceAsync(report2, parameterValues2) {
+    throwIfNotInitialized();
+    return client.createReportInstance(clientId, report2, parameterValues2).catch(function(xhrErrorData) {
+      handleRequestError(xhrErrorData, stringFormat(stringResources.errorCreatingReportInstance, [escapeHtml(report2)]));
+    });
+  }
+  function registerDocumentAsync(format, deviceInfo, useCache, baseDocumentId, actionId) {
+    throwIfNotInitialized();
+    throwIfNoReportInstance();
+    return client.createReportDocument(clientId, reportInstanceId, format, deviceInfo, useCache, baseDocumentId, actionId).catch(function(xhrErrorData) {
+      handleRequestError(xhrErrorData, stringFormat(stringResources.errorCreatingReportDocument, [escapeHtml(report), escapeHtml(format)]));
+    });
+  }
+  function sendDocumentAsync(documentId, args) {
+    throwIfNotInitialized();
+    throwIfNoReportInstance();
+    return client.sendDocument(clientId, reportInstanceId, documentId, args).catch(function(xhrErrorData) {
+      handleRequestError(xhrErrorData, stringFormat(stringResources.errorSendingDocument, [escapeHtml(report)]));
+    });
+  }
+  function getDocumentInfoRecursive(clientId2, instanceId, documentId, options2) {
+    if (!options2.isCanceled && instanceId === reportInstanceId) {
+      return client.getDocumentInfo(clientId2, instanceId, documentId).catch(handleRequestError).then(function(info) {
+        if (info && info.documentReady) {
+          return info;
+        } else {
+          info["promise"] = new Promise(function(resolve, reject) {
+            window.setTimeout(resolve, options2.documentInfoPollIntervalMs);
+          }).then(function() {
+            return getDocumentInfoRecursive(clientId2, instanceId, documentId, options2);
+          });
+          return info;
+        }
+      });
+    } else {
+      return Promise.reject();
+    }
+  }
+  function ReportLoader(reportHost, useCache, baseDocumentId, actionId) {
+    var loaderOptions = {};
+    function onReportDocumentRegistered(id) {
+      if (reportHost) {
+        reportDocumentId = id;
+        onBeginLoadReport();
+        getReportDocumentReady();
+      }
+    }
+    function onBeforeLoadReport(args) {
+      loaderOptions.documentInfoPollIntervalMs = options.pagePollIntervalMs;
+      if (reportHost) {
+        reportHost.beforeLoadReport(args);
+      }
+    }
+    function onBeginLoadReport() {
+      if (reportHost) {
+        reportHost.beginLoadReport();
+      }
+    }
+    function onReportLoadComplete(info) {
+      if (reportHost) {
+        reportHost.onReportLoadComplete(info);
+      }
+    }
+    function onReportLoadProgress(info) {
+      if (reportHost) {
+        pageCount = info.pageCount;
+        reportHost.reportLoadProgress(info);
+      }
+    }
+    function getReportDocumentReady() {
+      throwIfNotInitialized();
+      throwIfNoReportInstance();
+      throwIfNoReportDocument();
+      progressReportDocumentReady(getDocumentInfoRecursive(clientId, reportInstanceId, reportDocumentId, loaderOptions));
+    }
+    function progressReportDocumentReady(getDocumentReadyPromise) {
+      getDocumentReadyPromise.then(function(info) {
+        if (info.documentReady) {
+          onReportLoadComplete(info);
+        } else {
+          onReportLoadProgress(info);
+          progressReportDocumentReady(info.promise);
+        }
+      });
+    }
+    function getPageAsync(pageNo) {
+      return new Promise(function(resolve, reject) {
+        var fn = function() {
+          client.getPage(clientId, reportInstanceId, reportDocumentId, pageNo).catch(handleRequestError).then(function(pageInfo) {
+            if (pageInfo.pageReady) {
+              resolve(pageInfo);
+            } else {
+              window.setTimeout(fn, options.pagePollIntervalMs);
+            }
+          });
+        };
+        fn();
+      });
+    }
+    function onBeginLoadPage(pageNo) {
+      if (reportHost) {
+        reportHost.beginLoadPage(pageNo);
+      }
+    }
+    var loadPromise;
+    function loadAsync() {
+      if (!loadPromise) {
+        var format = getFormat();
+        var deviceInfo = createPreviewDeviceInfo();
+        onBeforeLoadReport({ deviceInfo });
+        loadPromise = initializeClientAsync().then(registerInstanceAsync).then(function() {
+          return registerDocumentAsync(format, deviceInfo, useCache, baseDocumentId, actionId);
+        }).then(onReportDocumentRegistered);
+      }
+      return loadPromise;
+    }
+    function createPreviewDeviceInfo() {
+      var deviceInfo = createDeviceInfo();
+      deviceInfo.ContentOnly = true;
+      deviceInfo.UseSVG = isSvgSupported();
+      return deviceInfo;
+    }
+    return {
+      beginLoad: function() {
+        loadAsync();
+      },
+      beginGetPage: function(pageNo) {
+        throwIfNotInitialized();
+        loadAsync().then(function() {
+          onBeginLoadPage(pageNo);
+          return getPageAsync(pageNo);
+        }).then(function(pageInfo) {
+          loaderOptions.documentInfoPollIntervalMs = options.documentInfoPollIntervalMs;
+          if (reportHost) {
+            reportHost.pageReady(pageInfo);
+          }
+        });
+      },
+      getPageData: function(pageNo) {
+        throwIfNotInitialized();
+        return loadAsync().then(function() {
+          return getPageAsync(pageNo);
+        });
+      },
+      dispose: function() {
+        reportHost = null;
+      },
+      cancel: function() {
+        loaderOptions.isCanceled = true;
+      }
+    };
+  }
+  function createDeviceInfo() {
+    var deviceInfo = {};
+    if (settings.getEnableAccessibility()) {
+      deviceInfo.enableAccessibility = true;
+      deviceInfo.contentTabIndex = settings.contentTabIndex;
+    }
+    var args = {};
+    controller.getSearchDialogState(args);
+    var searchInitiated = args.visible;
+    var searchMetadataOnDemand = settings.getSearchMetadataOnDemand();
+    var enableSearch = !searchMetadataOnDemand || searchInitiated;
+    deviceInfo.enableSearch = enableSearch;
+    return deviceInfo;
+  }
+  function tryResolveClientErrorByExceptionType(exceptionType) {
+    var parameterExceptionShortName = "InvalidParameterException";
+    return exceptionTypeNamesMatch(exceptionType, parameterExceptionShortName, "Telerik.Reporting.Services.Engine." + parameterExceptionShortName) ? stringResources.missingOrInvalidParameter : "";
+  }
+  function formatXhrError(xhr, status, error, localizedMessage) {
+    var parsedXhr = parseJSON(xhr.responseText);
+    var result = "";
+    if (parsedXhr) {
+      var errorMessage = tryResolveClientErrorByExceptionType(parsedXhr.exceptionType || parsedXhr.error);
+      if (errorMessage) {
+        return errorMessage;
+      }
+      result = escapeHtml(parsedXhr.message);
+      var exceptionMessage = escapeHtml(parsedXhr.exceptionMessage || parsedXhr.error_description);
+      if (exceptionMessage) {
+        if (result) {
+          result += " " + exceptionMessage;
+        } else {
+          result = exceptionMessage;
+        }
+      }
+    } else {
+      result = escapeHtml(xhr.responseText);
+    }
+    if (localizedMessage || error) {
+      if (result) {
+        result = " " + result;
+      }
+      result = escapeHtml(localizedMessage ? localizedMessage : error) + result;
+    }
+    if (isInvalidClientException(xhr)) {
+      result += "<br />" + stringResources.clientExpired;
+    }
+    return result;
+  }
+  function getReportPage(pageNo) {
+    if (loader) {
+      loader.beginGetPage(pageNo);
+    }
+  }
+  function loadReportAsync(ignoreCache, baseDocumentId, actionId) {
+    if (!report) {
+      controller.raiseError(stringResources.noReport);
+      return;
+    }
+    if (loader) {
+      loader.dispose();
+      loader = null;
+    }
+    clearReportState();
+    loader = new ReportLoader(controller, !ignoreCache, baseDocumentId, actionId);
+    loader.beginLoad();
+  }
+  function printReport() {
+    throwIfNoReport();
+    var deviceInfo = {
+      ImmediatePrint: true
+    };
+    var printStartArgs = {
+      deviceInfo,
+      handled: false
+    };
+    controller.printStarted(printStartArgs);
+    if (!printStartArgs.handled) {
+      controller.setUIState({
+        operationName: "PrintInProgress",
+        inProgress: true
+      });
+      controller.showNotification({ stringResources: "preparingPrint" });
+      var canUsePlugin = getCanUsePlugin();
+      var contentDisposition = canUsePlugin ? "inline" : "attachment";
+      var queryString = "response-content-disposition=" + contentDisposition;
+      exportAsync("PDF", deviceInfo).then(
+        function(info) {
+          var url = client.formatDocumentUrl(info.clientId, info.instanceId, info.documentId, queryString);
+          var printEndArgs = {
+            url,
+            handled: false
+          };
+          controller.printReady(printEndArgs);
+          controller.hideNotification();
+          controller.setUIState({
+            operationName: "PrintInProgress",
+            inProgress: false
+          });
+          if (!printEndArgs.handled) {
+            PrintManager.print(url);
+          }
+        }
+      );
+    }
+  }
+  function getCanUsePlugin() {
+    switch (printMode) {
+      case PrintModes.FORCE_PDF_FILE:
+      case false:
+        return false;
+      case PrintModes.FORCE_PDF_PLUGIN:
+      case true:
+        return true;
+      default:
+        return PrintManager.getDirectPrintState();
+    }
+  }
+  function exportReport(format, deviceInfo) {
+    throwIfNoReport();
+    if (!deviceInfo) {
+      deviceInfo = createDeviceInfo();
+    }
+    var exportStartArgs = {
+      format,
+      deviceInfo,
+      handled: false
+    };
+    controller.exportStarted(exportStartArgs);
+    if (!exportStartArgs.handled) {
+      var queryString = "response-content-disposition=attachment";
+      controller.setUIState({
+        operationName: "ExportInProgress",
+        inProgress: true
+      });
+      controller.showNotification({ stringResources: "preparingDownload" });
+      exportAsync(format, exportStartArgs.deviceInfo).then(
+        function(info) {
+          var url = client.formatDocumentUrl(info.clientId, info.instanceId, info.documentId, queryString);
+          var exportEndArgs = {
+            url,
+            format,
+            handled: false,
+            windowOpenTarget: "_self"
+          };
+          controller.exportReady(exportEndArgs);
+          controller.hideNotification();
+          controller.setUIState({
+            operationName: "ExportInProgress",
+            inProgress: false
+          });
+          if (!exportEndArgs.handled) {
+            window.open(url, exportEndArgs.windowOpenTarget);
+          }
+        }
+      );
+    }
+  }
+  function sendReport(args) {
+    throwIfNoReport();
+    if (!args.deviceInfo) {
+      args.deviceInfo = createDeviceInfo();
+    }
+    var sendEmailStartArgs = {
+      deviceInfo: args.deviceInfo,
+      handled: false,
+      format: args.format
+    };
+    controller.sendEmailStarted(sendEmailStartArgs);
+    var queryString = "response-content-disposition=attachment";
+    if (!sendEmailStartArgs.handled) {
+      exportAsync(args.format, args.deviceInfo).then(
+        function(info) {
+          var url = client.formatDocumentUrl(info.clientId, info.instanceId, info.documentId, queryString);
+          args["url"] = url;
+          args["handled"] = false;
+          controller.sendEmailReady(args);
+          delete args.deviceInfo;
+          if (!args.handled) {
+            sendDocumentAsync(info.documentId, args);
+          }
+        }
+      );
+    }
+  }
+  function exportAsync(format, deviceInfo) {
+    throwIfNoReport();
+    return initializeClientAsync().then(registerInstanceAsync).then(function() {
+      return registerDocumentAsync(format, deviceInfo, true, reportDocumentId);
+    }).then(function(documentId) {
+      return waitReportDocumentReady(clientId, reportInstanceId, documentId, options);
+    });
+  }
+  function waitReportDocumentReady(clientId2, reportInstanceId2, documentId, options2) {
+    return new Promise(function(resolve, reject) {
+      var fn = function(promise) {
+        promise.then(function(info) {
+          if (info.documentReady) {
+            resolve({
+              clientId: clientId2,
+              instanceId: reportInstanceId2,
+              documentId
+            });
+          } else {
+            fn(info.promise);
+          }
+        });
+      };
+      fn(getDocumentInfoRecursive(clientId2, reportInstanceId2, documentId, options2));
+    });
+  }
+  function execServerAction(actionId) {
+    throwIfNoReport();
+    throwIfNoReportInstance();
+    throwIfNoReportDocument();
+    onServerActionStarted();
+    controller.refreshReportCore(false, reportDocumentId, actionId);
+  }
+  function throwIfNotInitialized() {
+    if (!clientId) {
+      throw stringResources.controllerNotInitialized;
+    }
+  }
+  function throwIfNoReportInstance() {
+    if (!reportInstanceId) {
+      throw stringResources.noReportInstance;
+    }
+  }
+  function throwIfNoReportDocument() {
+    if (!reportDocumentId) {
+      throw stringResources.noReportDocument;
+    }
+  }
+  function throwIfNoReport() {
+    if (!report) {
+      throw stringResources.noReport;
+    }
+  }
+  function eventFactory(event, args) {
+    if (typeof args[0] === "function") {
+      eventEmitter.on(event, args[0]);
+    } else {
+      eventEmitter.trigger(event, args);
+    }
+    return controller;
+  }
+  function loadParametersAsync(report2, paramValues) {
+    return initializeClientAsync().then(function() {
+      return client.getParameters(clientId, report2, paramValues || parameterValues || {}).catch(function(xhrErrorData) {
+        handleRequestError(xhrErrorData, stringResources.unableToGetReportParameters);
+      });
+    });
+  }
+  function getDocumentFormatsAsync() {
+    if (renderingExtensions) {
+      return Promise.resolve(renderingExtensions);
+    }
+    if (!documentFormatsPromise) {
+      documentFormatsPromise = client.getDocumentFormats().catch(handleRequestError);
+    }
+    return documentFormatsPromise;
+  }
+  function getServiceVersionAsync() {
+    return client.getServiceVersion().catch(handleRequestError);
+  }
+  function getPageForBookmark(nodes, id) {
+    if (nodes) {
+      for (var i = 0, len = nodes.length; i < len; i++) {
+        var node = nodes[i];
+        if (node.id === id) {
+          return node.page;
+        } else {
+          var page = getPageForBookmark(node.items, id);
+          if (page) {
+            return page;
+          }
+        }
+      }
+    }
+    return null;
+  }
+  function fixDataContractJsonSerializer(arr) {
+    var dict = {};
+    if (Array.isArray(arr)) {
+      arr.forEach(function(pair) {
+        dict[pair.Key] = pair.Value;
+      });
+    }
+    return dict;
+  }
+  function changeReportSource(rs) {
+    setStateReportSource(rs);
+    controller.reportSourceChanged();
+  }
+  function setStateReportSource(rs) {
+    if (typeof settings.setReportSource === "function") {
+      settings.setReportSource(rs);
+    }
+  }
+  function changePageNumber(pageNr) {
+    settings.setPageNumber(pageNr);
+    controller.currentPageChanged();
+  }
+  var actionHandlers = {
+    "sorting": function(action) {
+      execServerAction(action.Id);
+    },
+    "toggleVisibility": function(action) {
+      execServerAction(action.Id);
+    },
+    "navigateToReport": function(action) {
+      var args = action.Value;
+      onServerActionStarted();
+      controller.setReportSource({
+        report: args.Report,
+        parameters: fixDataContractJsonSerializer(args.ParameterValues)
+      });
+      controller.refreshReport(false);
+    },
+    "navigateToUrl": function(action) {
+      var args = action.Value;
+      window.open(args.Url, args.Target);
+    },
+    "navigateToBookmark": function(action) {
+      var id = action.Value;
+      var page = getPageForBookmark(bookmarkNodes, id);
+      controller.navigateToPage(page, {
+        type: "bookmark",
+        id
+      });
+    },
+    "customAction": function(action) {
+    }
+  };
+  function onInteractiveActionExecuting(interactiveActionArgs) {
+    controller.interactiveActionExecuting(interactiveActionArgs);
+  }
+  function executeReportAction(interactiveActionArgs) {
+    var action = interactiveActionArgs.action;
+    var handler = actionHandlers[action.Type];
+    if (typeof handler === "function") {
+      window.setTimeout(function() {
+        onInteractiveActionExecuting(interactiveActionArgs);
+        if (!interactiveActionArgs.cancel) {
+          handler(action);
+        }
+      }, 0);
+    }
+  }
+  function onServerActionStarted() {
+    controller.serverActionStarted();
+  }
+  function onReportActionEnter(args) {
+    controller.interactiveActionEnter({
+      action: args.action,
+      element: args.element
+    });
+  }
+  function onReportActionLeave(args) {
+    controller.interactiveActionLeave({
+      action: args.action,
+      element: args.element
+    });
+  }
+  function onClientExpired() {
+    clientHasExpired = true;
+    controller.clientExpired();
+  }
+  function onReportToolTipOpening(args) {
+    controller.toolTipOpening(args);
+  }
+  function getSearchResultsAsync(args) {
+    if (!args.searchToken || args.searchToken === "") {
+      return Promise.resolve(null);
+    }
+    return client.getSearchResults(clientId, reportInstanceId, reportDocumentId, args.searchToken, args.matchCase, args.matchWholeWord, args.useRegex).catch(handleSearchResultsError);
+  }
+  function handleSearchResultsError(xhrData) {
+    if (!isSystemArgumentException(xhrData.xhr)) {
+      handleRequestError(xhrData, null, true);
+      throw null;
+    }
+    var exceptionDetails = parseJSON(xhrData.xhr.responseText);
+    throw exceptionDetails.exceptionMessage;
+  }
+  function appendInvalidReportParameterNames(invalidParameters) {
+    var errorElement = document.querySelector(".trv-pages-area .trv-error-message");
+    var invalidParametersHolder = document.createElement("ul");
+    for (var index = 0; index < invalidParameters.length; index++) {
+      var invalidParameterText = document.createElement("li");
+      invalidParameterText.classList.add(invalidParameters[index].name);
+      invalidParameterText.innerText = stringFormat("{0} ({1})", [invalidParameters[index].text, invalidParameters[index].name]);
+      invalidParametersHolder.appendChild(invalidParameterText);
+    }
+    errorElement.appendChild(invalidParametersHolder);
+  }
+  controller.Events = {
+    ERROR: "error",
+    EXPORT_STARTED: "exportStarted",
+    EXPORT_DOCUMENT_READY: "exportDocumentReady",
+    PRINT_STARTED: "printStarted",
+    PRINT_DOCUMENT_READY: "printDocumentReady",
+    BEFORE_LOAD_PARAMETERS: "beforeLoadParameters",
+    LOADED_REPORT_CHANGE: "loadedReportChange",
+    BEFORE_LOAD_REPORT: "beforeLoadReport",
+    BEGIN_LOAD_REPORT: "beginLoadReport",
+    REPORT_LOAD_COMPLETE: "reportLoadComplete",
+    REPORT_LOAD_PROGRESS: "reportLoadProgress",
+    REPORT_LOAD_FAIL: "reportLoadFail",
+    BEGIN_LOAD_PAGE: "beginLoadPage",
+    PAGE_READY: "pageReady",
+    VIEW_MODE_CHANGED: "viewModeChanged",
+    PAGE_MODE_CHANGED: "pageModeChanged",
+    PRINT_MODE_CHANGED: "printModeChanged",
+    REPORT_SOURCE_CHANGED: "reportSourceChanged",
+    NAVIGATE_TO_PAGE: "navigateToPage",
+    CURRENT_PAGE_CHANGED: "currentPageChanged",
+    GET_DOCUMENT_MAP_STATE: "trv.GET_DOCUMENT_MAP_STATE",
+    SET_DOCUMENT_MAP_VISIBLE: "trv.SET_DOCUMENT_MAP_VISIBLE",
+    GET_PARAMETER_AREA_STATE: "trv.GET_PARAMETER_AREA_STATE",
+    SET_PARAMETER_AREA_VISIBLE: "trv.SET_PARAMETER_AREA_VISIBLE",
+    SCALE_CHANGED: "scaleChanged",
+    SCALE_MODE_CHANGED: "scaleModeChanged",
+    SERVER_ACTION_STARTED: "serverActionStarted",
+    SET_TOGGLE_SIDE_MENU: "trv.SET_TOGGLE_SIDE_MENU",
+    GET_TOGGLE_SIDE_MENU: "trv.GET_TOGGLE_SIDE_MENU",
+    UPDATE_UI: "trv.UPDATE_UI",
+    CSS_LOADED: "cssLoaded",
+    RELOAD_PARAMETERS: "reloadParameters",
+    INTERACTIVE_ACTION_EXECUTING: "interactiveActionExecuting",
+    INTERACTIVE_ACTION_ENTER: "interactiveActionEnter",
+    INTERACTIVE_ACTION_LEAVE: "interactiveActionLeave",
+    UPDATE_UI_INTERNAL: "trv.UPDATE_UI_INTERNAL",
+    CLIENT_EXPIRED: "clientExpired",
+    TOOLTIP_OPENING: "tooltipOpening",
+    TOOLTIP_CLOSING: "tooltipClosing",
+    PAGE_NUMBER: "trv.PAGE_NUMBER",
+    PAGE_COUNT: "trv.PAGE_COUNT",
+    GET_SEARCH_DIALOG_STATE: "trv.GET_SEARCH_DIALOG_STATE",
+    GET_SEND_EMAIL_DIALOG_STATE: "trv.GET_SEND_EMAIL_DIALOG_STATE",
+    SET_SEARCH_DIALOG_VISIBLE: "trv.SET_SEARCH_DIALOG_VISIBLE",
+    SET_SEND_EMAIL_DIALOG_VISIBLE: "trv.SET_SEND_EMAIL_DIALOG_VISIBLE",
+    SEND_EMAIL_STARTED: "sendEmailStarted",
+    SEND_EMAIL_READY: "sendEmailDocumentReady",
+    SHOW_NOTIFICATION: "trv.SHOW_NOTIFICATION",
+    HIDE_NOTIFICATION: "trv.HIDE_NOTIFICATION",
+    UI_STATE: "trv.UI_STATE",
+    SCROLL_PAGE_READY: "scrollPageReady",
+    UPDATE_SCROLL_PAGE_DIMENSIONS_READY: "trv.UPDATE_SCROLL_PAGE_DIMENSIONS_READY",
+    MISSING_OR_INVALID_PARAMETERS: "missingOrInvalidParameters",
+    RENDERING_STOPPED: "renderingStopped"
+  };
+  extend(
+    controller,
+    {
+      getPageData: function(pageNumber) {
+        if (loader) {
+          return loader.getPageData(pageNumber);
+        }
+        return;
+      },
+      getReportSource: function() {
+        if (report === null) {
+          return null;
+        }
+        return {
+          report,
+          parameters: extend({}, parameterValues)
+        };
+      },
+      setReportSource: function(rs) {
+        if (rs === null) {
+          report = parameterValues = null;
+          clearReportState();
+          changeReportSource(rs);
+          return this;
+        }
+        report = rs.report;
+        parameterValues = rs.parameters;
+        changeReportSource(rs);
+        return this;
+      },
+      updateSettings: function(settings2) {
+        options.settings = extend({}, settings2, options.settings);
+      },
+      clearReportSource: function() {
+        report = parameterValues = null;
+        clearReportState();
+        changeReportSource(void 0);
+        return this;
+      },
+      getReportDocumentId: function() {
+        return reportDocumentId;
+      },
+      setReportDocumentId: function(documentId) {
+        reportDocumentId = documentId;
+      },
+      setParameters: function(paramValues) {
+        parameterValues = paramValues;
+      },
+      setProcessedParameter: function(processedParamValues) {
+        processedParameterValues = processedParamValues;
+      },
+      getPageCount: function() {
+        return pageCount;
+      },
+      getCurrentPageNumber: function() {
+        return currentPageNumber;
+      },
+      setCurrentPageNumber: function(pageNo) {
+        var num = tryParseInt(pageNo);
+        if (num !== currentPageNumber) {
+          currentPageNumber = num;
+          changePageNumber(num);
+        }
+        return this;
+      },
+      getScale: function() {
+        return settings.getScale();
+      },
+      setScale: function(scale) {
+        if (settings.getScale() !== scale) {
+          settings.setScale(scale);
+          controller.scaleChanged(scale);
+          controller.setScaleMode(ScaleModes.SPECIFIC);
+        }
+        return controller;
+      },
+      getScaleMode: function() {
+        return settings.getScaleMode();
+      },
+      setScaleMode: function(scaleMode) {
+        if (settings.getScaleMode() !== scaleMode) {
+          settings.setScaleMode(scaleMode);
+          controller.scaleModeChanged(scaleMode);
+        }
+        return controller;
+      },
+      getViewMode: function() {
+        return viewMode;
+      },
+      setViewMode: function(vm) {
+        if (viewMode !== vm) {
+          viewMode = vm;
+          controller.viewModeChanged(vm);
+          if (report) {
+            controller.refreshReportCore(false, reportDocumentId);
+          }
+        }
+        return controller;
+      },
+      getPageMode: function() {
+        return pageMode;
+      },
+      setPageMode: function(psm) {
+        if (pageMode !== psm) {
+          pageMode = psm;
+          controller.pageModeChanged(psm);
+          if (report) {
+            controller.refreshReportCore(false, reportDocumentId);
+          }
+        }
+        return controller;
+      },
+      getPrintMode: function() {
+        return printMode;
+      },
+      setPrintMode: function(pm) {
+        if (printMode !== pm) {
+          printMode = pm;
+          controller.printModeChanged(pm);
+        }
+        return controller;
+      },
+      previewReport: function(ignoreCache, baseDocumentId, actionId) {
+        controller.loadedReportChange();
+        controller.refreshReportCore(ignoreCache, baseDocumentId, actionId);
+      },
+      refreshReportCore: function(ignoreCache, baseDocumentId, actionId) {
+        loadReportAsync(ignoreCache, baseDocumentId, actionId);
+      },
+      stopRendering: function() {
+        throwIfNoReport();
+        throwIfNoReportInstance();
+        throwIfNoReportDocument();
+        client.deleteReportDocument(clientId, reportInstanceId, reportDocumentId).catch(handleRequestError).then(function() {
+          if (loader) {
+            loader.cancel();
+          }
+          resetPageNumbers();
+          controller.renderingStopped();
+        });
+      },
+      getReportParameters: function() {
+        var paramsToBeExposed = {};
+        for (var key in processedParameterValues) {
+          var processedParam = processedParameterValues[key];
+          var paramValue = parameterValues[key];
+          if (processedParam && processedParam.availableValues) {
+            if (processedParam.multivalue) {
+              paramsToBeExposed[key] = addMultiComboParam(processedParam, paramValue, key);
+            } else {
+              paramsToBeExposed[key] = addSingleComboParam(processedParam, paramValue, key);
+            }
+          } else {
+            paramsToBeExposed[key] = paramValue;
+          }
+        }
+        return paramsToBeExposed;
+      },
+      refreshReport: function(ignoreCache, baseDocumentId, actionId) {
+        controller.loadedReportChange();
+        if (clientHasExpired) {
+          clientHasExpired = false;
+          clearClientId();
+        }
+        if (!report) {
+          controller.raiseError(stringResources.noReport);
+          return;
+        }
+        var loadParametersPromise = controller.loadParameters(null);
+        loadParametersPromise.then(function(parameters) {
+          var parameterValues2 = {};
+          var invalidParameters = [];
+          var hasError = false;
+          each(parameters || [], function() {
+            try {
+              var value = parameterValidators.validate(this, this.value);
+              parameterValues2[this.id] = value;
+            } catch (e) {
+              hasError = true;
+              invalidParameters.push(this);
+              return;
+            }
+          });
+          if (hasError) {
+            controller.raiseError(stringResources.missingOrInvalidParameter);
+            appendInvalidReportParameterNames(invalidParameters);
+            controller.missingOrInvalidParameters();
+          } else {
+            controller.setParameters(parameterValues2);
+            controller.refreshReportCore(ignoreCache, baseDocumentId, actionId);
+          }
+        });
+        controller.reloadParameters(loadParametersPromise);
+      },
+      exportReport: function(format, deviceInfo) {
+        exportReport(format, deviceInfo);
+      },
+      sendReport: function(args) {
+        sendReport(args);
+      },
+      printReport: function() {
+        printReport();
+      },
+      getReportPage: function(pageNumber) {
+        getReportPage(pageNumber);
+      },
+      executeReportAction: function(interactiveActionArgs) {
+        executeReportAction(interactiveActionArgs);
+      },
+      reportActionEnter: function(args) {
+        onReportActionEnter(args);
+      },
+      reportActionLeave: function(args) {
+        onReportActionLeave(args);
+      },
+      reportToolTipOpening: function(args) {
+        onReportToolTipOpening(args);
+      },
+      loadParameters: function(paramValues) {
+        if (report === null) {
+          return {};
+        }
+        controller.beforeLoadParameters(paramValues === null);
+        return loadParametersAsync(report, paramValues);
+      },
+      getDocumentFormats: function() {
+        return getDocumentFormatsAsync();
+      },
+      getServiceVersion: function() {
+        return getServiceVersionAsync();
+      },
+      setAuthenticationToken: function(token) {
+        client.setAccessToken(token);
+      },
+      clientId: function() {
+        return clientId;
+      },
+      onReportLoadComplete: function(info) {
+        pageCount = info.pageCount;
+        bookmarkNodes = info.bookmarkNodes;
+        renderingExtensions = info.renderingExtensions;
+        setStateReportSource(controller.getReportSource());
+        controller.reportLoadComplete(info);
+      },
+      raiseError: function(...args) {
+        var errorMessage = formatError(args);
+        controller.error(errorMessage);
+      },
+      getSearchResults: function(args, results) {
+        return getSearchResultsAsync(args);
+      },
+      // --- E V E N T S ---
+      on: function(eventName, handler) {
+        eventEmitter.on(eventName, handler);
+        return controller;
+      },
+      trigger: function(eventName, args) {
+        eventEmitter.trigger(eventName, args);
+        return controller;
+      },
+      showNotification: function(...args) {
+        return eventFactory(controller.Events.SHOW_NOTIFICATION, args);
+      },
+      hideNotification: function(...args) {
+        return eventFactory(controller.Events.HIDE_NOTIFICATION, args);
+      },
+      setUIState: function(...args) {
+        return eventFactory(controller.Events.UI_STATE, args);
+      },
+      error: function(...args) {
+        return eventFactory(controller.Events.ERROR, args);
+      },
+      reloadParameters: function(...args) {
+        return eventFactory(controller.Events.RELOAD_PARAMETERS, args);
+      },
+      exportStarted: function(...args) {
+        return eventFactory(controller.Events.EXPORT_STARTED, args);
+      },
+      exportReady: function(...args) {
+        return eventFactory(controller.Events.EXPORT_DOCUMENT_READY, args);
+      },
+      sendEmailStarted: function(...args) {
+        return eventFactory(controller.Events.SEND_EMAIL_STARTED, args);
+      },
+      sendEmailReady: function(...args) {
+        return eventFactory(controller.Events.SEND_EMAIL_READY, args);
+      },
+      printStarted: function(...args) {
+        return eventFactory(controller.Events.PRINT_STARTED, args);
+      },
+      printReady: function(...args) {
+        return eventFactory(controller.Events.PRINT_DOCUMENT_READY, args);
+      },
+      beforeLoadParameters: function(...args) {
+        return eventFactory(controller.Events.BEFORE_LOAD_PARAMETERS, args);
+      },
+      loadedReportChange: function(...args) {
+        return eventFactory(controller.Events.LOADED_REPORT_CHANGE, args);
+      },
+      beforeLoadReport: function(...args) {
+        return eventFactory(controller.Events.BEFORE_LOAD_REPORT, args);
+      },
+      beginLoadReport: function(...args) {
+        return eventFactory(controller.Events.BEGIN_LOAD_REPORT, args);
+      },
+      reportLoadComplete: function(...args) {
+        return eventFactory(controller.Events.REPORT_LOAD_COMPLETE, args);
+      },
+      reportLoadProgress: function(...args) {
+        return eventFactory(controller.Events.REPORT_LOAD_PROGRESS, args);
+      },
+      reportLoadFail: function(...args) {
+        return eventFactory(controller.Events.REPORT_LOAD_FAIL, args);
+      },
+      beginLoadPage: function(...args) {
+        return eventFactory(controller.Events.BEGIN_LOAD_PAGE, args);
+      },
+      pageReady: function(...args) {
+        return eventFactory(controller.Events.PAGE_READY, args);
+      },
+      viewModeChanged: function(...args) {
+        return eventFactory(controller.Events.VIEW_MODE_CHANGED, args);
+      },
+      pageModeChanged: function(...args) {
+        return eventFactory(controller.Events.PAGE_MODE_CHANGED, args);
+      },
+      printModeChanged: function(...args) {
+        return eventFactory(controller.Events.PRINT_MODE_CHANGED, args);
+      },
+      reportSourceChanged: function(...args) {
+        return eventFactory(controller.Events.REPORT_SOURCE_CHANGED, args);
+      },
+      navigateToPage: function(...args) {
+        return eventFactory(controller.Events.NAVIGATE_TO_PAGE, args);
+      },
+      currentPageChanged: function(...args) {
+        return eventFactory(controller.Events.CURRENT_PAGE_CHANGED, args);
+      },
+      getDocumentMapState: function(...args) {
+        return eventFactory(controller.Events.GET_DOCUMENT_MAP_STATE, args);
+      },
+      setDocumentMapVisible: function(...args) {
+        return eventFactory(controller.Events.SET_DOCUMENT_MAP_VISIBLE, args);
+      },
+      getParametersAreaState: function(...args) {
+        return eventFactory(controller.Events.GET_PARAMETER_AREA_STATE, args);
+      },
+      setParametersAreaVisible: function(...args) {
+        return eventFactory(controller.Events.SET_PARAMETER_AREA_VISIBLE, args);
+      },
+      setSideMenuVisible: function(...args) {
+        return eventFactory(controller.Events.SET_TOGGLE_SIDE_MENU, args);
+      },
+      getSideMenuVisible: function(...args) {
+        return eventFactory(controller.Events.GET_TOGGLE_SIDE_MENU, args);
+      },
+      scaleChanged: function(...args) {
+        return eventFactory(controller.Events.SCALE_CHANGED, args);
+      },
+      scaleModeChanged: function(...args) {
+        return eventFactory(controller.Events.SCALE_MODE_CHANGED, args);
+      },
+      serverActionStarted: function(...args) {
+        return eventFactory(controller.Events.SERVER_ACTION_STARTED, args);
+      },
+      cssLoaded: function(...args) {
+        return eventFactory(controller.Events.CSS_LOADED, args);
+      },
+      interactiveActionExecuting: function(...args) {
+        return eventFactory(controller.Events.INTERACTIVE_ACTION_EXECUTING, args);
+      },
+      interactiveActionEnter: function(...args) {
+        return eventFactory(controller.Events.INTERACTIVE_ACTION_ENTER, args);
+      },
+      interactiveActionLeave: function(...args) {
+        return eventFactory(controller.Events.INTERACTIVE_ACTION_LEAVE, args);
+      },
+      updateUI: function(...args) {
+        return eventFactory(controller.Events.UPDATE_UI, args);
+      },
+      updateUIInternal: function(...args) {
+        return eventFactory(controller.Events.UPDATE_UI_INTERNAL, args);
+      },
+      toolTipOpening: function(...args) {
+        return eventFactory(controller.Events.TOOLTIP_OPENING, args);
+      },
+      pageNumberChange: function(...args) {
+        return eventFactory(controller.Events.PAGE_NUMBER, args);
+      },
+      pageCountChange: function(...args) {
+        return eventFactory(controller.Events.PAGE_COUNT, args);
+      },
+      getSearchDialogState: function(...args) {
+        return eventFactory(controller.Events.GET_SEARCH_DIALOG_STATE, args);
+      },
+      getSendEmailDialogState: function(...args) {
+        return eventFactory(controller.Events.GET_SEND_EMAIL_DIALOG_STATE, args);
+      },
+      setSearchDialogVisible: function(...args) {
+        return eventFactory(controller.Events.SET_SEARCH_DIALOG_VISIBLE, args);
+      },
+      setSendEmailDialogVisible: function(...args) {
+        return eventFactory(controller.Events.SET_SEND_EMAIL_DIALOG_VISIBLE, args);
+      },
+      scrollPageReady: function(...args) {
+        return eventFactory(controller.Events.SCROLL_PAGE_READY, args);
+      },
+      updatePageDimensionsReady: function(...args) {
+        return eventFactory(controller.Events.UPDATE_SCROLL_PAGE_DIMENSIONS_READY, args);
+      },
+      missingOrInvalidParameters: function(...args) {
+        return eventFactory(controller.Events.MISSING_OR_INVALID_PARAMETERS, args);
+      },
+      renderingStopped: function(...args) {
+        return eventFactory(controller.Events.RENDERING_STOPPED, args);
+      },
+      clientExpired: function(...args) {
+        return eventFactory(controller.Events.CLIENT_EXPIRED, args);
+      },
+      dispose: function() {
+        stopSentinel();
+        this.serviceClientSentinel = null;
+      }
+    }
+  );
+  return controller;
+}
+function addSingleComboParam(processedParam, paramValue, key) {
+  try {
+    var nameValuePair = processedParam.availableValues.find((obj) => {
+      return obj["value"] === paramValue;
+    });
+    if (!nameValuePair) {
+      throw new Error(`The available values of parameter ${key} do not contain Value property that equals ${paramValue}`);
+    }
+    return { valueMember: paramValue, displayMember: nameValuePair["name"] };
+  } catch (e) {
+    logError(e);
+  }
+}
+function addMultiComboParam(processedParam, paramValue, key) {
+  var paramArr = [];
+  for (var i in paramValue) {
+    paramArr.push(addSingleComboParam(processedParam, paramValue[i], key));
+  }
+  return paramArr;
+}
+
+export { ReportViewerController };