@progress/telerik-jquery-report-viewer/dist/cjs/parametersArea.js

Progress® Telerik® Report Viewer for jQuery

'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

var utils = require('./utils.js');
var stringResources = require('./stringResources.js');
var parameterValidators = require('./parameterValidators.js');
var parameters = require('./parameters.js');
var enums = require('./enums.js');
var globalSettings = require('./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, parameters.ParameterEditors);
  var recentParameterValues;
  var parameters$1;
  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.stringResources[$previewButton.text()]);
  $previewButton.attr("aria-label", stringResources.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.stringResources[$previewButton2.attr("aria-label")]);
    $previewButton2.text(stringResources.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 = utils.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.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$1).every((parameter) => {
      return !parameter.isVisible || parameter.autoRefresh;
    });
    return allAuto;
  }
  function allParametersValid() {
    var allValid = Array.from(parameters$1).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$1 = newParameters || [];
    clearEditors();
    var $parameterContainer;
    var $tempContainer = $("<div></div>");
    Array.from(parameters$1).forEach((parameter) => {
      try {
        parameter.value = parameterValidators.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;
      } else {
        parameter.Error = stringResources.stringResources.invalidParameter;
      }
      if (parameter.availableValues) {
        processedParameterValues[parameter.id] = { valueMember: parameter.value, displayMember: parameter.label, availableValues: parameter.availableValues, multivalue: parameter.multivalue };
      } else {
        processedParameterValues[parameter.id] = parameter.value;
      }
      if (parameter.isVisible || options.showHiddenParameters) {
        $parameterContainer = createParameterUI(parameter);
        if ($parameterContainer) {
          $tempContainer.append($parameterContainer);
        }
      }
    });
    if (initialParameterValues !== void 0) {
      if (null === initialParameterValues) {
        initialParameterValues = {};
        Array.from(parameters$1).forEach((parameter) => {
          if (parameter.isVisible) {
            initialParameterValues[parameter.id] = parameter.value;
          } else {
            delete recentParameterValues[parameter.id];
          }
        });
      } else {
        Array.from(parameters$1).forEach((parameter) => {
          if (!(parameter.id in initialParameterValues)) {
            delete recentParameterValues[parameter.id];
          }
        });
      }
    }
    $content.empty();
    if (parameters$1.length > 0) {
      $content.append($tempContainer.children());
      if (enableAccessibility) {
        $content.attr("aria-label", "Parameters area. Contains " + parameters$1.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$1.length - 1; triggerAutoUpdate && i >= 0; i--) {
      var p = parameters$1[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.stringResources.tryReportPreview;
        }
        tryRefreshReport();
      }
    }
  }
  function getParameterById(parameterId) {
    if (parameters$1) {
      for (var i = 0; i < parameters$1.length; i++) {
        var p = parameters$1[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.GlobalSettings.viewerInstances.find((element) => element.id === options.viewerSelector + "-parameters-splitter").instance;
    var sibling = $placeholder.prev();
    if (options.parametersAreaPosition === enums.ParametersAreaPositions.TOP || options.parametersAreaPosition === enums.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 === enums.ParametersAreaPositions.TOP || options.parametersAreaPosition === enums.ParametersAreaPositions.LEFT) {
      splitbar = $placeholder.next();
    }
    splitbar.attr("aria-label", stringResources.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$1) {
      parametersAreaNecessary2 = hasVisibleParameters(parameters$1);
    }
    args.enabled = parametersAreaNecessary2;
    args.visible = parametersAreaVisible;
  }).setParametersAreaVisible(function(event, args) {
    parametersAreaVisible = args.visible;
    showParametersArea(args.visible && hasVisibleParameters(parameters$1));
  });
  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);
      },
      fill: function(parameters2) {
        return fill(parameters2);
      },
      setParameters: function(parameterValues) {
        initialParameterValues = null === parameterValues ? null : $.extend({}, parameterValues);
      }
    }
  );
  return parametersArea;
}

exports.ParametersArea = ParametersArea;