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

package/dist/es/documentMapArea.js

@@ -0,0 +1,155 @@
+import { stringResources } from './stringResources.js';
+import { DocumentMapAreaPositions } from './enums.js';
+import { GlobalSettings } from './globalSettings.js';
+
+var defaultOptions = {};
+function DocumentMapArea(placeholder, options, otherOptions) {
+  options = $.extend({}, defaultOptions, options, otherOptions);
+  var controller = options.controller;
+  if (!controller) {
+    throw "No controller (telerikReporting.reportViewerController) has been specified.";
+  }
+  var $placeholder = $(placeholder);
+  var $documentMap;
+  var documentMapVisible = options.documentMapVisible !== false;
+  var enableAccessibility = options.enableAccessibility;
+  var currentReport = null;
+  var documentMapNecessary = false;
+  init();
+  function init() {
+    $documentMap = $('<div id="' + options.viewerSelector + '-documentMap"></div>');
+    $documentMap.appendTo(placeholder);
+    attach();
+    replaceStringResources($placeholder);
+  }
+  function onTreeViewSelectionChanged(e) {
+    var documentMapNode = this.dataItem(e.node);
+    var page = documentMapNode.page;
+    var id = documentMapNode.id;
+    controller.navigateToPage(page, {
+      type: "bookmark",
+      id
+    });
+  }
+  function onTreeViewNodeExpand(e) {
+    if (enableAccessibility) {
+      window.setTimeout(function() {
+        setNodeAccessibilityAttributes(e.node);
+      }, 100);
+    }
+  }
+  function setNodeAccessibilityAttributes(node) {
+    var $items = $(node).find("li");
+    Array.from($items).forEach((item) => {
+      var $li = $(item);
+      $li.attr("aria-label", $li[0].innerText);
+    });
+  }
+  function clearDocumentMap() {
+    displayDocumentMap([]);
+  }
+  function displayDocumentMap(documentMap) {
+    var hasDocumentMap = documentMap && !$.isEmptyObject(documentMap);
+    var $treeView = $documentMap.data("kendoTreeView");
+    if (!$treeView) {
+      try {
+        $documentMap.kendoTreeView({
+          dataTextField: "text",
+          select: onTreeViewSelectionChanged
+        });
+        $treeView = $documentMap.data("kendoTreeView");
+      } catch (e) {
+        console.error("Instantiation of Kendo TreeView as Document Map threw an exception", e);
+        throw e;
+      }
+    }
+    $treeView.setDataSource(documentMap);
+    if (enableAccessibility) {
+      setAccessibilityAttributes($treeView);
+    }
+    showDocumentMap(hasDocumentMap);
+  }
+  function setAccessibilityAttributes(treeView) {
+    treeView.bind("expand", onTreeViewNodeExpand);
+    treeView.element.attr("aria-label", stringResources.ariaLabelDocumentMap);
+    var listItems = treeView.element.find("ul");
+    Array.from(listItems).forEach((list) => {
+      setNodeAccessibilityAttributes(list);
+    });
+    if (documentMapNecessary) {
+      setSplitbarAccessibilityAttributes();
+    }
+  }
+  function setSplitbarAccessibilityAttributes() {
+    var splitbar = $placeholder.next();
+    if (options.documentMapAreaPosition === DocumentMapAreaPositions.RIGHT) {
+      splitbar = $placeholder.prev();
+    }
+    splitbar.attr("aria-label", stringResources.ariaLabelDocumentMapSplitter);
+  }
+  function isVisible() {
+    var args = {};
+    controller.getDocumentMapState(args);
+    return args.visible;
+  }
+  function beginLoad() {
+    $placeholder.addClass("trv-loading");
+  }
+  function endLoad() {
+    $placeholder.removeClass("trv-loading");
+  }
+  function showDocumentMap(show) {
+    var splitter = GlobalSettings.viewerInstances.find((element) => element.id === options.viewerSelector + "-document-map-splitter").instance;
+    var sibling = $placeholder.next();
+    if (options.documentMapAreaPosition === DocumentMapAreaPositions.RIGHT) {
+      sibling = $placeholder.prev();
+    }
+    if (splitter) {
+      (documentMapNecessary ? $.fn.removeClass : $.fn.addClass).call(sibling, "trv-hidden");
+      splitter.toggle(".trv-document-map", show);
+    }
+  }
+  function attach() {
+    controller.beginLoadReport(function() {
+      beginLoad();
+      var r = controller.getReportSource().report;
+      var clearMapItems = currentReport !== r || !isVisible();
+      currentReport = r;
+      if (clearMapItems) {
+        clearDocumentMap();
+      }
+    }).reportLoadComplete(function(event, args) {
+      if (args.documentMapAvailable) {
+        documentMapNecessary = true;
+        displayDocumentMap(args.documentMapNodes);
+        controller.setDocumentMapVisible({ enabled: true, visible: documentMapVisible });
+      } else {
+        documentMapNecessary = false;
+        showDocumentMap(documentMapNecessary);
+      }
+      endLoad();
+    }).error(function(event, error) {
+      endLoad();
+      clearDocumentMap();
+    }).renderingStopped(function() {
+      documentMapNecessary = false;
+      showDocumentMap(false);
+    });
+    controller.setDocumentMapVisible(function(event, args) {
+      documentMapVisible = args.visible;
+      showDocumentMap(documentMapVisible && documentMapNecessary);
+    }).getDocumentMapState(function(event, args) {
+      args.enabled = documentMapNecessary;
+      args.visible = documentMapVisible;
+    });
+  }
+  function replaceStringResources($documentMap2) {
+    var $documentMapOverlay = $documentMap2.find(".trv-document-map-overlay");
+    if (!$documentMapOverlay) {
+      return;
+    }
+    $documentMapOverlay.attr("aria-label", stringResources[$documentMapOverlay.attr("aria-label")]);
+  }
+}
+
+export { DocumentMapArea };

package/dist/es/domUtils.js

@@ -0,0 +1,43 @@
+import { stringFormat } from './utils.js';
+
+function toPixels(value) {
+  return parseInt(value, 10) || 0;
+}
+function getMargins(dom) {
+  var $target = $(dom);
+  return {
+    left: toPixels($target.css("marginLeft")),
+    right: toPixels($target.css("marginRight")),
+    top: toPixels($target.css("marginTop")),
+    bottom: toPixels($target.css("marginBottom"))
+  };
+}
+function getPadding(dom) {
+  var $target = $(dom);
+  return {
+    left: toPixels($target.css("paddingLeft")),
+    right: toPixels($target.css("paddingRight")),
+    top: toPixels($target.css("paddingTop")),
+    bottom: toPixels($target.css("paddingBottom"))
+  };
+}
+function getBorderWidth(dom) {
+  var $target = $(dom);
+  return {
+    left: toPixels($target.css("borderLeftWidth")),
+    right: toPixels($target.css("borderRightWidth")),
+    top: toPixels($target.css("borderTopWidth")),
+    bottom: toPixels($target.css("borderBottomWidth"))
+  };
+}
+function scale(dom, scaleX, scaleY, originX, originY) {
+  scaleX = scaleX || 1;
+  scaleY = scaleY || 1;
+  originX = originX || 0;
+  originY = originY || 0;
+  var scale2 = stringFormat("scale({0}, {1})", [scaleX, scaleY]);
+  var origin = stringFormat("{0} {1}", [originX, originY]);
+  $(dom).css("transform", scale2).css("transform-origin", origin);
+}
+
+export { getBorderWidth, getMargins, getPadding, scale };

package/dist/es/enums.js

@@ -0,0 +1,41 @@
+const ViewModes = {
+  INTERACTIVE: "INTERACTIVE",
+  PRINT_PREVIEW: "PRINT_PREVIEW"
+};
+const PrintModes = {
+  AUTO_SELECT: "AUTO_SELECT",
+  FORCE_PDF_PLUGIN: "FORCE_PDF_PLUGIN",
+  FORCE_PDF_FILE: "FORCE_PDF_FILE"
+};
+const PageModes = {
+  SINGLE_PAGE: "SINGLE_PAGE",
+  CONTINUOUS_SCROLL: "CONTINUOUS_SCROLL"
+};
+const ScaleModes = {
+  FIT_PAGE_WIDTH: "FIT_PAGE_WIDTH",
+  FIT_PAGE: "FIT_PAGE",
+  SPECIFIC: "SPECIFIC"
+};
+const ParameterTypes = {
+  INTEGER: "System.Int64",
+  FLOAT: "System.Double",
+  STRING: "System.String",
+  DATETIME: "System.DateTime",
+  BOOLEAN: "System.Boolean"
+};
+const ParameterEditorTypes = {
+  COMBO_BOX: "COMBO_BOX",
+  LIST_VIEW: "LIST_VIEW"
+};
+const ParametersAreaPositions = {
+  RIGHT: "RIGHT",
+  LEFT: "LEFT",
+  TOP: "TOP",
+  BOTTOM: "BOTTOM"
+};
+const DocumentMapAreaPositions = {
+  RIGHT: "RIGHT",
+  LEFT: "LEFT"
+};
+
+export { DocumentMapAreaPositions, PageModes, ParameterEditorTypes, ParameterTypes, ParametersAreaPositions, PrintModes, ScaleModes, ViewModes };

package/dist/es/event-emitter.js

@@ -0,0 +1,127 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class EventEmitter extends EventTarget {
+  constructor() {
+    super();
+    __publicField(this, "_events");
+    __publicField(this, "_eventsCount");
+    this._events = {};
+    this._eventsCount = 0;
+  }
+  /**
+   * @param {string} type
+   * @param {(event: CustomEvent, ...args: any[]) => void} listener
+   * @returns
+   */
+  addListener(type, listener) {
+    if (typeof listener !== "function") {
+      throw new TypeError("listener must be a function");
+    }
+    if (!this._events[type]) {
+      this._events[type] = [];
+    }
+    function wrappedListener(event) {
+      listener.call(this, event, ...event.detail);
+    }
+    wrappedListener.listener = listener;
+    this._events[type].push(wrappedListener);
+    this._eventsCount++;
+    this.addEventListener(type, wrappedListener.bind(this));
+    return this;
+  }
+  /**
+   * @alias addListener
+   * @param {string} type
+   * @param {(event: CustomEvent, ...args: any[]) => void} listener
+   * @returns
+   */
+  on(type, listener) {
+    return this.addListener(type, listener);
+  }
+  /**
+   * @param {string} type
+   * @param {any[]} args
+   * @returns
+   */
+  trigger(type, ...args) {
+    if (!this._events[type]) {
+      return void 0;
+    }
+    const event = new CustomEvent(type, {
+      detail: args,
+      cancelable: true
+    });
+    return this.dispatchEvent(event);
+  }
+  /**
+   * @alias trigger
+   * @param {string} type
+   * @param {any[]} args
+   * @returns
+   */
+  emit(type, ...args) {
+    return this.trigger(type, ...args);
+  }
+  /**
+   * @param {string} type
+   * @param {(event: CustomEvent, ...args: any[]) => void} listener
+   * @returns
+   */
+  removeListener(type, listener) {
+    if (!this._events[type]) {
+      return this;
+    }
+    this._events[type] = this._events[type].filter((wrappedListener) => {
+      if (wrappedListener.listener !== listener) {
+        return true;
+      }
+      this.removeEventListener(type, wrappedListener);
+      return false;
+    });
+    if (this._events[type].length === 0) {
+      delete this._events[type];
+      this._eventsCount--;
+    }
+    return this;
+  }
+  /**
+   * @param {string} type
+   * @returns
+   */
+  removeAllListeners(type) {
+    if (type === void 0) {
+      Object.keys(this._events).forEach((eventType) => {
+        this.removeAllListeners(eventType);
+      });
+      return this;
+    }
+    if (this._events[type]) {
+      this._events[type].forEach((wrappedListener) => {
+        this.removeEventListener(type, wrappedListener);
+      });
+      delete this._events[type];
+      this._eventsCount--;
+    }
+    return this;
+  }
+  /**
+   * @param {string} type
+   * @param {(event: CustomEvent, ...args: any[]) => void} listener
+   * @returns
+   */
+  off(type, listener) {
+    if (type === void 0) {
+      return this.removeAllListeners();
+    }
+    if (listener === void 0) {
+      return this.removeAllListeners(type);
+    }
+    return this.removeListener(type, listener);
+  }
+}
+
+export { EventEmitter };

package/dist/es/events.js

@@ -0,0 +1,19 @@
+const Events = {
+  EXPORT_BEGIN: "EXPORT_BEGIN",
+  EXPORT_END: "EXPORT_END",
+  PRINT_BEGIN: "PRINT_BEGIN",
+  PRINT_END: "PRINT_END",
+  RENDERING_BEGIN: "RENDERING_BEGIN",
+  RENDERING_END: "RENDERING_END",
+  PAGE_READY: "PAGE_READY",
+  ERROR: "ERROR",
+  UPDATE_UI: "UPDATE_UI",
+  INTERACTIVE_ACTION_EXECUTING: "INTERACTIVE_ACTION_EXECUTING",
+  INTERACTIVE_ACTION_ENTER: "INTERACTIVE_ACTION_ENTER",
+  INTERACTIVE_ACTION_LEAVE: "INTERACTIVE_ACTION_LEAVE",
+  VIEWER_TOOLTIP_OPENING: "VIEWER_TOOLTIP_OPENING",
+  SEND_EMAIL_BEGIN: "SEND_EMAIL_BEGIN",
+  SEND_EMAIL_END: "SEND_EMAIL_END"
+};
+
+export { Events };

package/dist/es/globalSettings.js

@@ -0,0 +1,5 @@
+const GlobalSettings = {
+  viewerInstances: []
+};
+
+export { GlobalSettings };

package/dist/es/history.js

@@ -0,0 +1,127 @@
+import { reportSourcesAreEqual } from './utils.js';
+
+function HistoryManager(options) {
+  var controller = options.controller;
+  if (!controller) {
+    throw "No controller (telerikReporting.reportViewerController) has been specified.";
+  }
+  var settings = options.settings;
+  var history = settings.getHistory() || { records: [], position: -1 };
+  controller.loadedReportChange(function() {
+    addToHistory(true);
+  }).currentPageChanged(function() {
+    updatePageInfo();
+  }).reportLoadComplete(function(event, args) {
+    addToHistory(false);
+  }).clientExpired(function() {
+    var records = history.records;
+    for (var i = 0; i < records.length; i++) {
+      records[i].reportDocumentId = null;
+    }
+  });
+  function getCurrentRecord() {
+    var records = history.records;
+    if (records.length > 0) {
+      return records[history.position];
+    }
+    return null;
+  }
+  function pushRecord(rec) {
+    var records = history.records;
+    var position = history.position;
+    records = Array.prototype.slice.call(records, 0, position + 1);
+    records.push(rec);
+    history.records = records;
+    history.position = records.length - 1;
+    saveSettings();
+  }
+  function saveSettings() {
+    settings.setHistory(history);
+  }
+  function updatePageInfo() {
+    var currentRecord = getCurrentRecord();
+    if (currentRecord) {
+      currentRecord.pageNumber = controller.getCurrentPageNumber();
+      currentRecord.viewMode = controller.getViewMode();
+      currentRecord.reportDocumentId = controller.getReportDocumentId();
+      saveSettings();
+    }
+  }
+  function addToHistory(temp) {
+    removeTempRecordsFromHistory();
+    var currentRecord = getCurrentRecord();
+    var rs = controller.getReportSource();
+    if (!currentRecord || !reportSourcesAreEqual(currentRecord.reportSource, rs)) {
+      pushRecord({
+        reportSource: rs,
+        pageNumber: 1,
+        temp
+      });
+    }
+  }
+  function exec(currentRecord) {
+    controller.setReportDocumentId(currentRecord.reportDocumentId);
+    controller.setViewMode(currentRecord.viewMode);
+    controller.setReportSource(currentRecord.reportSource);
+    controller.refreshReport(false, currentRecord.reportDocumentId);
+    controller.navigateToPage(currentRecord.pageNumber);
+  }
+  function canMove(step) {
+    var position = history.position;
+    var length = history.records.length;
+    var newPos = position + step;
+    return 0 <= newPos && newPos < length;
+  }
+  function move(step) {
+    var position = history.position;
+    var length = history.records.length;
+    var newPos = position + step;
+    if (newPos < 0) {
+      newPos = 0;
+    } else if (newPos >= length) {
+      newPos = length - 1;
+    }
+    if (newPos != position) {
+      history.position = newPos;
+      saveSettings();
+      exec(getCurrentRecord());
+    }
+  }
+  function removeTempRecordsFromHistory() {
+    var lastIndex = history.records.length - 1;
+    while (lastIndex >= 0) {
+      if (history.records[lastIndex].temp === true) {
+        history.records.splice(lastIndex, 1);
+        if (history.position >= lastIndex) {
+          history.position--;
+        }
+      } else {
+        break;
+      }
+      lastIndex--;
+    }
+  }
+  return {
+    back: function() {
+      move(-1);
+    },
+    forward: function() {
+      move(1);
+    },
+    canMoveBack: function() {
+      return canMove(-1);
+    },
+    canMoveForward: function() {
+      return canMove(1);
+    },
+    loadCurrent: function() {
+      var rec = getCurrentRecord();
+      if (rec) {
+        exec(rec);
+      }
+      return Boolean(rec);
+    }
+  };
+}
+
+export { HistoryManager };

package/dist/es/index.js

@@ -0,0 +1,24 @@
+import * as domUtils from './domUtils.js';
+export { domUtils };
+import * as utils from './utils.js';
+export { utils };
+export { Accessibility } from './accessibility.js';
+export { Binder } from './binder.js';
+export { CommandSet } from './commandSet.js';
+export { ReportViewerController } from './controller.js';
+export { DocumentMapAreaPositions, PageModes, ParameterEditorTypes, ParameterTypes, ParametersAreaPositions, PrintModes, ScaleModes, ViewModes } from './enums.js';
+export { Events } from './events.js';
+export { GlobalSettings } from './globalSettings.js';
+export { HistoryManager } from './history.js';
+export { PagesArea } from './pagesArea.js';
+export { ParameterEditors, parameterEditorsMatch } from './parameters.js';
+export { ParameterValidators } from './parameterValidators.js';
+export { PerspectiveManager } from './perspectives.js';
+export { PrintManager } from './print.js';
+export { ReportViewer } from './reportViewer.js';
+export { Scroll } from './scroll.js';
+export { ServiceClient } from './serviceClient.js';
+import './sr.js';
+export { TouchBehavior } from './touch.js';
+export { UIController } from './uiController.js';
+export { UIFreezeCoordinator } from './uiFreezeCoordinator.js';

package/dist/es/jqueryThrottleDebounce.js

@@ -0,0 +1,46 @@
+/*!
+ * jQuery throttle / debounce - v1.1 - 3/7/2010
+ * http://benalman.com/projects/jquery-throttle-debounce-plugin/
+ *
+ * Copyright (c) 2010 "Cowboy" Ben Alman
+ * Dual licensed under the MIT and GPL licenses.
+ * http://benalman.com/about/license/
+ */
+(function(window2, undefined$1) {
+  "$:nomunge";
+  var $ = window2.Cowboy || (window2.Cowboy = {}), jq_throttle;
+  $.throttle = jq_throttle = function(delay, no_trailing, callback, debounce_mode) {
+    var timeout_id, last_exec = 0;
+    if (typeof no_trailing !== "boolean") {
+      debounce_mode = callback;
+      callback = no_trailing;
+      no_trailing = undefined$1;
+    }
+    function wrapper() {
+      var that = this, elapsed = +/* @__PURE__ */ new Date() - last_exec, args = arguments;
+      function exec() {
+        last_exec = +/* @__PURE__ */ new Date();
+        callback.apply(that, args);
+      }
+      function clear() {
+        timeout_id = undefined$1;
+      }
+      if (debounce_mode && !timeout_id) {
+        exec();
+      }
+      timeout_id && clearTimeout(timeout_id);
+      if (debounce_mode === undefined$1 && elapsed > delay) {
+        exec();
+      } else if (no_trailing !== true) {
+        timeout_id = setTimeout(debounce_mode ? clear : exec, debounce_mode === undefined$1 ? delay - elapsed : delay);
+      }
+    }
+    if ($.guid) {
+      wrapper.guid = callback.guid = callback.guid || $.guid++;
+    }
+    return wrapper;
+  };
+  $.debounce = function(delay, at_begin, callback) {
+    return callback === undefined$1 ? jq_throttle(delay, at_begin, false) : jq_throttle(delay, callback, at_begin !== false);
+  };
+})(window);

package/dist/es/kendo-jquery.js

@@ -0,0 +1 @@
+import 'kendo-ui-core/esm/kendo.ui.core';