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

package/dist/es/parametersArea.js

@@ -0,0 +1,482 @@
+import { escapeHtml } from './utils.js';
+import { stringResources } from './stringResources.js';
+import { ParameterValidators } from './parameterValidators.js';
+import { ParameterEditors } from './parameters.js';
+import { ParametersAreaPositions } from './enums.js';
+import { GlobalSettings } from './globalSettings.js';
+
+var defaultOptions = {};
+var Events = {
+  PARAMETERS_READY: "pa.parametersReady",
+  ERROR: "pa.Error"
+};
+function ParametersArea(placeholder, options, otherOptions) {
+  options = $.extend({}, defaultOptions, options, otherOptions);
+  var parametersArea = {};
+  var $parametersArea = $(parametersArea);
+  var editors = {};
+  var controller = options.controller;
+  if (!controller) {
+    throw "No controller (telerikReporting.reportViewerController) has been specified.";
+  }
+  var parameterEditors = [].concat(options.parameterEditors, ParameterEditors);
+  var recentParameterValues;
+  var parameters;
+  var initialParameterValues;
+  var processedParameterValues = void 0;
+  var $placeholder = $(placeholder);
+  var $content = $placeholder.find(".trv-parameters-area-content");
+  var $errorMessage = $placeholder.find(".trv-error-message");
+  var $previewButton = $placeholder.find(".trv-parameters-area-preview-button");
+  $previewButton.text(stringResources[$previewButton.text()]);
+  $previewButton.attr("aria-label", stringResources[$previewButton.attr("aria-label")]);
+  $previewButton.on("click", function(e) {
+    e.preventDefault();
+    if (allParametersValid()) {
+      applyParameters();
+    }
+  });
+  var parameterContainerTemplate = options.templates["trv-parameter"];
+  var parametersAreaVisible = options.parametersAreaVisible !== false;
+  var enableAccessibility = options.enableAccessibility;
+  init();
+  function init() {
+    replaceStringResources($placeholder);
+  }
+  function replaceStringResources($paramsArea) {
+    var $previewButton2 = $paramsArea.find(".trv-parameters-area-preview-button");
+    if (!$previewButton2) {
+      return;
+    }
+    $previewButton2.attr("aria-label", stringResources[$previewButton2.attr("aria-label")]);
+    $previewButton2.text(stringResources[$previewButton2.text()]);
+  }
+  function toggleElementDisplay(el, shouldHide) {
+    el.style.display = shouldHide ? "none" : "";
+  }
+  function createParameterContainer() {
+    return $(parameterContainerTemplate);
+  }
+  function createParameterUI(parameter) {
+    var $container = createParameterContainer();
+    var $editorPlaceholder = $container.find(".trv-parameter-value");
+    var $title = $container.find(".trv-parameter-title");
+    var $error = $container.find(".trv-parameter-error");
+    var $errorMessage2 = $container.find(".trv-parameter-error-message");
+    var $useDefaultValueCheckbox = $container.find(".trv-parameter-use-default input");
+    var editorsTypes = options.parameters && options.parameters.editors ? options.parameters.editors : null;
+    var editorFactory = selectParameterEditorFactory(parameter, editorsTypes);
+    var parameterText = escapeHtml(parameter.text);
+    var isHiddenParameter = !parameter.isVisible;
+    if (isHiddenParameter) {
+      parameterText += " [<b>hidden</b>]";
+    }
+    $title.html(parameterText).attr("title", parameterText);
+    $errorMessage2.text(parameter.Error);
+    (parameter.Error ? $.fn.show : $.fn.hide).call($error);
+    var editor = editorFactory.createEditor(
+      $editorPlaceholder,
+      {
+        templates: options.templates,
+        parameterChanged: function(parameter2, newValue) {
+          var invalidParameterLI = document.querySelector(".trv-pages-area .trv-error-message ul li." + parameter2.name);
+          try {
+            newValue = ParameterValidators.validate(parameter2, newValue);
+            $error.hide();
+            if (invalidParameterLI) {
+              toggleElementDisplay(invalidParameterLI, true);
+            }
+            onParameterChanged(parameter2, newValue);
+          } catch (error) {
+            if (invalidParameterLI) {
+              toggleElementDisplay(invalidParameterLI, false);
+            }
+            parameter2.Error = error;
+            parameter2.value = [];
+            $errorMessage2.text(error);
+            $error.show();
+            enablePreviewButton(false);
+          } finally {
+            setAccessibilityErrorState(parameter2);
+          }
+        },
+        enableAccessibility
+      }
+    );
+    editors[parameter.id] = editor;
+    editor.beginEdit(parameter);
+    if (enableAccessibility && !isHiddenParameter) {
+      editor.addAccessibility(parameter);
+    }
+    if ($useDefaultValueCheckbox.length > 0) {
+      $useDefaultValueCheckbox.on(
+        "click",
+        function() {
+          var useDefaultValue = $(this).is(":checked");
+          if (useDefaultValue) {
+            delete recentParameterValues[parameter.id];
+            delete initialParameterValues[parameter.id];
+            invalidateChildParameters(parameter);
+            updateParameters(onLoadParametersSuccess);
+          } else {
+            recentParameterValues[parameter.id] = parameter.value;
+            initialParameterValues[parameter.id] = parameter.value;
+          }
+          editor.enable(!useDefaultValue);
+          raiseParametersReady();
+        }
+      );
+      var hasInitialValues = initialParameterValues !== null;
+      if (hasInitialValues) {
+        if (!(parameter.id in initialParameterValues)) {
+          $useDefaultValueCheckbox.prop("checked", true);
+          editor.enable(false);
+        }
+      } else if (isHiddenParameter) {
+        $useDefaultValueCheckbox.prop("checked", true);
+        editor.enable(false);
+      }
+    }
+    return $container;
+  }
+  function setAccessibilityErrorState(parameter) {
+    var editor = editors[parameter.id];
+    if (!editor || !enableAccessibility) {
+      return;
+    }
+    editor.setAccessibilityErrorState(parameter);
+  }
+  function enablePreviewButton(enabled) {
+    if (enabled) {
+      $previewButton.prop("disabled", false);
+      $previewButton.removeClass("k-disabled");
+    } else {
+      $previewButton.prop("disabled", true);
+      $previewButton.addClass("k-disabled");
+    }
+  }
+  function selectParameterEditorFactory(parameter, editorsType) {
+    var factory = Array.from(parameterEditors).find((editor) => {
+      return editor.match(parameter, editorsType);
+    });
+    return factory;
+  }
+  function showError(error) {
+    $errorMessage.text(error);
+    (error ? $.fn.addClass : $.fn.removeClass).call($placeholder, "trv-error");
+  }
+  function showPreviewButton() {
+    (allParametersAutoRefresh() ? $.fn.removeClass : $.fn.addClass).call($placeholder, "preview");
+  }
+  function allParametersAutoRefresh() {
+    var allAuto = Array.from(parameters).every((parameter) => {
+      return !parameter.isVisible || parameter.autoRefresh;
+    });
+    return allAuto;
+  }
+  function allParametersValid() {
+    var allValid = Array.from(parameters).every((parameter) => {
+      return !parameter.Error;
+    });
+    return allValid;
+  }
+  function clearEditors() {
+    Object.entries(editors).forEach(([key, editor]) => {
+      if (typeof editor.destroy === "function") {
+        editor.destroy();
+      }
+    });
+    editors = {};
+  }
+  function fill(newParameters) {
+    recentParameterValues = {};
+    processedParameterValues = {};
+    parameters = newParameters || [];
+    clearEditors();
+    var $parameterContainer;
+    var $tempContainer = $("<div></div>");
+    Array.from(parameters).forEach((parameter) => {
+      try {
+        parameter.value = ParameterValidators.validate(parameter, parameter.value);
+      } catch (e) {
+        parameter.Error = parameter.Error || e;
+      }
+      var hasError = Boolean(parameter.Error);
+      var hasValue = !hasError;
+      if (hasValue) {
+        recentParameterValues[parameter.id] = parameter.value;
+        if (parameter.availableValues) {
+          processedParameterValues[parameter.id] = { valueMember: parameter.value, displayMember: parameter.label, availableValues: parameter.availableValues, multivalue: parameter.multivalue };
+        } else {
+          processedParameterValues[parameter.id] = parameter.value;
+        }
+      } else {
+        parameter.Error = stringResources.invalidParameter;
+      }
+      if (parameter.isVisible || options.showHiddenParameters) {
+        $parameterContainer = createParameterUI(parameter);
+        if ($parameterContainer) {
+          $tempContainer.append($parameterContainer);
+        }
+      }
+    });
+    if (initialParameterValues !== void 0) {
+      if (null === initialParameterValues) {
+        initialParameterValues = {};
+        Array.from(parameters).forEach((parameter) => {
+          if (parameter.isVisible) {
+            initialParameterValues[parameter.id] = parameter.value;
+          } else {
+            delete recentParameterValues[parameter.id];
+          }
+        });
+      } else {
+        Array.from(parameters).forEach((parameter) => {
+          if (!(parameter.id in initialParameterValues)) {
+            delete recentParameterValues[parameter.id];
+          }
+        });
+      }
+    }
+    $content.empty();
+    if (parameters.length > 0) {
+      $content.append($tempContainer.children());
+      if (enableAccessibility) {
+        $content.attr("aria-label", "Parameters area. Contains " + parameters.length + " parameters.");
+      }
+    }
+    showPreviewButton();
+    var allValid = allParametersValid();
+    enablePreviewButton(allValid);
+    applyProcessedParameters();
+  }
+  function applyParameters() {
+    controller.setParameters($.extend({}, recentParameterValues));
+    controller.previewReport(false);
+  }
+  function applyProcessedParameters() {
+    controller.setProcessedParameter($.extend({}, processedParameterValues));
+  }
+  function allParametersValidForAutoRefresh() {
+    var triggerAutoUpdate = true;
+    for (var i = parameters.length - 1; triggerAutoUpdate && i >= 0; i--) {
+      var p = parameters[i];
+      triggerAutoUpdate = p.id in recentParameterValues && (Boolean(p.autoRefresh) || !p.isVisible);
+    }
+    return triggerAutoUpdate;
+  }
+  function raiseParametersReady() {
+    parametersArea.parametersReady(recentParameterValues);
+  }
+  function tryRefreshReport() {
+    raiseParametersReady();
+    if (allParametersValidForAutoRefresh()) {
+      applyParameters();
+    }
+  }
+  function invalidateChildParameters(parameter) {
+    if (parameter.childParameters) {
+      Array.from(parameter.childParameters).forEach((parameterId) => {
+        var childParameter = getParameterById(parameterId);
+        if (childParameter) {
+          invalidateChildParameters(childParameter);
+        }
+        delete recentParameterValues[parameterId];
+        resetPendingParameterChange(parameterId);
+      });
+    }
+  }
+  function resetPendingParameterChange(parameterId) {
+    if (editors) {
+      var editor = editors[parameterId];
+      if (editor && typeof editor.clearPendingChange === "function") {
+        editor.clearPendingChange();
+      }
+    }
+  }
+  function onParameterChanged(parameter, newValue) {
+    delete parameter["Error"];
+    parameter.value = newValue;
+    recentParameterValues[parameter.id] = newValue;
+    if (initialParameterValues !== void 0) {
+      if (parameter.id in initialParameterValues) {
+        recentParameterValues[parameter.id] = newValue;
+      }
+    } else {
+      recentParameterValues[parameter.id] = newValue;
+    }
+    invalidateChildParameters(parameter);
+    if (parameter.childParameters) {
+      updateParameters(tryRefreshReport);
+    } else {
+      var allValid = allParametersValid();
+      enablePreviewButton(allValid);
+      if (allValid) {
+        var errorMsg = document.querySelector(".trv-pages-area .trv-error-message");
+        if ($previewButton.is(":visible") && errorMsg) {
+          errorMsg.textContent = stringResources.tryReportPreview;
+        }
+        tryRefreshReport();
+      }
+    }
+  }
+  function getParameterById(parameterId) {
+    if (parameters) {
+      for (var i = 0; i < parameters.length; i++) {
+        var p = parameters[i];
+        if (p.id === parameterId) {
+          return p;
+        }
+      }
+    }
+    return null;
+  }
+  function hasVisibleParameters(params) {
+    if (!params || null === params) {
+      return false;
+    }
+    var hasVisible = Array.from(params).some((parameter) => {
+      return parameter.isVisible;
+    });
+    return hasVisible;
+  }
+  var loadingCount = 0;
+  function beginLoad() {
+    loadingCount++;
+    $placeholder.addClass("trv-loading");
+  }
+  function endLoad() {
+    if (loadingCount > 0) {
+      if (0 === --loadingCount) {
+        $placeholder.removeClass("trv-loading");
+      }
+    }
+  }
+  var parametersAreaNecessary = false;
+  function onLoadParametersComplete(params, successAction) {
+    parametersAreaNecessary = hasVisibleParameters(params);
+    if (!parametersAreaNecessary) {
+      showParametersArea(false);
+    }
+    fill(params);
+    showError("");
+    if (parametersAreaNecessary && parametersAreaVisible) {
+      showParametersArea(true);
+      if (enableAccessibility) {
+        setSplitbarAccessibilityAttributes();
+      }
+    }
+    controller.updateUIInternal();
+    if (typeof successAction === "function") {
+      successAction();
+    }
+    endLoad();
+  }
+  function updateParameters(successAction) {
+    acceptParameters(controller.loadParameters(recentParameterValues), successAction);
+  }
+  function acceptParameters(controllerLoadParametersPromise, successAction) {
+    beginLoad();
+    controllerLoadParametersPromise.then(function(parameters2) {
+      onLoadParametersComplete(parameters2, successAction);
+    }).catch(function(error) {
+      endLoad();
+      clear();
+      if (!$placeholder.hasClass("trv-hidden")) {
+        showError(error);
+      }
+      parametersArea.error(error);
+    });
+  }
+  function getEventHandlerFromArguments(args) {
+    var arg0;
+    if (args && args.length) {
+      arg0 = args[0];
+    }
+    if (typeof arg0 === "function") {
+      return arg0;
+    }
+    return null;
+  }
+  function eventFactory(event, args) {
+    var h = getEventHandlerFromArguments(args);
+    if (h) {
+      $parametersArea.on(event, h);
+    } else {
+      $parametersArea.trigger(event, args);
+    }
+    return controller;
+  }
+  function onLoadParametersSuccess() {
+    if (initialParameterValues === null) {
+      initialParameterValues = $.extend({}, recentParameterValues);
+    }
+    raiseParametersReady();
+  }
+  function showParametersArea(show) {
+    var splitter = GlobalSettings.viewerInstances.find((element) => element.id === options.viewerSelector + "-parameters-splitter").instance;
+    var sibling = $placeholder.prev();
+    if (options.parametersAreaPosition === ParametersAreaPositions.TOP || options.parametersAreaPosition === ParametersAreaPositions.LEFT) {
+      sibling = $placeholder.next();
+    }
+    if (splitter) {
+      (parametersAreaNecessary ? $.fn.removeClass : $.fn.addClass).call(sibling, "trv-hidden");
+      splitter.toggle(".trv-parameters-area", show);
+    }
+  }
+  function setSplitbarAccessibilityAttributes() {
+    var splitbar = $placeholder.prev();
+    var tabIndex = $placeholder.find(".trv-parameters-area-content").attr("tabIndex");
+    if (options.parametersAreaPosition === ParametersAreaPositions.TOP || options.parametersAreaPosition === ParametersAreaPositions.LEFT) {
+      splitbar = $placeholder.next();
+    }
+    splitbar.attr("aria-label", stringResources.ariaLabelParametersAreaSplitter);
+    splitbar.attr("tabIndex", tabIndex);
+  }
+  function onReloadParameters(event, controllerLoadParametersPromise) {
+    showError();
+    $content.empty();
+    acceptParameters(controllerLoadParametersPromise, onLoadParametersSuccess);
+  }
+  controller.reloadParameters(onReloadParameters).beforeLoadReport(function() {
+    loadingCount = 0;
+    beginLoad();
+  }).error(endLoad).pageReady(endLoad);
+  controller.getParametersAreaState(function(event, args) {
+    var parametersAreaNecessary2 = false;
+    if (parameters) {
+      parametersAreaNecessary2 = hasVisibleParameters(parameters);
+    }
+    args.enabled = parametersAreaNecessary2;
+    args.visible = parametersAreaVisible;
+  }).setParametersAreaVisible(function(event, args) {
+    parametersAreaVisible = args.visible;
+    showParametersArea(args.visible && hasVisibleParameters(parameters));
+  });
+  function clear() {
+    fill([]);
+  }
+  $.extend(
+    parametersArea,
+    {
+      allParametersValid: function() {
+        return allParametersValid();
+      },
+      clear: function() {
+        clear();
+      },
+      error: function() {
+        return eventFactory(Events.ERROR, arguments);
+      },
+      parametersReady: function() {
+        return eventFactory(Events.PARAMETERS_READY, arguments);
+      },
+      setParameters: function(parameterValues) {
+        initialParameterValues = null === parameterValues ? null : $.extend({}, parameterValues);
+      }
+    }
+  );
+  return parametersArea;
+}
+
+export { ParametersArea };

package/dist/es/perspectives.js

@@ -0,0 +1,134 @@
+function PerspectiveManager(dom, controller) {
+  var smallMenu = dom.querySelectorAll ? dom.querySelectorAll(".trv-menu-small")[0] : false;
+  var perspectives = {
+    "small": {
+      documentMapVisible: false,
+      parametersAreaVisible: false,
+      onDocumentMapVisibleChanged: function(e, args) {
+        if (args.visible) {
+          controller.setParametersAreaVisible({ visible: false });
+        }
+      },
+      onParameterAreaVisibleChanged: function(e, args) {
+        if (args.visible) {
+          controller.setDocumentMapVisible({ visible: false });
+        }
+      },
+      onBeforeLoadReport: function() {
+        controller.setParametersAreaVisible({ visible: false });
+        controller.setDocumentMapVisible({ visible: false });
+      },
+      onNavigateToPage: function() {
+        controller.setParametersAreaVisible({ visible: false });
+        controller.setDocumentMapVisible({ visible: false });
+      }
+    },
+    "large": {
+      documentMapVisible: true,
+      parametersAreaVisible: true
+    }
+  };
+  var currentPerspective;
+  function init() {
+    currentPerspective = getPerspective();
+    initStateFromController(perspectives["large"]);
+  }
+  function setPerspective(beforeApplyState) {
+    var perspective = getPerspective();
+    if (perspective !== currentPerspective) {
+      var oldState = perspectives[currentPerspective];
+      var newState = perspectives[perspective];
+      currentPerspective = perspective;
+      if (beforeApplyState) {
+        beforeApplyState.call(void 0, oldState, newState);
+      }
+      applyState(newState);
+    }
+  }
+  function onDocumentMapVisibleChanged(e, args) {
+    dispatch("onDocumentMapVisibleChanged", arguments);
+  }
+  function onParameterAreaVisibleChanged(e, args) {
+    dispatch("onParameterAreaVisibleChanged", arguments);
+  }
+  function onBeforeLoadReport() {
+    dispatch("onBeforeLoadReport", arguments);
+  }
+  function onNavigateToPage() {
+    dispatch("onNavigateToPage", arguments);
+  }
+  function onReportLoadComplete() {
+    dispatch("onReportLoadComplete", arguments);
+  }
+  function onWindowResize() {
+    setPerspective(
+      function(oldState, newState) {
+        initStateFromController(oldState);
+      }
+    );
+  }
+  function onCssLoaded() {
+    setPerspective(null);
+  }
+  function dispatch(func, args) {
+    var activePerspective = perspectives[currentPerspective];
+    var handler = activePerspective[func];
+    if (typeof handler === "function") {
+      handler.apply(activePerspective, args);
+    }
+  }
+  function attach() {
+    window.addEventListener("resize", onWindowResize);
+    controller.setDocumentMapVisible(onDocumentMapVisibleChanged);
+    controller.setParametersAreaVisible(onParameterAreaVisibleChanged);
+    controller.beforeLoadReport(onBeforeLoadReport);
+    controller.navigateToPage(onNavigateToPage);
+    controller.reportLoadComplete(onReportLoadComplete);
+    controller.cssLoaded(onCssLoaded);
+  }
+  function dispose() {
+    window.removeEventListener("resize", onWindowResize);
+  }
+  function getPerspective() {
+    var windowWidthInEm = $(window).width() / parseFloat($("body").css("font-size"));
+    var windowMinWidth = 40.5;
+    return smallMenu && windowWidthInEm <= windowMinWidth ? "small" : "large";
+  }
+  function initStateFromController(state) {
+    state.documentMapVisible = documentMapVisible();
+    state.parametersAreaVisible = parametersAreaVisible();
+  }
+  function applyState(state) {
+    documentMapVisible(state.documentMapVisible);
+    parametersAreaVisible(state.parametersAreaVisible);
+  }
+  function documentMapVisible() {
+    if (arguments.length === 0) {
+      var args1 = {};
+      controller.getDocumentMapState(args1);
+      return args1.visible;
+    }
+    controller.setDocumentMapVisible({
+      visible: Boolean(arguments[0])
+    });
+    return this;
+  }
+  function parametersAreaVisible() {
+    if (arguments.length === 0) {
+      var args1 = {};
+      controller.getParametersAreaState(args1);
+      return args1.visible;
+    }
+    controller.setParametersAreaVisible({
+      visible: Boolean(arguments[0])
+    });
+    return this;
+  }
+  init();
+  return {
+    attach,
+    dispose
+  };
+}
+
+export { PerspectiveManager };