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

package/dist/cjs/template-cache.js

@@ -0,0 +1,39 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var utils = require('./utils.js');
+
+const TemplateCache = function() {
+  var cache = {};
+  return {
+    load: function(url, serviceUrl, client) {
+      var p = cache[url];
+      if (!p) {
+        cache[url] = p = client.get(url).then(function(html) {
+          var templates = {};
+          var styleSheets = [];
+          var baseUri = utils.rTrim(serviceUrl, "\\/") + "/";
+          html = utils.replaceAll(html, "{service}/", baseUri);
+          html = utils.replaceAll(html, "{service}", baseUri);
+          var viewerTemplate = $("<div></div>").html(html);
+          utils.each(viewerTemplate.find("template"), function(index, e) {
+            var $e = $(e);
+            templates[$e.attr("id")] = utils.trim($e.html(), "\n 	");
+          });
+          utils.each(viewerTemplate.find("link"), function(index, e) {
+            styleSheets.push(utils.trim(e.outerHTML, "\n 	"));
+          });
+          styleSheets = utils.filterUniqueLastOccurance(styleSheets);
+          return {
+            templates,
+            styleSheets
+          };
+        });
+      }
+      return p;
+    }
+  };
+}();
+
+exports.TemplateCache = TemplateCache;

package/dist/cjs/touch.js

@@ -0,0 +1,86 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+function TouchBehavior(dom, options) {
+  var startDistance;
+  var ignoreTouch;
+  init(dom);
+  function init(element) {
+    if (typeof $.fn.kendoTouch === "function") {
+      try {
+        $(element).mousedown(function() {
+          ignoreTouch = true;
+        }).mouseup(function() {
+          ignoreTouch = false;
+        }).kendoTouch({
+          multiTouch: true,
+          enableSwipe: true,
+          swipe: function(e) {
+            if (!ignoreTouch) {
+              onSwipe(e);
+            }
+          },
+          gesturestart: function(e) {
+            if (!ignoreTouch) {
+              onGestureStart(e);
+            }
+          },
+          gestureend: function(e) {
+            if (!ignoreTouch) {
+              onGestureEnd(e);
+            }
+          },
+          gesturechange: function(e) {
+            if (!ignoreTouch) {
+              onGestureChange(e);
+            }
+          },
+          doubletap: function(e) {
+            if (!ignoreTouch) {
+              onDoubleTap(e);
+            }
+          },
+          touchstart: function(e) {
+            if (!ignoreTouch) {
+              fire("touchstart");
+            }
+          }
+        });
+      } catch (e) {
+        console.error("Instantiation of Kendo Touch threw an exception", e);
+        throw e;
+      }
+    }
+  }
+  function onDoubleTap(e) {
+    fire("doubletap", e);
+  }
+  function onGestureStart(e) {
+    startDistance = kendo.touchDelta(e.touches[0], e.touches[1]).distance;
+  }
+  function onGestureEnd(e) {
+  }
+  function onGestureChange(e) {
+    var current = kendo.touchDelta(e.touches[0], e.touches[1]).distance;
+    onPinch({
+      distance: current,
+      lastDistance: startDistance
+    });
+    startDistance = current;
+  }
+  function onSwipe(e) {
+    fire("swipe", e);
+  }
+  function onPinch(e) {
+    fire("pinch", e);
+  }
+  function fire(func, args) {
+    var handler = options[func];
+    if (typeof handler === "function") {
+      handler(args);
+    }
+  }
+}
+
+exports.TouchBehavior = TouchBehavior;

package/dist/cjs/uiController.js

@@ -0,0 +1,142 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var enums = require('./enums.js');
+
+function UIController(options) {
+  var stateFlags = {
+    ExportInProgress: 1 << 0,
+    PrintInProgress: 1 << 1,
+    RenderInProgress: 1 << 2
+  };
+  function getState(flags) {
+    return (state & flags) != 0;
+  }
+  function setState(flags, value) {
+    if (value) {
+      state |= flags;
+    } else {
+      state &= ~flags;
+    }
+  }
+  var controller = options.controller;
+  var historyManager = options.history;
+  var state = 0;
+  var refreshUI;
+  var commands = options.commands;
+  if (!controller) {
+    throw "No controller (telerikReporting.ReportViewerController) has been specified.";
+  }
+  function getDocumentMapState() {
+    var args = {};
+    controller.getDocumentMapState(args);
+    return args;
+  }
+  function getParametersAreaState() {
+    var args = {};
+    controller.getParametersAreaState(args);
+    return args;
+  }
+  function getSearchDialogState() {
+    var args = {};
+    controller.getSearchDialogState(args);
+    return args;
+  }
+  function getSendEmailDialogState() {
+    var args = {};
+    controller.getSendEmailDialogState(args);
+    return args;
+  }
+  function updateUI() {
+    if (!refreshUI) {
+      refreshUI = true;
+      window.setTimeout(function() {
+        try {
+          updateUICore();
+        } finally {
+          refreshUI = false;
+        }
+      }, 10);
+    }
+  }
+  function updateUICore() {
+    var rs = controller.getReportSource();
+    var pageCount = controller.getPageCount();
+    var currentPageNumber = controller.getCurrentPageNumber();
+    var hasReport = rs && rs.report;
+    var hasPages = hasReport && pageCount > 0;
+    var nextPage = hasPages && currentPageNumber < pageCount;
+    var prevPage = hasPages && currentPageNumber > 1;
+    var hasPage = hasPages && currentPageNumber;
+    var documentMapState = getDocumentMapState();
+    var parametersAreaState = getParametersAreaState();
+    var searchDialogState = getSearchDialogState();
+    var sendEmailDialogState = getSendEmailDialogState();
+    var renderInProgress = getState(stateFlags.RenderInProgress);
+    var printInProgress = getState(stateFlags.PrintInProgress);
+    var exportInProgress = getState(stateFlags.ExportInProgress);
+    commands.goToFirstPage.enabled(prevPage);
+    commands.goToPrevPage.enabled(prevPage);
+    commands.stopRendering.enabled(hasReport && renderInProgress);
+    commands.goToLastPage.enabled(nextPage);
+    commands.goToNextPage.enabled(nextPage);
+    commands.goToPage.enabled(hasPages);
+    commands.print.enabled(hasPages && !renderInProgress && !printInProgress);
+    commands.export.enabled(hasPages && !renderInProgress && !exportInProgress);
+    commands.refresh.enabled(hasReport);
+    commands.historyBack.enabled(historyManager && historyManager.canMoveBack());
+    commands.historyForward.enabled(historyManager && historyManager.canMoveForward());
+    commands.toggleDocumentMap.enabled(hasReport && documentMapState.enabled).checked(documentMapState.enabled && documentMapState.visible);
+    commands.toggleParametersArea.enabled(hasReport && parametersAreaState.enabled).checked(parametersAreaState.enabled && parametersAreaState.visible);
+    commands.togglePrintPreview.enabled(hasPages).checked(controller.getViewMode() == enums.ViewModes.PRINT_PREVIEW);
+    commands.pageMode.enabled(hasPages).checked(controller.getPageMode() == enums.PageModes.CONTINUOUS_SCROLL);
+    commands.zoom.enabled(hasPage);
+    commands.zoomIn.enabled(hasPage);
+    commands.zoomOut.enabled(hasPage);
+    commands.toggleZoomMode.enabled(hasPage).checked(controller.getScaleMode() == enums.ScaleModes.FIT_PAGE || controller.getScaleMode() == enums.ScaleModes.FIT_PAGE_WIDTH);
+    commands.toggleSearchDialog.enabled(hasPages).checked(searchDialogState.visible);
+    commands.toggleSendEmailDialog.enabled(hasPages).checked(sendEmailDialogState.visible);
+    controller.updateUI(null);
+    controller.pageNumberChange(currentPageNumber);
+    controller.pageCountChange(pageCount);
+  }
+  controller.setParametersAreaVisible(updateUI);
+  controller.setDocumentMapVisible(updateUI);
+  controller.updateUIInternal(updateUI);
+  controller.setSearchDialogVisible(updateUI);
+  controller.setSendEmailDialogVisible(updateUI);
+  controller.scaleModeChanged(updateUI);
+  controller.currentPageChanged(updateUI);
+  controller.beforeLoadReport(function() {
+    setState(stateFlags.RenderInProgress, true);
+    updateUI();
+  });
+  controller.reportLoadProgress(updateUI);
+  controller.reportLoadComplete(function() {
+    setState(stateFlags.RenderInProgress, false);
+    updateUI();
+  });
+  controller.reportSourceChanged(updateUI);
+  controller.viewModeChanged(updateUI);
+  controller.pageModeChanged(function() {
+    updateUI();
+  });
+  controller.setUIState(function(event, args) {
+    setState(stateFlags[args.operationName], args.inProgress);
+    updateUI();
+  });
+  controller.error(function() {
+    setState(stateFlags.ExportInProgress, false);
+    setState(stateFlags.PrintInProgress, false);
+    setState(stateFlags.RenderInProgress, false);
+    updateUI();
+  });
+  controller.renderingStopped(function() {
+    setState(stateFlags.RenderInProgress, false);
+    updateUI();
+  });
+  updateUI();
+}
+
+exports.UIController = UIController;

package/dist/cjs/uiFreezeCoordinator.js

@@ -0,0 +1,281 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var utils = require('./utils.js');
+
+var UIFreezeCoordinator = {
+  $placeholder: null,
+  $scrollableContainer: null,
+  itemsInitialState: {},
+  // Holds all items initial position per container
+  xFrozenAreasBounds: {},
+  //Holds the bounds of the frozen areas by X per container
+  yFrozenAreasBounds: {},
+  //Holds the bounds of the frozen areas by Y per container
+  freezeMaxZIndex: {},
+  zIndex: 1,
+  freezeBGColor: {},
+  // Holds default background-color value per container
+  currentlyfreezedContainer: {
+    vertical: {},
+    horizontal: {}
+  },
+  //Holds whether freezing has been applied per container.
+  isInitialize: false,
+  scaleFactor: null,
+  /**
+   * Initialize the uiFreezeCoordinator object
+   * Takes one parameter
+   *  - $placeholder - PageArea jQuery DOM element
+   */
+  init: function($placeholder) {
+    this.$placeholder = $placeholder;
+    this.$scrollableContainer = $placeholder.find(".trv-page-container");
+    if (this.isInitialize) {
+      this.reset($placeholder);
+    }
+    this._attachToScrollEvent();
+    this.isInitialize = true;
+  },
+  reset: function($placeholder) {
+    this.$placeholder = $placeholder;
+    this.$scrollableContainer = $placeholder.find(".trv-page-container");
+    this.itemsInitialState = {};
+    this.xFrozenAreasBounds = {};
+    this.yFrozenAreasBounds = {};
+    this.currentlyfreezedContainer = {
+      vertical: {},
+      horizontal: {}
+    };
+  },
+  setScaleFactor: function(scale) {
+    this.scaleFactor = scale;
+  },
+  /**
+   * Initializing scroll listener
+   */
+  _attachToScrollEvent: function() {
+    var thisInstance = this;
+    this.$scrollableContainer.scroll(function updateFreezeUIOnScroll() {
+      var $freezeItems = thisInstance.$scrollableContainer.find("div[data-sticky-id]");
+      if ($freezeItems.length) {
+        var tableIDs = $freezeItems.map(function(index2, $element) {
+          return $($element).attr("data-sticky-id");
+        }).get();
+        var uniqueIDs = tableIDs.filter(function(item, index2) {
+          return index2 === tableIDs.indexOf(item);
+        });
+        var scrollableContainerScrollTop = thisInstance.$scrollableContainer.scrollTop();
+        var scrollableContainerScrollLeft = thisInstance.$scrollableContainer.scrollLeft();
+        for (var index = 0; index < uniqueIDs.length; index++) {
+          var freezeItemsContainerID = uniqueIDs[index];
+          if (!thisInstance.itemsInitialState[freezeItemsContainerID]) {
+            thisInstance._saveFreezeItemsInitialState(freezeItemsContainerID);
+          }
+          thisInstance._updateFreezeItemsOnScroll(
+            freezeItemsContainerID,
+            scrollableContainerScrollTop,
+            scrollableContainerScrollLeft
+          );
+        }
+      }
+    });
+  },
+  _saveFreezeItemsInitialState: function(freezeItemsContainerID) {
+    var $allFreezeItems = $("[data-sticky-direction][data-sticky-id='" + freezeItemsContainerID + "']");
+    var $freezeActions = $("[data-reporting-action][data-sticky-id='" + freezeItemsContainerID + "']");
+    var yAreaBounds;
+    var xAreaBounds;
+    this.itemsInitialState[freezeItemsContainerID] = {};
+    this.freezeBGColor[freezeItemsContainerID] = $("[data-id='" + freezeItemsContainerID + "']").attr("data-sticky-bg-color");
+    for (var index = 0; index < $allFreezeItems.length; index++) {
+      var $item = $($allFreezeItems[index]);
+      var scrollDirection = $item.attr("data-sticky-direction");
+      var itemID = $item.attr("data-id");
+      var itemPosition = $item.position();
+      var scaledItemPosition = { top: itemPosition.top / this.scaleFactor, left: itemPosition.left / this.scaleFactor };
+      var itemBounds = utils.rectangle(scaledItemPosition.left, scaledItemPosition.top, $item.outerWidth(true) * this.scaleFactor, $item.outerHeight(true) * this.scaleFactor);
+      switch (scrollDirection) {
+        case "Vertical":
+          yAreaBounds = yAreaBounds ? yAreaBounds.union(itemBounds) : itemBounds;
+          break;
+        case "Horizontal":
+          xAreaBounds = xAreaBounds ? xAreaBounds.union(itemBounds) : itemBounds;
+          break;
+      }
+      this._saveFreezeItemInitialState(freezeItemsContainerID, $item, itemID, scaledItemPosition);
+    }
+    this.freezeMaxZIndex[freezeItemsContainerID] = $freezeActions.length ? $freezeActions.css("zIndex") : this.zIndex;
+    this.yFrozenAreasBounds[freezeItemsContainerID] = yAreaBounds;
+    this.xFrozenAreasBounds[freezeItemsContainerID] = xAreaBounds;
+  },
+  /**
+   * Save the freeze UI item initial position based on the wrapper element and current page
+   *  - freezeItemsContainerID - string. A parent/wrapper element identifier
+   *  - $item - JQuery DOM element of the freezed item
+   *  - itemID - string. A ID of the freeze UI item
+   *  - position - object. Contains the top and left values
+   */
+  _saveFreezeItemInitialState: function(freezeItemsContainerID, $item, itemID, position) {
+    var itemBgColor = $item.css("background-color");
+    var hasInitialBgColor = this._hasSetBgColor(itemBgColor);
+    var itemState = {
+      top: position.top,
+      left: position.left,
+      zIndex: $item.css("zIndex"),
+      hasBgColor: hasInitialBgColor
+    };
+    this.itemsInitialState[freezeItemsContainerID][itemID] = itemState;
+  },
+  _updateFreezeItemsOnScroll: function(freezeItemsContainerID, scrollableContainerScrollTop, scrollableContainerScrollLeft) {
+    var $elementWrapper = $("div[data-id='" + freezeItemsContainerID + "']");
+    if (this._isInScrollVisibleArea($elementWrapper)) {
+      var $pageContainer = $elementWrapper.closest(".trv-report-page");
+      var pageContainerPosition = $pageContainer.position();
+      var pageContainerMargin = parseFloat($pageContainer.css("margin-top"));
+      var pageContainerTopOffset = parseFloat($pageContainer.css("padding-top"));
+      var pageContainerLeftOffset = parseFloat($pageContainer.css("padding-left"));
+      var pageContainerBorderTopWidth = parseFloat($pageContainer.css("border-top-width"));
+      var pageContainerBorderLeftWidth = parseFloat($pageContainer.css("border-left-width"));
+      var $rowHeaders = $("[data-sticky-direction*='Horizontal'][data-sticky-id='" + freezeItemsContainerID + "']");
+      var $colHeaders = $("[data-sticky-direction*='Vertical'][data-sticky-id='" + freezeItemsContainerID + "']");
+      var hasFixRow = $rowHeaders.length > 0;
+      var hasFixColumn = $colHeaders.length > 0;
+      var elementWrapperPosition = $elementWrapper.position();
+      var elementWrapperTopPosition = elementWrapperPosition.top + pageContainerPosition.top + pageContainerMargin + pageContainerTopOffset + pageContainerBorderTopWidth;
+      var elementWrapperLeftPosition = elementWrapperPosition.left + pageContainerLeftOffset + pageContainerBorderLeftWidth;
+      var verticalMoveOffset = scrollableContainerScrollTop - elementWrapperTopPosition;
+      var horizontalMoveOffset = scrollableContainerScrollLeft - elementWrapperLeftPosition;
+      if (hasFixColumn && verticalMoveOffset > 0) {
+        if (scrollableContainerScrollTop <= $elementWrapper.outerHeight() * this.scaleFactor + elementWrapperTopPosition - this.yFrozenAreasBounds[freezeItemsContainerID].height) {
+          this.currentlyfreezedContainer.vertical[freezeItemsContainerID] = true;
+          this._updateUIElementsPosition($colHeaders, "top", verticalMoveOffset / this.scaleFactor, freezeItemsContainerID);
+        }
+      } else {
+        if (this.currentlyfreezedContainer.vertical[freezeItemsContainerID]) {
+          delete this.currentlyfreezedContainer.vertical[freezeItemsContainerID];
+          this._updateUIElementsPosition($colHeaders, "top", -1, freezeItemsContainerID);
+        }
+      }
+      if (hasFixRow && horizontalMoveOffset > 0) {
+        if (scrollableContainerScrollLeft <= $elementWrapper.outerWidth() * this.scaleFactor + elementWrapperLeftPosition - this.xFrozenAreasBounds[freezeItemsContainerID].width) {
+          this.currentlyfreezedContainer.horizontal[freezeItemsContainerID] = true;
+          this._updateUIElementsPosition($rowHeaders, "left", horizontalMoveOffset / this.scaleFactor, freezeItemsContainerID);
+        }
+      } else {
+        if (this.currentlyfreezedContainer.horizontal[freezeItemsContainerID]) {
+          delete this.currentlyfreezedContainer.horizontal[freezeItemsContainerID];
+          this._updateUIElementsPosition($rowHeaders, "left", -1, freezeItemsContainerID);
+        }
+      }
+    } else {
+      if (this.currentlyfreezedContainer.horizontal[freezeItemsContainerID] || this.currentlyfreezedContainer.vertical[freezeItemsContainerID]) {
+        this._resetToDefaultPosition(freezeItemsContainerID);
+      }
+    }
+  },
+  /**
+   * Move all freeze items to their initial position
+   * Takes one parameters
+   *  - freezeItemsContainerID - string. A parent/wrapper element identifier
+   */
+  _resetToDefaultPosition: function(freezeItemsContainerID) {
+    var $rowHeaders = $("[data-sticky-direction*='Horizontal'][data-sticky-id='" + freezeItemsContainerID + "']");
+    var $colHeaders = $("[data-sticky-direction*='Vertical'][data-sticky-id='" + freezeItemsContainerID + "']");
+    this._updateUIElementsPosition($colHeaders, "top", -1, freezeItemsContainerID);
+    this._updateUIElementsPosition($rowHeaders, "left", -1, freezeItemsContainerID);
+    delete this.currentlyfreezedContainer.horizontal[freezeItemsContainerID];
+    delete this.currentlyfreezedContainer.vertical[freezeItemsContainerID];
+  },
+  /**
+   * Update the freeze elements position
+   * Takes four parameters
+   *  - targetElements -Array. Collection of DOM element, that has a freeze attribute
+   *  - position - string. Indicates which position property to be updated - top or left
+   *  - offset - integer. The value of the increase that should be applied.
+   *              If it is negative number, should not move the items and it should set their initial position
+   *  - freezeItemsContainerID - string. A parent/wrapper element identifier
+   */
+  _updateUIElementsPosition: function(targetElements, position, offset, freezeItemsContainerID) {
+    for (var index = 0; index < targetElements.length; index++) {
+      var $item = $(targetElements[index]);
+      var itemFreezeDirection = $item.attr("data-sticky-direction");
+      var isFrozenBothDirection = itemFreezeDirection.indexOf(",") > 0;
+      var itemID = $item.attr("data-id");
+      var itemInitialState = this.itemsInitialState[freezeItemsContainerID][itemID];
+      var itemNewPostion = itemInitialState[position];
+      var initialZIndex = itemInitialState["zIndex"];
+      var hasInitialBgColor = itemInitialState["hasBgColor"];
+      var zIndexValue = 1;
+      var maxZIndex = this.freezeMaxZIndex[freezeItemsContainerID] ? this.freezeMaxZIndex[freezeItemsContainerID] : zIndexValue;
+      if (isFrozenBothDirection) {
+        zIndexValue = initialZIndex !== "auto" ? initialZIndex : maxZIndex + 2;
+      } else {
+        zIndexValue = initialZIndex !== "auto" ? initialZIndex + 1 : maxZIndex;
+      }
+      var newStyleRules = {
+        "z-index": zIndexValue
+      };
+      if (offset >= 0) {
+        itemNewPostion = itemNewPostion + offset;
+      } else {
+        newStyleRules["z-index"] = initialZIndex;
+      }
+      if (!hasInitialBgColor) {
+        this._applyBgColorOnScroll($item, isFrozenBothDirection, hasInitialBgColor, offset >= 0, freezeItemsContainerID);
+      }
+      newStyleRules[position] = itemNewPostion + "px";
+      $item.css(newStyleRules);
+    }
+  },
+  _applyBgColorOnScroll: function($item, isItemFrozenBothDirection, hasInitialBgColor, shouldApplyBGColor, freezeItemsContainerID) {
+    if ($item.is("img")) {
+      return true;
+    }
+    if (isItemFrozenBothDirection && this._isFrozen(freezeItemsContainerID) && !hasInitialBgColor) {
+      $item.css("background-color", this.freezeBGColor[freezeItemsContainerID]);
+      return true;
+    }
+    if (shouldApplyBGColor) {
+      $item.css("background-color", this.freezeBGColor[freezeItemsContainerID]);
+    } else {
+      $item.css("background-color", "initial");
+    }
+  },
+  _hasSetBgColor: function(bgColorValue) {
+    return utils.getColorAlphaValue(bgColorValue) > 0;
+  },
+  _isFrozen: function(freezeItemsContainerID) {
+    return this.currentlyfreezedContainer.horizontal[freezeItemsContainerID] || this.currentlyfreezedContainer.vertical[freezeItemsContainerID];
+  },
+  /**
+   * Checks if an UI element is in the visible part of the scrollable container
+   * Takes one parameters
+   *  - $element - JQuery DOM element
+   */
+  _isInScrollVisibleArea: function($element) {
+    var $page = $element.closest(".trv-report-page");
+    var elementPosition = $element.position();
+    return this._isVisibleVertically($element, $page, elementPosition) && this._isVisibleHorizontally($element, $page, elementPosition);
+  },
+  _isVisibleHorizontally: function($element, $page, elementPosition) {
+    var pageLeftOffset = parseFloat($page.css("padding-left"));
+    var scrollableContainerLeftScrollPosition = this.$scrollableContainer.scrollLeft();
+    var scrollableContainerWidth = this.$scrollableContainer.width();
+    var elementWidth = $element.outerWidth(true) * this.scaleFactor;
+    var elementLeftOffset = elementPosition.left + pageLeftOffset;
+    return elementLeftOffset > scrollableContainerLeftScrollPosition - elementWidth && elementLeftOffset < scrollableContainerLeftScrollPosition + elementWidth + scrollableContainerWidth;
+  },
+  _isVisibleVertically: function($element, $page, elementPosition) {
+    var pageTopOffset = parseFloat($page.css("padding-top"));
+    var pagePosition = $page.position();
+    var scrollableContainerTopScrollPosition = this.$scrollableContainer.scrollTop();
+    var scrollableContainerHeight = this.$scrollableContainer.height();
+    var elementHeight = $element.outerHeight(true) * this.scaleFactor;
+    var elementTopOffset = elementPosition.top + pageTopOffset + pagePosition.top;
+    return elementTopOffset > scrollableContainerTopScrollPosition - elementHeight && elementTopOffset < scrollableContainerTopScrollPosition + elementHeight + scrollableContainerHeight;
+  }
+};
+
+exports.UIFreezeCoordinator = UIFreezeCoordinator;