CodeforLeipzig/stadtratmonitor

View on GitHub
public/assets/application-83027ab76a0c0e3ffb5bae510e4627be2c66fe2cccf3e0d566ea67ed819ad3e1.js

Summary

Maintainability
F
1 mo
Test Coverage

File application-83027ab76a0c0e3ffb5bae510e4627be2c66fe2cccf3e0d566ea67ed819ad3e1.js has 5061 lines of code (exceeds 250 allowed). Consider refactoring.
Open

(() => {
  var __defProp = Object.defineProperty;
  var __export = (target, all) => {
    for (var name in all)
      __defProp(target, name, { get: all[name], enumerable: true });

    Function popperGenerator has 152 lines of code (exceeds 25 allowed). Consider refactoring.
    Open

      function popperGenerator(generatorOptions) {
        if (generatorOptions === void 0) {
          generatorOptions = {};
        }
        var _generatorOptions = generatorOptions, _generatorOptions$def = _generatorOptions.defaultModifiers, defaultModifiers3 = _generatorOptions$def === void 0 ? [] : _generatorOptions$def, _generatorOptions$def2 = _generatorOptions.defaultOptions, defaultOptions = _generatorOptions$def2 === void 0 ? DEFAULT_OPTIONS : _generatorOptions$def2;

      Function createPopper4 has 146 lines of code (exceeds 25 allowed). Consider refactoring.
      Open

          return function createPopper4(reference2, popper2, options) {
            if (options === void 0) {
              options = defaultOptions;
            }
            var state = {

        Function flip has 84 lines of code (exceeds 25 allowed). Consider refactoring.
        Open

          function flip(_ref) {
            var state = _ref.state, options = _ref.options, name = _ref.name;
            if (state.modifiersData[name]._skip) {
              return;
            }

          Function preventOverflow has 82 lines of code (exceeds 25 allowed). Consider refactoring.
          Open

            function preventOverflow(_ref) {
              var state = _ref.state, options = _ref.options, name = _ref.name;
              var _options$mainAxis = options.mainAxis, checkMainAxis = _options$mainAxis === void 0 ? true : _options$mainAxis, _options$altAxis = options.altAxis, checkAltAxis = _options$altAxis === void 0 ? false : _options$altAxis, boundary = options.boundary, rootBoundary = options.rootBoundary, altBoundary = options.altBoundary, padding = options.padding, _options$tether = options.tether, tether = _options$tether === void 0 ? true : _options$tether, _options$tetherOffset = options.tetherOffset, tetherOffset = _options$tetherOffset === void 0 ? 0 : _options$tetherOffset;
              var overflow = detectOverflow(state, {
                boundary,

            Function mapToStyles has 63 lines of code (exceeds 25 allowed). Consider refactoring.
            Open

              function mapToStyles(_ref2) {
                var _Object$assign2;
                var popper2 = _ref2.popper, popperRect = _ref2.popperRect, placement = _ref2.placement, variation = _ref2.variation, offsets = _ref2.offsets, position = _ref2.position, gpuAcceleration = _ref2.gpuAcceleration, adaptive = _ref2.adaptive, roundOffsets = _ref2.roundOffsets, isFixed = _ref2.isFixed;
                var _offsets$x = offsets.x, x = _offsets$x === void 0 ? 0 : _offsets$x, _offsets$y = offsets.y, y = _offsets$y === void 0 ? 0 : _offsets$y;
                var _ref3 = typeof roundOffsets === "function" ? roundOffsets({

              Function validateModifiers has 57 lines of code (exceeds 25 allowed). Consider refactoring.
              Open

                function validateModifiers(modifiers) {
                  modifiers.forEach(function(modifier) {
                    [].concat(Object.keys(modifier), VALID_PROPERTIES).filter(function(value, index, self) {
                      return self.indexOf(value) === index;
                    }).forEach(function(key) {

                Function computeOffsets has 51 lines of code (exceeds 25 allowed). Consider refactoring.
                Open

                  function computeOffsets(_ref) {
                    var reference2 = _ref.reference, element = _ref.element, placement = _ref.placement;
                    var basePlacement = placement ? getBasePlacement(placement) : null;
                    var variation = placement ? getVariation(placement) : null;
                    var commonX = reference2.x + reference2.width / 2 - element.width / 2;

                  Function _slide has 47 lines of code (exceeds 25 allowed). Consider refactoring.
                  Open

                      _slide(order2, element = null) {
                        if (this._isSliding) {
                          return;
                        }
                        const activeElement = this._getActive();

                    Function forceUpdate has 43 lines of code (exceeds 25 allowed). Consider refactoring.
                    Open

                            forceUpdate: function forceUpdate() {
                              if (isDestroyed) {
                                return;
                              }
                              var _state$elements = state.elements, reference3 = _state$elements.reference, popper3 = _state$elements.popper;

                      Consider simplifying this complex logical expression.
                      Open

                            if (css.transform !== "none" || css.perspective !== "none" || css.contain === "paint" || ["transform", "perspective"].indexOf(css.willChange) !== -1 || isFirefox && css.willChange === "filter" || isFirefox && css.filter && css.filter !== "none") {
                              return currentNode;
                            } else {
                              currentNode = currentNode.parentNode;
                            }

                        Function computeStyles has 37 lines of code (exceeds 25 allowed). Consider refactoring.
                        Open

                          function computeStyles(_ref5) {
                            var state = _ref5.state, options = _ref5.options;
                            var _options$gpuAccelerat = options.gpuAcceleration, gpuAcceleration = _options$gpuAccelerat === void 0 ? true : _options$gpuAccelerat, _options$adaptive = options.adaptive, adaptive = _options$adaptive === void 0 ? true : _options$adaptive, _options$roundOffsets = options.roundOffsets, roundOffsets = _options$roundOffsets === void 0 ? true : _options$roundOffsets;
                            if (true) {
                              var transitionProperty = getComputedStyle2(state.elements.popper).transitionProperty || "";

                          Function show has 37 lines of code (exceeds 25 allowed). Consider refactoring.
                          Open

                              show() {
                                if (this._element.style.display === "none") {
                                  throw new Error("Please use show on visible elements");
                                }
                                if (!(this._isWithContent() && this._isEnabled)) {

                            Function show has 36 lines of code (exceeds 25 allowed). Consider refactoring.
                            Open

                                show() {
                                  if (this._isTransitioning || this._isShown()) {
                                    return;
                                  }
                                  let activeChildren = [];

                              Function effect has 36 lines of code (exceeds 25 allowed). Consider refactoring.
                              Open

                                function effect(_ref2) {
                                  var state = _ref2.state;
                                  var initialStyles = {
                                    popper: {
                                      position: state.options.strategy,

                                Function setOptions has 35 lines of code (exceeds 25 allowed). Consider refactoring.
                                Open

                                        setOptions: function setOptions(setOptionsAction) {
                                          var options2 = typeof setOptionsAction === "function" ? setOptionsAction(state.options) : setOptionsAction;
                                          cleanupModifierEffects();
                                          state.options = Object.assign({}, defaultOptions, state.options, options2);
                                          state.scrollParents = {

                                  Function _getPopperConfig has 35 lines of code (exceeds 25 allowed). Consider refactoring.
                                  Open

                                      _getPopperConfig(attachment) {
                                        const defaultBsPopperConfig = {
                                          placement: attachment,
                                          modifiers: [{
                                            name: "flip",

                                    Function detectOverflow has 34 lines of code (exceeds 25 allowed). Consider refactoring.
                                    Open

                                      function detectOverflow(state, options) {
                                        if (options === void 0) {
                                          options = {};
                                        }
                                        var _options = options, _options$placement = _options.placement, placement = _options$placement === void 0 ? state.placement : _options$placement, _options$strategy = _options.strategy, strategy = _options$strategy === void 0 ? state.strategy : _options$strategy, _options$boundary = _options.boundary, boundary = _options$boundary === void 0 ? clippingParents : _options$boundary, _options$rootBoundary = _options.rootBoundary, rootBoundary = _options$rootBoundary === void 0 ? viewport : _options$rootBoundary, _options$elementConte = _options.elementContext, elementContext = _options$elementConte === void 0 ? popper : _options$elementConte, _options$altBoundary = _options.altBoundary, altBoundary = _options$altBoundary === void 0 ? false : _options$altBoundary, _options$padding = _options.padding, padding = _options$padding === void 0 ? 0 : _options$padding;

                                      Function getCompositeRect has 34 lines of code (exceeds 25 allowed). Consider refactoring.
                                      Open

                                        function getCompositeRect(elementOrVirtualElement, offsetParent, isFixed) {
                                          if (isFixed === void 0) {
                                            isFixed = false;
                                          }
                                          var isOffsetParentAnElement = isHTMLElement(offsetParent);

                                        Function trigger has 32 lines of code (exceeds 25 allowed). Consider refactoring.
                                        Open

                                            trigger(element, event, args) {
                                              if (typeof event !== "string" || !element) {
                                                return null;
                                              }
                                              const $ = getjQuery();

                                          Function _addEventListeners has 30 lines of code (exceeds 25 allowed). Consider refactoring.
                                          Open

                                              _addEventListeners() {
                                                EventHandler.on(this._element, EVENT_KEYDOWN_DISMISS$1, (event) => {
                                                  if (event.key !== ESCAPE_KEY$1) {
                                                    return;
                                                  }

                                            Function addHandler has 29 lines of code (exceeds 25 allowed). Consider refactoring.
                                            Open

                                              function addHandler(element, originalTypeEvent, handler, delegationFunction, oneOff) {
                                                if (typeof originalTypeEvent !== "string" || !element) {
                                                  return;
                                                }
                                                let [isDelegated, callable, typeEvent] = normalizeParameters(originalTypeEvent, handler, delegationFunction);

                                              Function computeAutoPlacement has 29 lines of code (exceeds 25 allowed). Consider refactoring.
                                              Open

                                                function computeAutoPlacement(state, options) {
                                                  if (options === void 0) {
                                                    options = {};
                                                  }
                                                  var _options = options, placement = _options.placement, boundary = _options.boundary, rootBoundary = _options.rootBoundary, padding = _options.padding, flipVariations = _options.flipVariations, _options$allowedAutoP = _options.allowedAutoPlacements, allowedAutoPlacements = _options$allowedAutoP === void 0 ? placements : _options$allowedAutoP;

                                                Function getBoundingClientRect has 29 lines of code (exceeds 25 allowed). Consider refactoring.
                                                Open

                                                  function getBoundingClientRect(element, includeScale, isFixedStrategy) {
                                                    if (includeScale === void 0) {
                                                      includeScale = false;
                                                    }
                                                    if (isFixedStrategy === void 0) {

                                                  Function hide has 29 lines of code (exceeds 25 allowed). Consider refactoring.
                                                  Open

                                                      hide() {
                                                        if (!this._isShown()) {
                                                          return;
                                                        }
                                                        const hideEvent = EventHandler.trigger(this._element, this.constructor.eventName(EVENT_HIDE$2));

                                                    Function _setListeners has 28 lines of code (exceeds 25 allowed). Consider refactoring.
                                                    Open

                                                        _setListeners() {
                                                          const triggers = this._config.trigger.split(" ");
                                                          for (const trigger of triggers) {
                                                            if (trigger === "click") {
                                                              EventHandler.on(this._element, this.constructor.eventName(EVENT_CLICK$1), this._config.selector, (event) => {

                                                      Function show has 28 lines of code (exceeds 25 allowed). Consider refactoring.
                                                      Open

                                                          show(relatedTarget) {
                                                            if (this._isShown) {
                                                              return;
                                                            }
                                                            const showEvent = EventHandler.trigger(this._element, EVENT_SHOW$3, {

                                                        Function hide has 27 lines of code (exceeds 25 allowed). Consider refactoring.
                                                        Open

                                                            hide() {
                                                              if (this._isTransitioning || !this._isShown()) {
                                                                return;
                                                              }
                                                              const startEvent = EventHandler.trigger(this._element, EVENT_HIDE$6);

                                                          Function off has 27 lines of code (exceeds 25 allowed). Consider refactoring.
                                                          Open

                                                              off(element, originalTypeEvent, handler, delegationFunction) {
                                                                if (typeof originalTypeEvent !== "string" || !element) {
                                                                  return;
                                                                }
                                                                const [isDelegated, callable, typeEvent] = normalizeParameters(originalTypeEvent, handler, delegationFunction);

                                                            Function arrow has 26 lines of code (exceeds 25 allowed). Consider refactoring.
                                                            Open

                                                              function arrow(_ref) {
                                                                var _state$modifiersData$;
                                                                var state = _ref.state, name = _ref.name, options = _ref.options;
                                                                var arrowElement = state.elements.arrow;
                                                                var popperOffsets2 = state.modifiersData.popperOffsets;

                                                              Function _observerCallback has 26 lines of code (exceeds 25 allowed). Consider refactoring.
                                                              Open

                                                                  _observerCallback(entries) {
                                                                    const targetElement = (entry) => this._targetLinks.get(`#${entry.target.id}`);
                                                                    const activate = (entry) => {
                                                                      this._previousScrollData.visibleEntryTop = entry.target.offsetTop;
                                                                      this._process(targetElement(entry));

                                                                Consider simplifying this complex logical expression.
                                                                Open

                                                                      if (placement === top || (placement === left || placement === right) && variation === end) {
                                                                        sideY = bottom;
                                                                        var offsetY = isFixed && offsetParent === win && win.visualViewport ? win.visualViewport.height : (
                                                                          // $FlowFixMe[prop-missing]
                                                                          offsetParent[heightProp]

                                                                  Consider simplifying this complex logical expression.
                                                                  Open

                                                                        if (placement === left || (placement === top || placement === bottom) && variation === end) {
                                                                          sideX = right;
                                                                          var offsetX = isFixed && offsetParent === win && win.visualViewport ? win.visualViewport.width : (
                                                                            // $FlowFixMe[prop-missing]
                                                                            offsetParent[widthProp]

                                                                    Function removeHandler has 5 arguments (exceeds 4 allowed). Consider refactoring.
                                                                    Open

                                                                      function removeHandler(element, events, typeEvent, handler, delegationSelector) {

                                                                      Function addHandler has 5 arguments (exceeds 4 allowed). Consider refactoring.
                                                                      Open

                                                                        function addHandler(element, originalTypeEvent, handler, delegationFunction, oneOff) {

                                                                        Avoid too many return statements within this function.
                                                                        Open

                                                                                return isEnd ? PLACEMENT_TOPEND : PLACEMENT_TOP;

                                                                          Avoid too many return statements within this function.
                                                                          Open

                                                                                return value;

                                                                            Avoid too many return statements within this function.
                                                                            Open

                                                                                  return JSON.parse(decodeURIComponent(value));

                                                                              Avoid too many return statements within this function.
                                                                              Open

                                                                                    return value;

                                                                                Avoid too many return statements within this function.
                                                                                Open

                                                                                      return isEnd ? PLACEMENT_BOTTOMEND : PLACEMENT_BOTTOM;

                                                                                  Avoid too many return statements within this function.
                                                                                  Open

                                                                                      return findShadowRoot(element.parentNode);

                                                                                    Avoid too many return statements within this function.
                                                                                    Open

                                                                                        return elementIsVisible;

                                                                                      Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                      Open

                                                                                            if (placement === left || (placement === top || placement === bottom) && variation === end) {
                                                                                              sideX = right;
                                                                                              var offsetX = isFixed && offsetParent === win && win.visualViewport ? win.visualViewport.width : (
                                                                                                // $FlowFixMe[prop-missing]
                                                                                                offsetParent[widthProp]
                                                                                      public/assets/application-83027ab76a0c0e3ffb5bae510e4627be2c66fe2cccf3e0d566ea67ed819ad3e1.js on lines 513..521

                                                                                      Duplicated Code

                                                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                      Tuning

                                                                                      This issue has a mass of 115.

                                                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                      Refactorings

                                                                                      Further Reading

                                                                                      Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                      Open

                                                                                            if (placement === top || (placement === left || placement === right) && variation === end) {
                                                                                              sideY = bottom;
                                                                                              var offsetY = isFixed && offsetParent === win && win.visualViewport ? win.visualViewport.height : (
                                                                                                // $FlowFixMe[prop-missing]
                                                                                                offsetParent[heightProp]
                                                                                      public/assets/application-83027ab76a0c0e3ffb5bae510e4627be2c66fe2cccf3e0d566ea67ed819ad3e1.js on lines 522..530

                                                                                      Duplicated Code

                                                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                      Tuning

                                                                                      This issue has a mass of 115.

                                                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                      Refactorings

                                                                                      Further Reading

                                                                                      Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                      Open

                                                                                          return {
                                                                                            top: overflow.top - rect.height - preventedOffsets.y,
                                                                                            right: overflow.right - rect.width + preventedOffsets.x,
                                                                                            bottom: overflow.bottom - rect.height + preventedOffsets.y,
                                                                                            left: overflow.left - rect.width - preventedOffsets.x
                                                                                      public/assets/application-83027ab76a0c0e3ffb5bae510e4627be2c66fe2cccf3e0d566ea67ed819ad3e1.js on lines 887..892

                                                                                      Duplicated Code

                                                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                      Tuning

                                                                                      This issue has a mass of 102.

                                                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                      Refactorings

                                                                                      Further Reading

                                                                                      Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                      Open

                                                                                          _getOffset() {
                                                                                            const {
                                                                                              offset: offset2
                                                                                            } = this._config;
                                                                                            if (typeof offset2 === "string") {
                                                                                      public/assets/application-83027ab76a0c0e3ffb5bae510e4627be2c66fe2cccf3e0d566ea67ed819ad3e1.js on lines 4483..4494

                                                                                      Duplicated Code

                                                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                      Tuning

                                                                                      This issue has a mass of 102.

                                                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                      Refactorings

                                                                                      Further Reading

                                                                                      Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                      Open

                                                                                          _getOffset() {
                                                                                            const {
                                                                                              offset: offset2
                                                                                            } = this._config;
                                                                                            if (typeof offset2 === "string") {
                                                                                      public/assets/application-83027ab76a0c0e3ffb5bae510e4627be2c66fe2cccf3e0d566ea67ed819ad3e1.js on lines 3186..3197

                                                                                      Duplicated Code

                                                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                      Tuning

                                                                                      This issue has a mass of 102.

                                                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                      Refactorings

                                                                                      Further Reading

                                                                                      Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                      Open

                                                                                          var overflowOffsets = {
                                                                                            top: clippingClientRect.top - elementClientRect.top + paddingObject.top,
                                                                                            bottom: elementClientRect.bottom - clippingClientRect.bottom + paddingObject.bottom,
                                                                                            left: clippingClientRect.left - elementClientRect.left + paddingObject.left,
                                                                                            right: elementClientRect.right - clippingClientRect.right + paddingObject.right
                                                                                      public/assets/application-83027ab76a0c0e3ffb5bae510e4627be2c66fe2cccf3e0d566ea67ed819ad3e1.js on lines 1052..1057

                                                                                      Duplicated Code

                                                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                      Tuning

                                                                                      This issue has a mass of 102.

                                                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                      Refactorings

                                                                                      Further Reading

                                                                                      Similar blocks of code found in 3 locations. Consider refactoring.
                                                                                      Open

                                                                                          static jQueryInterface(config) {
                                                                                            return this.each(function() {
                                                                                              const data = Dropdown.getOrCreateInstance(this, config);
                                                                                              if (typeof config !== "string") {
                                                                                                return;
                                                                                      public/assets/application-83027ab76a0c0e3ffb5bae510e4627be2c66fe2cccf3e0d566ea67ed819ad3e1.js on lines 4660..4671
                                                                                      public/assets/application-83027ab76a0c0e3ffb5bae510e4627be2c66fe2cccf3e0d566ea67ed819ad3e1.js on lines 4715..4726

                                                                                      Duplicated Code

                                                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                      Tuning

                                                                                      This issue has a mass of 100.

                                                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                      Refactorings

                                                                                      Further Reading

                                                                                      Similar blocks of code found in 3 locations. Consider refactoring.
                                                                                      Open

                                                                                          static jQueryInterface(config) {
                                                                                            return this.each(function() {
                                                                                              const data = Tooltip.getOrCreateInstance(this, config);
                                                                                              if (typeof config !== "string") {
                                                                                                return;
                                                                                      public/assets/application-83027ab76a0c0e3ffb5bae510e4627be2c66fe2cccf3e0d566ea67ed819ad3e1.js on lines 3236..3247
                                                                                      public/assets/application-83027ab76a0c0e3ffb5bae510e4627be2c66fe2cccf3e0d566ea67ed819ad3e1.js on lines 4715..4726

                                                                                      Duplicated Code

                                                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                      Tuning

                                                                                      This issue has a mass of 100.

                                                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                      Refactorings

                                                                                      Further Reading

                                                                                      Similar blocks of code found in 3 locations. Consider refactoring.
                                                                                      Open

                                                                                          static jQueryInterface(config) {
                                                                                            return this.each(function() {
                                                                                              const data = Popover.getOrCreateInstance(this, config);
                                                                                              if (typeof config !== "string") {
                                                                                                return;
                                                                                      public/assets/application-83027ab76a0c0e3ffb5bae510e4627be2c66fe2cccf3e0d566ea67ed819ad3e1.js on lines 3236..3247
                                                                                      public/assets/application-83027ab76a0c0e3ffb5bae510e4627be2c66fe2cccf3e0d566ea67ed819ad3e1.js on lines 4660..4671

                                                                                      Duplicated Code

                                                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                      Tuning

                                                                                      This issue has a mass of 100.

                                                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                      Refactorings

                                                                                      Further Reading

                                                                                      Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                      Open

                                                                                                case "fn":
                                                                                                  if (typeof modifier.fn !== "function") {
                                                                                                    console.error(format(INVALID_MODIFIER_ERROR, modifier.name, '"fn"', '"function"', '"' + String(modifier.fn) + '"'));
                                                                                                  }
                                                                                                  break;
                                                                                      public/assets/application-83027ab76a0c0e3ffb5bae510e4627be2c66fe2cccf3e0d566ea67ed819ad3e1.js on lines 1392..1396

                                                                                      Duplicated Code

                                                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                      Tuning

                                                                                      This issue has a mass of 61.

                                                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                      Refactorings

                                                                                      Further Reading

                                                                                      Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                      Open

                                                                                                case "enabled":
                                                                                                  if (typeof modifier.enabled !== "boolean") {
                                                                                                    console.error(format(INVALID_MODIFIER_ERROR, modifier.name, '"enabled"', '"boolean"', '"' + String(modifier.enabled) + '"'));
                                                                                                  }
                                                                                                  break;
                                                                                      public/assets/application-83027ab76a0c0e3ffb5bae510e4627be2c66fe2cccf3e0d566ea67ed819ad3e1.js on lines 1402..1406

                                                                                      Duplicated Code

                                                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                      Tuning

                                                                                      This issue has a mass of 61.

                                                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                      Refactorings

                                                                                      Further Reading

                                                                                      Similar blocks of code found in 3 locations. Consider refactoring.
                                                                                      Open

                                                                                            if ("ontouchstart" in document.documentElement) {
                                                                                              for (const element of [].concat(...document.body.children)) {
                                                                                                EventHandler.off(element, "mouseover", noop);
                                                                                              }
                                                                                            }
                                                                                      public/assets/application-83027ab76a0c0e3ffb5bae510e4627be2c66fe2cccf3e0d566ea67ed819ad3e1.js on lines 3124..3128
                                                                                      public/assets/application-83027ab76a0c0e3ffb5bae510e4627be2c66fe2cccf3e0d566ea67ed819ad3e1.js on lines 4365..4369

                                                                                      Duplicated Code

                                                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                      Tuning

                                                                                      This issue has a mass of 60.

                                                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                      Refactorings

                                                                                      Further Reading

                                                                                      Similar blocks of code found in 3 locations. Consider refactoring.
                                                                                      Open

                                                                                            if ("ontouchstart" in document.documentElement) {
                                                                                              for (const element of [].concat(...document.body.children)) {
                                                                                                EventHandler.off(element, "mouseover", noop);
                                                                                              }
                                                                                            }
                                                                                      public/assets/application-83027ab76a0c0e3ffb5bae510e4627be2c66fe2cccf3e0d566ea67ed819ad3e1.js on lines 4365..4369
                                                                                      public/assets/application-83027ab76a0c0e3ffb5bae510e4627be2c66fe2cccf3e0d566ea67ed819ad3e1.js on lines 4389..4393

                                                                                      Duplicated Code

                                                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                      Tuning

                                                                                      This issue has a mass of 60.

                                                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                      Refactorings

                                                                                      Further Reading

                                                                                      Similar blocks of code found in 3 locations. Consider refactoring.
                                                                                      Open

                                                                                            if ("ontouchstart" in document.documentElement) {
                                                                                              for (const element of [].concat(...document.body.children)) {
                                                                                                EventHandler.on(element, "mouseover", noop);
                                                                                              }
                                                                                            }
                                                                                      public/assets/application-83027ab76a0c0e3ffb5bae510e4627be2c66fe2cccf3e0d566ea67ed819ad3e1.js on lines 3124..3128
                                                                                      public/assets/application-83027ab76a0c0e3ffb5bae510e4627be2c66fe2cccf3e0d566ea67ed819ad3e1.js on lines 4389..4393

                                                                                      Duplicated Code

                                                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                      Tuning

                                                                                      This issue has a mass of 60.

                                                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                      Refactorings

                                                                                      Further Reading

                                                                                      Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                      Open

                                                                                          constructor(config) {
                                                                                            super();
                                                                                            this._config = this._getConfig(config);
                                                                                            this._isAppended = false;
                                                                                            this._element = null;
                                                                                      public/assets/application-83027ab76a0c0e3ffb5bae510e4627be2c66fe2cccf3e0d566ea67ed819ad3e1.js on lines 3505..3510

                                                                                      Duplicated Code

                                                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                      Tuning

                                                                                      This issue has a mass of 58.

                                                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                      Refactorings

                                                                                      Further Reading

                                                                                      Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                      Open

                                                                                          constructor(config) {
                                                                                            super();
                                                                                            this._config = this._getConfig(config);
                                                                                            this._isActive = false;
                                                                                            this._lastTabNavDirection = null;
                                                                                      public/assets/application-83027ab76a0c0e3ffb5bae510e4627be2c66fe2cccf3e0d566ea67ed819ad3e1.js on lines 3405..3410

                                                                                      Duplicated Code

                                                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                      Tuning

                                                                                      This issue has a mass of 58.

                                                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                      Refactorings

                                                                                      Further Reading

                                                                                      Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                      Open

                                                                                          prev(element, selector) {
                                                                                            let previous = element.previousElementSibling;
                                                                                            while (previous) {
                                                                                              if (previous.matches(selector)) {
                                                                                                return [previous];
                                                                                      public/assets/application-83027ab76a0c0e3ffb5bae510e4627be2c66fe2cccf3e0d566ea67ed819ad3e1.js on lines 2361..2370

                                                                                      Duplicated Code

                                                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                      Tuning

                                                                                      This issue has a mass of 57.

                                                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                      Refactorings

                                                                                      Further Reading

                                                                                      Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                      Open

                                                                                          next(element, selector) {
                                                                                            let next = element.nextElementSibling;
                                                                                            while (next) {
                                                                                              if (next.matches(selector)) {
                                                                                                return [next];
                                                                                      public/assets/application-83027ab76a0c0e3ffb5bae510e4627be2c66fe2cccf3e0d566ea67ed819ad3e1.js on lines 2350..2359

                                                                                      Duplicated Code

                                                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                      Tuning

                                                                                      This issue has a mass of 57.

                                                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                      Refactorings

                                                                                      Further Reading

                                                                                      Identical blocks of code found in 5 locations. Consider refactoring.
                                                                                      Open

                                                                                              if (data[config] === void 0 || config.startsWith("_") || config === "constructor") {
                                                                                                throw new TypeError(`No method named "${config}"`);
                                                                                              }
                                                                                      public/assets/application-83027ab76a0c0e3ffb5bae510e4627be2c66fe2cccf3e0d566ea67ed819ad3e1.js on lines 2764..2766
                                                                                      public/assets/application-83027ab76a0c0e3ffb5bae510e4627be2c66fe2cccf3e0d566ea67ed819ad3e1.js on lines 3985..3987
                                                                                      public/assets/application-83027ab76a0c0e3ffb5bae510e4627be2c66fe2cccf3e0d566ea67ed819ad3e1.js on lines 4924..4926
                                                                                      public/assets/application-83027ab76a0c0e3ffb5bae510e4627be2c66fe2cccf3e0d566ea67ed819ad3e1.js on lines 5128..5130

                                                                                      Duplicated Code

                                                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                      Tuning

                                                                                      This issue has a mass of 53.

                                                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                      Refactorings

                                                                                      Further Reading

                                                                                      Identical blocks of code found in 5 locations. Consider refactoring.
                                                                                      Open

                                                                                              if (data[config] === void 0 || config.startsWith("_") || config === "constructor") {
                                                                                                throw new TypeError(`No method named "${config}"`);
                                                                                              }
                                                                                      public/assets/application-83027ab76a0c0e3ffb5bae510e4627be2c66fe2cccf3e0d566ea67ed819ad3e1.js on lines 2289..2291
                                                                                      public/assets/application-83027ab76a0c0e3ffb5bae510e4627be2c66fe2cccf3e0d566ea67ed819ad3e1.js on lines 2764..2766
                                                                                      public/assets/application-83027ab76a0c0e3ffb5bae510e4627be2c66fe2cccf3e0d566ea67ed819ad3e1.js on lines 3985..3987
                                                                                      public/assets/application-83027ab76a0c0e3ffb5bae510e4627be2c66fe2cccf3e0d566ea67ed819ad3e1.js on lines 5128..5130

                                                                                      Duplicated Code

                                                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                      Tuning

                                                                                      This issue has a mass of 53.

                                                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                      Refactorings

                                                                                      Further Reading

                                                                                      Identical blocks of code found in 5 locations. Consider refactoring.
                                                                                      Open

                                                                                                if (data[config] === void 0 || config.startsWith("_") || config === "constructor") {
                                                                                                  throw new TypeError(`No method named "${config}"`);
                                                                                                }
                                                                                      public/assets/application-83027ab76a0c0e3ffb5bae510e4627be2c66fe2cccf3e0d566ea67ed819ad3e1.js on lines 2289..2291
                                                                                      public/assets/application-83027ab76a0c0e3ffb5bae510e4627be2c66fe2cccf3e0d566ea67ed819ad3e1.js on lines 3985..3987
                                                                                      public/assets/application-83027ab76a0c0e3ffb5bae510e4627be2c66fe2cccf3e0d566ea67ed819ad3e1.js on lines 4924..4926
                                                                                      public/assets/application-83027ab76a0c0e3ffb5bae510e4627be2c66fe2cccf3e0d566ea67ed819ad3e1.js on lines 5128..5130

                                                                                      Duplicated Code

                                                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                      Tuning

                                                                                      This issue has a mass of 53.

                                                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                      Refactorings

                                                                                      Further Reading

                                                                                      Identical blocks of code found in 5 locations. Consider refactoring.
                                                                                      Open

                                                                                              if (data[config] === void 0 || config.startsWith("_") || config === "constructor") {
                                                                                                throw new TypeError(`No method named "${config}"`);
                                                                                              }
                                                                                      public/assets/application-83027ab76a0c0e3ffb5bae510e4627be2c66fe2cccf3e0d566ea67ed819ad3e1.js on lines 2289..2291
                                                                                      public/assets/application-83027ab76a0c0e3ffb5bae510e4627be2c66fe2cccf3e0d566ea67ed819ad3e1.js on lines 2764..2766
                                                                                      public/assets/application-83027ab76a0c0e3ffb5bae510e4627be2c66fe2cccf3e0d566ea67ed819ad3e1.js on lines 4924..4926
                                                                                      public/assets/application-83027ab76a0c0e3ffb5bae510e4627be2c66fe2cccf3e0d566ea67ed819ad3e1.js on lines 5128..5130

                                                                                      Duplicated Code

                                                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                      Tuning

                                                                                      This issue has a mass of 53.

                                                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                      Refactorings

                                                                                      Further Reading

                                                                                      Identical blocks of code found in 5 locations. Consider refactoring.
                                                                                      Open

                                                                                              if (data[config] === void 0 || config.startsWith("_") || config === "constructor") {
                                                                                                throw new TypeError(`No method named "${config}"`);
                                                                                              }
                                                                                      public/assets/application-83027ab76a0c0e3ffb5bae510e4627be2c66fe2cccf3e0d566ea67ed819ad3e1.js on lines 2289..2291
                                                                                      public/assets/application-83027ab76a0c0e3ffb5bae510e4627be2c66fe2cccf3e0d566ea67ed819ad3e1.js on lines 2764..2766
                                                                                      public/assets/application-83027ab76a0c0e3ffb5bae510e4627be2c66fe2cccf3e0d566ea67ed819ad3e1.js on lines 3985..3987
                                                                                      public/assets/application-83027ab76a0c0e3ffb5bae510e4627be2c66fe2cccf3e0d566ea67ed819ad3e1.js on lines 4924..4926

                                                                                      Duplicated Code

                                                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                      Tuning

                                                                                      This issue has a mass of 53.

                                                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                      Refactorings

                                                                                      Further Reading

                                                                                      Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                      Open

                                                                                            return {
                                                                                              ...defaultBsPopperConfig,
                                                                                              ...typeof this._config.popperConfig === "function" ? this._config.popperConfig(defaultBsPopperConfig) : this._config.popperConfig
                                                                                            };
                                                                                      public/assets/application-83027ab76a0c0e3ffb5bae510e4627be2c66fe2cccf3e0d566ea67ed819ad3e1.js on lines 4530..4533

                                                                                      Duplicated Code

                                                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                      Tuning

                                                                                      This issue has a mass of 50.

                                                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                      Refactorings

                                                                                      Further Reading

                                                                                      Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                      Open

                                                                                            return {
                                                                                              ...defaultBsPopperConfig,
                                                                                              ...typeof this._config.popperConfig === "function" ? this._config.popperConfig(defaultBsPopperConfig) : this._config.popperConfig
                                                                                            };
                                                                                      public/assets/application-83027ab76a0c0e3ffb5bae510e4627be2c66fe2cccf3e0d566ea67ed819ad3e1.js on lines 3220..3223

                                                                                      Duplicated Code

                                                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                      Tuning

                                                                                      This issue has a mass of 50.

                                                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                      Refactorings

                                                                                      Further Reading

                                                                                      Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                      Open

                                                                                        EventHandler.on(window, EVENT_LOAD_DATA_API, () => {
                                                                                          for (const element of SelectorEngine.find(SELECTOR_DATA_TOGGLE_ACTIVE)) {
                                                                                            Tab.getOrCreateInstance(element);
                                                                                          }
                                                                                        });
                                                                                      public/assets/application-83027ab76a0c0e3ffb5bae510e4627be2c66fe2cccf3e0d566ea67ed819ad3e1.js on lines 4931..4935

                                                                                      Duplicated Code

                                                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                      Tuning

                                                                                      This issue has a mass of 50.

                                                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                      Refactorings

                                                                                      Further Reading

                                                                                      Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                      Open

                                                                                        EventHandler.on(window, EVENT_LOAD_DATA_API$1, () => {
                                                                                          for (const spy of SelectorEngine.find(SELECTOR_DATA_SPY)) {
                                                                                            ScrollSpy.getOrCreateInstance(spy);
                                                                                          }
                                                                                        });
                                                                                      public/assets/application-83027ab76a0c0e3ffb5bae510e4627be2c66fe2cccf3e0d566ea67ed819ad3e1.js on lines 5144..5148

                                                                                      Duplicated Code

                                                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                      Tuning

                                                                                      This issue has a mass of 50.

                                                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                      Refactorings

                                                                                      Further Reading

                                                                                      Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                      Open

                                                                                            if (isBodyOverflowing && !isModalOverflowing) {
                                                                                              const property = isRTL() ? "paddingLeft" : "paddingRight";
                                                                                              this._element.style[property] = `${scrollbarWidth}px`;
                                                                                            }
                                                                                      public/assets/application-83027ab76a0c0e3ffb5bae510e4627be2c66fe2cccf3e0d566ea67ed819ad3e1.js on lines 3785..3788

                                                                                      Duplicated Code

                                                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                      Tuning

                                                                                      This issue has a mass of 48.

                                                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                      Refactorings

                                                                                      Further Reading

                                                                                      Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                      Open

                                                                                            if (!isBodyOverflowing && isModalOverflowing) {
                                                                                              const property = isRTL() ? "paddingRight" : "paddingLeft";
                                                                                              this._element.style[property] = `${scrollbarWidth}px`;
                                                                                            }
                                                                                      public/assets/application-83027ab76a0c0e3ffb5bae510e4627be2c66fe2cccf3e0d566ea67ed819ad3e1.js on lines 3781..3784

                                                                                      Duplicated Code

                                                                                      Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                      Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                      When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                      Tuning

                                                                                      This issue has a mass of 48.

                                                                                      We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                      The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                      If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                      See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                      Refactorings

                                                                                      Further Reading

                                                                                      There are no issues that match your filters.

                                                                                      Category
                                                                                      Status