XingFramework/xing-frontend-utils

View on GitHub
dist/xing-frontend-utils.js

Summary

Maintainability
F
3 mos
Test Coverage

File xing-frontend-utils.js has 3326 lines of code (exceeds 250 allowed). Consider refactoring.
Open

(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.xingFrontendUtils = f()}})(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
(function(e, a) { for(var i in a) e[i] = a[i]; }(exports, /******/ (function(modules) { // webpackBootstrap
/******/     // The module cache
/******/     var installedModules = {};
/******/
Severity: Major
Found in dist/xing-frontend-utils.js - About 1 wk to fix

    Function 1 has 1831 lines of code (exceeds 25 allowed). Consider refactoring.
    Open

    (function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.xingFrontendUtils = f()}})(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
    (function(e, a) { for(var i in a) e[i] = a[i]; }(exports, /******/ (function(modules) { // webpackBootstrap
    /******/     // The module cache
    /******/     var installedModules = {};
    /******/
    Severity: Major
    Found in dist/xing-frontend-utils.js - About 1 wk to fix

      Function 23 has 247 lines of code (exceeds 25 allowed). Consider refactoring.
      Open

      },{}],23:[function(require,module,exports){
      'use strict';
      
      Object.defineProperty(exports, '__esModule', {
        value: true
      Severity: Major
      Found in dist/xing-frontend-utils.js - About 1 day to fix

        Function SerializerProvider has 210 lines of code (exceeds 25 allowed). Consider refactoring.
        Open

        var SerializerProvider = (function () {
          function SerializerProvider() {
            _classCallCheck(this, _SerializerProvider);
        
            var defaultOptions = {
        Severity: Major
        Found in dist/xing-frontend-utils.js - About 1 day to fix

          Function SerializerProvider has 205 lines of code (exceeds 25 allowed). Consider refactoring.
          Open

            function SerializerProvider() {
              _classCallCheck(this, _SerializerProvider);
          
              var defaultOptions = {
                underscore: undefined,
          Severity: Major
          Found in dist/xing-frontend-utils.js - About 1 day to fix

            Function $get has 180 lines of code (exceeds 25 allowed). Consider refactoring.
            Open

                this.$get = ['$injector', 'Inflector', function ($injector, Inflector) {
                  defaultOptions.underscore = defaultOptions.underscore || Inflector.underscore;
                  defaultOptions.camelize = defaultOptions.camelize || Inflector.camelize;
                  defaultOptions.pluralize = defaultOptions.pluralize || Inflector.pluralize;
            
            
            Severity: Major
            Found in dist/xing-frontend-utils.js - About 7 hrs to fix

              Function Injector has 166 lines of code (exceeds 25 allowed). Consider refactoring.
              Open

                  var Injector = (function () {
                    function Injector() {
                      var appNamePrefix = arguments.length <= 0 || arguments[0] === undefined ? "" : arguments[0];
              
                      _classCallCheck(this, Injector);
              Severity: Major
              Found in dist/xing-frontend-utils.js - About 6 hrs to fix

                Function ComponentMapper has 166 lines of code (exceeds 25 allowed). Consider refactoring.
                Open

                    var ComponentMapper = (function () {
                      function ComponentMapper() {
                        _classCallCheck(this, ComponentMapper);
                      }
                
                
                Severity: Major
                Found in dist/xing-frontend-utils.js - About 6 hrs to fix

                  Function 20 has 143 lines of code (exceeds 25 allowed). Consider refactoring.
                  Open

                  },{}],20:[function(require,module,exports){
                  'use strict';
                  
                  Object.defineProperty(exports, '__esModule', {
                    value: true
                  Severity: Major
                  Found in dist/xing-frontend-utils.js - About 5 hrs to fix

                    Function 24 has 104 lines of code (exceeds 25 allowed). Consider refactoring.
                    Open

                    },{"a1atscript":1,"xing-inflector":2}],24:[function(require,module,exports){
                    'use strict';
                    
                    Object.defineProperty(exports, '__esModule', {
                      value: true
                    Severity: Major
                    Found in dist/xing-frontend-utils.js - About 4 hrs to fix

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

                      },{"./errorLimiter.js":22,"a1atscript":1}],26:[function(require,module,exports){
                      'use strict';
                      
                      Object.defineProperty(exports, '__esModule', {
                        value: true
                      Severity: Major
                      Found in dist/xing-frontend-utils.js - About 4 hrs to fix

                        Function Ng2DirectiveDefinitionObject has 93 lines of code (exceeds 25 allowed). Consider refactoring.
                        Open

                            var Ng2DirectiveDefinitionObject = (function () {
                              function Ng2DirectiveDefinitionObject(controller, annotation) {
                                var template = arguments.length <= 2 || arguments[2] === undefined ? {} : arguments[2];
                                var bind = arguments.length <= 3 || arguments[3] === undefined ? null : arguments[3];
                        
                        
                        Severity: Major
                        Found in dist/xing-frontend-utils.js - About 3 hrs to fix

                          Function 17 has 87 lines of code (exceeds 25 allowed). Consider refactoring.
                          Open

                          },{}],17:[function(require,module,exports){
                          'use strict';
                          
                          require('./compiler.js');
                          
                          
                          Severity: Major
                          Found in dist/xing-frontend-utils.js - About 3 hrs to fix

                            Function InterimElementFactory has 83 lines of code (exceeds 25 allowed). Consider refactoring.
                            Open

                            function InterimElementFactory($q, $rootScope, $timeout, $rootElement, $animate, $xngCompiler) {
                            
                              return function createInterimElementService(defaults) {
                            
                                /**
                            Severity: Major
                            Found in dist/xing-frontend-utils.js - About 3 hrs to fix

                              Function createInterimElementService has 81 lines of code (exceeds 25 allowed). Consider refactoring.
                              Open

                                return function createInterimElementService(defaults) {
                              
                                  /**
                                   * @ngdoc service
                                   * @name $$interimElement.$service
                              Severity: Major
                              Found in dist/xing-frontend-utils.js - About 3 hrs to fix

                                Function 22 has 79 lines of code (exceeds 25 allowed). Consider refactoring.
                                Open

                                },{"a1atscript":1}],22:[function(require,module,exports){
                                "use strict";
                                
                                Object.defineProperty(exports, "__esModule", {
                                  value: true
                                Severity: Major
                                Found in dist/xing-frontend-utils.js - About 3 hrs to fix

                                  Function 19 has 78 lines of code (exceeds 25 allowed). Consider refactoring.
                                  Open

                                  },{}],19:[function(require,module,exports){
                                  "use strict";
                                  
                                  (function () {
                                  
                                  
                                  Severity: Major
                                  Found in dist/xing-frontend-utils.js - About 3 hrs to fix

                                    Function xngToastService has 78 lines of code (exceeds 25 allowed). Consider refactoring.
                                    Open

                                    function xngToastService($timeout, $$interimElement, $animate, $xngSwipe, Inflector) {
                                    
                                      var factoryDef = {
                                        onShow: onShow,
                                        onRemove: onRemove,
                                    Severity: Major
                                    Found in dist/xing-frontend-utils.js - About 3 hrs to fix

                                      Function 3 has 77 lines of code (exceeds 25 allowed). Consider refactoring.
                                      Open

                                      },{"a1atscript":1}],3:[function(require,module,exports){
                                      "use strict";
                                      
                                      Object.defineProperty(exports, "__esModule", {
                                        value: true
                                      Severity: Major
                                      Found in dist/xing-frontend-utils.js - About 3 hrs to fix

                                        Function RouteInitializer has 76 lines of code (exceeds 25 allowed). Consider refactoring.
                                        Open

                                            var RouteInitializer = (function () {
                                              function RouteInitializer(componentMapper) {
                                                _classCallCheck(this, RouteInitializer);
                                        
                                                this.componentMapper = componentMapper;
                                        Severity: Major
                                        Found in dist/xing-frontend-utils.js - About 3 hrs to fix

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

                                          },{"a1atscript":1}],27:[function(require,module,exports){
                                          'use strict';
                                          
                                          Object.defineProperty(exports, '__esModule', {
                                            value: true
                                          Severity: Major
                                          Found in dist/xing-frontend-utils.js - About 2 hrs to fix

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

                                            },{}],2:[function(require,module,exports){
                                            'use strict';
                                            
                                            Object.defineProperty(exports, '__esModule', {
                                              value: true
                                            Severity: Major
                                            Found in dist/xing-frontend-utils.js - About 2 hrs to fix

                                              Function DirectiveObjectInjector has 60 lines of code (exceeds 25 allowed). Consider refactoring.
                                              Open

                                                  var DirectiveObjectInjector = (function (_ListInjector) {
                                                    _inherits(DirectiveObjectInjector, _ListInjector);
                                              
                                                    function DirectiveObjectInjector() {
                                                      _classCallCheck(this, DirectiveObjectInjector);
                                              Severity: Major
                                              Found in dist/xing-frontend-utils.js - About 2 hrs to fix

                                                Function ErrorLimiter has 58 lines of code (exceeds 25 allowed). Consider refactoring.
                                                Open

                                                var ErrorLimiter = (function () {
                                                  function ErrorLimiter(uiState, failsafeStateName) {
                                                    _classCallCheck(this, ErrorLimiter);
                                                
                                                    this.uiState = uiState;
                                                Severity: Major
                                                Found in dist/xing-frontend-utils.js - About 2 hrs to fix

                                                  Function uiRouteLogger has 56 lines of code (exceeds 25 allowed). Consider refactoring.
                                                  Open

                                                  function uiRouteLogger($rootScope, $state, noTable) {
                                                    if (noTable) {
                                                      $rootScope.$on('$stateChangeStart', function (event, toState, toParams, fromState, fromParams) {
                                                        /*jshint -W075 */
                                                        console.log("Routing Event", event.name);
                                                  Severity: Major
                                                  Found in dist/xing-frontend-utils.js - About 2 hrs to fix

                                                    Function 13 has 55 lines of code (exceeds 25 allowed). Consider refactoring.
                                                    Open

                                                    },{"./responsive-menu.tpl.js":11,"a1atscript":1}],13:[function(require,module,exports){
                                                    'use strict';
                                                    
                                                    Object.defineProperty(exports, '__esModule', {
                                                      value: true
                                                    Severity: Major
                                                    Found in dist/xing-frontend-utils.js - About 2 hrs to fix

                                                      Function ComponentInjector has 53 lines of code (exceeds 25 allowed). Consider refactoring.
                                                      Open

                                                          var ComponentInjector = (function (_ListInjector) {
                                                            _inherits(ComponentInjector, _ListInjector);
                                                      
                                                            function ComponentInjector() {
                                                              _classCallCheck(this, ComponentInjector);
                                                      Severity: Major
                                                      Found in dist/xing-frontend-utils.js - About 2 hrs to fix

                                                        Function Inflector has 53 lines of code (exceeds 25 allowed). Consider refactoring.
                                                        Open

                                                        var Inflector = (function () {
                                                          function Inflector() {
                                                            _classCallCheck(this, _Inflector);
                                                          }
                                                        
                                                        
                                                        Severity: Major
                                                        Found in dist/xing-frontend-utils.js - About 2 hrs to fix

                                                          Function 14 has 48 lines of code (exceeds 25 allowed). Consider refactoring.
                                                          Open

                                                          },{"a1atscript":1}],14:[function(require,module,exports){
                                                          'use strict';
                                                          
                                                          function xngCompilerService($q, $http, $injector, $compile, $controller, $templateCache) {
                                                          
                                                          
                                                          Severity: Minor
                                                          Found in dist/xing-frontend-utils.js - About 1 hr to fix

                                                            Function RouteReader has 48 lines of code (exceeds 25 allowed). Consider refactoring.
                                                            Open

                                                                var RouteReader = (function () {
                                                                  function RouteReader(componentMapper) {
                                                                    _classCallCheck(this, RouteReader);
                                                            
                                                                    this.componentMapper = componentMapper;
                                                            Severity: Minor
                                                            Found in dist/xing-frontend-utils.js - About 1 hr to fix

                                                              Function xngCompilerService has 45 lines of code (exceeds 25 allowed). Consider refactoring.
                                                              Open

                                                              function xngCompilerService($q, $http, $injector, $compile, $controller, $templateCache) {
                                                              
                                                                /**
                                                                 * @ngdoc service
                                                                 * @name $xngCompiler
                                                              Severity: Minor
                                                              Found in dist/xing-frontend-utils.js - About 1 hr to fix

                                                                Function 12 has 44 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                Open

                                                                },{}],12:[function(require,module,exports){
                                                                'use strict';
                                                                
                                                                Object.defineProperty(exports, '__esModule', {
                                                                  value: true
                                                                Severity: Minor
                                                                Found in dist/xing-frontend-utils.js - About 1 hr to fix

                                                                  Function SelectorMatcher has 44 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                  Open

                                                                      var SelectorMatcher = (function () {
                                                                        function SelectorMatcher(selector) {
                                                                          _classCallCheck(this, SelectorMatcher);
                                                                  
                                                                          this._selector = selector;
                                                                  Severity: Minor
                                                                  Found in dist/xing-frontend-utils.js - About 1 hr to fix

                                                                    Function PropertiesBuilder has 44 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                    Open

                                                                        var PropertiesBuilder = (function (_BindBuilder) {
                                                                          _inherits(PropertiesBuilder, _BindBuilder);
                                                                    
                                                                          function PropertiesBuilder() {
                                                                            _classCallCheck(this, PropertiesBuilder);
                                                                    Severity: Minor
                                                                    Found in dist/xing-frontend-utils.js - About 1 hr to fix

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

                                                                        this.compile = function (options) {
                                                                          var templateUrl = options.templateUrl;
                                                                          var template = options.template || '';
                                                                          var controller = options.controller;
                                                                          var controllerAs = options.controllerAs;
                                                                      Severity: Minor
                                                                      Found in dist/xing-frontend-utils.js - About 1 hr to fix

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

                                                                        var StateInjector = (function () {
                                                                          function StateInjector() {
                                                                            _classCallCheck(this, StateInjector);
                                                                          }
                                                                        
                                                                        
                                                                        Severity: Minor
                                                                        Found in dist/xing-frontend-utils.js - About 1 hr to fix

                                                                          Function SwipeService has 40 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                          Open

                                                                              return function SwipeService(scope, eventTypes) {
                                                                                if (!eventTypes) {
                                                                                  eventTypes = "swipeleft swiperight";
                                                                                }
                                                                          
                                                                          
                                                                          Severity: Minor
                                                                          Found in dist/xing-frontend-utils.js - About 1 hr to fix

                                                                            Function BindBuilder has 38 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                            Open

                                                                                var BindBuilder = (function () {
                                                                                  function BindBuilder(bindParam, component) {
                                                                                    _classCallCheck(this, BindBuilder);
                                                                            
                                                                                    this._bindParam = bindParam;
                                                                            Severity: Minor
                                                                            Found in dist/xing-frontend-utils.js - About 1 hr to fix

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

                                                                              },{"./error-list.tpl.js":15,"./error.tpl.js":16,"./interimElement.js":17,"./notice.tpl.js":18,"./swipe.js":19,"a1atscript":1,"xing-inflector":2}],21:[function(require,module,exports){
                                                                              'use strict';
                                                                              
                                                                              Object.defineProperty(exports, '__esModule', {
                                                                                value: true
                                                                              Severity: Minor
                                                                              Found in dist/xing-frontend-utils.js - About 1 hr to fix

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

                                                                                    function InterimElement(options) {
                                                                                      var self;
                                                                                      var hideTimeout, element;
                                                                                
                                                                                      options = options || {};
                                                                                Severity: Minor
                                                                                Found in dist/xing-frontend-utils.js - About 1 hr to fix

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

                                                                                        return function configureFor(element, onSwipeCallback, attachLater) {
                                                                                          var hammertime = new Hammer(element[0], {
                                                                                            recognizers: addRecognizers([], eventTypes)
                                                                                          });
                                                                                  
                                                                                  
                                                                                  Severity: Minor
                                                                                  Found in dist/xing-frontend-utils.js - About 1 hr to fix

                                                                                    Function setupProperty has 33 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                    Open

                                                                                            value: function setupProperty(key, properties) {
                                                                                              properties[STRING_PREFIX + key] = "@" + this.bindObj[key];
                                                                                              properties[BIND_PREFIX + key] = "=?bind" + this.bindObj[key][0].toUpperCase() + this.bindObj[key].slice(1);
                                                                                    
                                                                                              // This property is used when user uses the `bind-property` attribute on a directive to bind an expression
                                                                                    Severity: Minor
                                                                                    Found in dist/xing-frontend-utils.js - About 1 hr to fix

                                                                                      Function StateAttrs has 33 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                      Open

                                                                                      var StateAttrs = (function () {
                                                                                        function StateAttrs($compile, $state) {
                                                                                          _classCallCheck(this, _StateAttrs);
                                                                                      
                                                                                          this.$compile = $compile;
                                                                                      Severity: Minor
                                                                                      Found in dist/xing-frontend-utils.js - About 1 hr to fix

                                                                                        Function 10 has 31 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                        Open

                                                                                        },{"../../stateInjector.js":26,"./error-fallback.tpl.js":8,"a1atscript":1}],10:[function(require,module,exports){
                                                                                        "use strict";
                                                                                        
                                                                                        Object.defineProperty(exports, "__esModule", {
                                                                                          value: true
                                                                                        Severity: Minor
                                                                                        Found in dist/xing-frontend-utils.js - About 1 hr to fix

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

                                                                                              var AnnotationFinder = (function () {
                                                                                                function AnnotationFinder(AnnotatedClass) {
                                                                                                  _classCallCheck(this, AnnotationFinder);
                                                                                          
                                                                                                  this.AnnotatedClass = AnnotatedClass;
                                                                                          Severity: Minor
                                                                                          Found in dist/xing-frontend-utils.js - About 1 hr to fix

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

                                                                                            },{}],9:[function(require,module,exports){
                                                                                            'use strict';
                                                                                            
                                                                                            Object.defineProperty(exports, '__esModule', {
                                                                                              value: true
                                                                                            Severity: Minor
                                                                                            Found in dist/xing-frontend-utils.js - About 1 hr to fix

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

                                                                                                  var ComponentMapping = (function () {
                                                                                                    function ComponentMapping(component, componentMapper) {
                                                                                                      _classCallCheck(this, ComponentMapping);
                                                                                              
                                                                                                      this.component = component;
                                                                                              Severity: Minor
                                                                                              Found in dist/xing-frontend-utils.js - About 1 hr to fix

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

                                                                                                },{"a1atscript":1}],7:[function(require,module,exports){
                                                                                                'use strict';
                                                                                                
                                                                                                Object.defineProperty(exports, '__esModule', {
                                                                                                  value: true
                                                                                                Severity: Minor
                                                                                                Found in dist/xing-frontend-utils.js - About 1 hr to fix

                                                                                                  Function InterimElementFactory has 6 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                  Open

                                                                                                  function InterimElementFactory($q, $rootScope, $timeout, $rootElement, $animate, $xngCompiler) {
                                                                                                  Severity: Minor
                                                                                                  Found in dist/xing-frontend-utils.js - About 45 mins to fix

                                                                                                    Function xngCompilerService has 6 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                    Open

                                                                                                    function xngCompilerService($q, $http, $injector, $compile, $controller, $templateCache) {
                                                                                                    Severity: Minor
                                                                                                    Found in dist/xing-frontend-utils.js - About 45 mins to fix

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

                                                                                                          value: function link(scope, element, attrs, controller, transcludeFn) {
                                                                                                      Severity: Minor
                                                                                                      Found in dist/xing-frontend-utils.js - About 35 mins to fix

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

                                                                                                        function xngToastService($timeout, $$interimElement, $animate, $xngSwipe, Inflector) {
                                                                                                        Severity: Minor
                                                                                                        Found in dist/xing-frontend-utils.js - About 35 mins to fix

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

                                                                                                              this.$get = ['$injector', 'Inflector', function ($injector, Inflector) {
                                                                                                                defaultOptions.underscore = defaultOptions.underscore || Inflector.underscore;
                                                                                                                defaultOptions.camelize = defaultOptions.camelize || Inflector.camelize;
                                                                                                                defaultOptions.pluralize = defaultOptions.pluralize || Inflector.pluralize;
                                                                                                          
                                                                                                          
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 1 other location - About 1 wk to fix
                                                                                                          src/xing-frontend-utils/serializer.js on lines 64..430

                                                                                                          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 1899.

                                                                                                          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

                                                                                                          function xngCompilerService($q, $http, $injector, $compile, $controller, $templateCache) {
                                                                                                          
                                                                                                            /**
                                                                                                             * @ngdoc service
                                                                                                             * @name $xngCompiler
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 1 other location - About 3 days to fix
                                                                                                          src/xing-frontend-utils/components/toast/compiler.js on lines 1..132

                                                                                                          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 522.

                                                                                                          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 function SwipeService(scope, eventTypes) {
                                                                                                                if (!eventTypes) {
                                                                                                                  eventTypes = "swipeleft swiperight";
                                                                                                                }
                                                                                                          
                                                                                                          
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 1 other location - About 2 days to fix
                                                                                                          src/xing-frontend-utils/components/toast/swipe.js on lines 33..103

                                                                                                          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 375.

                                                                                                          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 7 locations. Consider refactoring.
                                                                                                          Open

                                                                                                              var _get = function get(_x2, _x3, _x4) { var _again = true; _function: while (_again) { var object = _x2, property = _x3, receiver = _x4; desc = parent = getter = undefined; _again = false; if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x2 = parent; _x3 = property; _x4 = receiver; _again = true; continue _function; } } else if ('value' in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } };
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 6 other locations - About 1 day to fix
                                                                                                          dist/xing-frontend-utils.js on lines 238..238
                                                                                                          dist/xing-frontend-utils.js on lines 932..932
                                                                                                          dist/xing-frontend-utils.js on lines 1545..1545
                                                                                                          dist/xing-frontend-utils.js on lines 2064..2064
                                                                                                          dist/xing-frontend-utils.js on lines 2220..2220
                                                                                                          dist/xing-frontend-utils.js on lines 2269..2269

                                                                                                          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 243.

                                                                                                          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 7 locations. Consider refactoring.
                                                                                                          Open

                                                                                                              var _get = function get(_x2, _x3, _x4) { var _again = true; _function: while (_again) { var object = _x2, property = _x3, receiver = _x4; desc = parent = getter = undefined; _again = false; if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x2 = parent; _x3 = property; _x4 = receiver; _again = true; continue _function; } } else if ('value' in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } };
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 6 other locations - About 1 day to fix
                                                                                                          dist/xing-frontend-utils.js on lines 238..238
                                                                                                          dist/xing-frontend-utils.js on lines 566..566
                                                                                                          dist/xing-frontend-utils.js on lines 932..932
                                                                                                          dist/xing-frontend-utils.js on lines 1545..1545
                                                                                                          dist/xing-frontend-utils.js on lines 2064..2064
                                                                                                          dist/xing-frontend-utils.js on lines 2220..2220

                                                                                                          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 243.

                                                                                                          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 7 locations. Consider refactoring.
                                                                                                          Open

                                                                                                              var _get = function get(_x, _x2, _x3) { var _again = true; _function: while (_again) { var object = _x, property = _x2, receiver = _x3; desc = parent = getter = undefined; _again = false; if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x = parent; _x2 = property; _x3 = receiver; _again = true; continue _function; } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } };
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 6 other locations - About 1 day to fix
                                                                                                          dist/xing-frontend-utils.js on lines 238..238
                                                                                                          dist/xing-frontend-utils.js on lines 566..566
                                                                                                          dist/xing-frontend-utils.js on lines 932..932
                                                                                                          dist/xing-frontend-utils.js on lines 1545..1545
                                                                                                          dist/xing-frontend-utils.js on lines 2220..2220
                                                                                                          dist/xing-frontend-utils.js on lines 2269..2269

                                                                                                          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 243.

                                                                                                          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 7 locations. Consider refactoring.
                                                                                                          Open

                                                                                                              var _get = function get(_x, _x2, _x3) { var _again = true; _function: while (_again) { var object = _x, property = _x2, receiver = _x3; desc = parent = getter = undefined; _again = false; if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x = parent; _x2 = property; _x3 = receiver; _again = true; continue _function; } } else if ('value' in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } };
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 6 other locations - About 1 day to fix
                                                                                                          dist/xing-frontend-utils.js on lines 566..566
                                                                                                          dist/xing-frontend-utils.js on lines 932..932
                                                                                                          dist/xing-frontend-utils.js on lines 1545..1545
                                                                                                          dist/xing-frontend-utils.js on lines 2064..2064
                                                                                                          dist/xing-frontend-utils.js on lines 2220..2220
                                                                                                          dist/xing-frontend-utils.js on lines 2269..2269

                                                                                                          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 243.

                                                                                                          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 7 locations. Consider refactoring.
                                                                                                          Open

                                                                                                              var _get = function get(_x, _x2, _x3) { var _again = true; _function: while (_again) { var object = _x, property = _x2, receiver = _x3; desc = parent = getter = undefined; _again = false; if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x = parent; _x2 = property; _x3 = receiver; _again = true; continue _function; } } else if ('value' in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } };
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 6 other locations - About 1 day to fix
                                                                                                          dist/xing-frontend-utils.js on lines 238..238
                                                                                                          dist/xing-frontend-utils.js on lines 566..566
                                                                                                          dist/xing-frontend-utils.js on lines 1545..1545
                                                                                                          dist/xing-frontend-utils.js on lines 2064..2064
                                                                                                          dist/xing-frontend-utils.js on lines 2220..2220
                                                                                                          dist/xing-frontend-utils.js on lines 2269..2269

                                                                                                          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 243.

                                                                                                          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 7 locations. Consider refactoring.
                                                                                                          Open

                                                                                                              var _get = function get(_x, _x2, _x3) { var _again = true; _function: while (_again) { var object = _x, property = _x2, receiver = _x3; desc = parent = getter = undefined; _again = false; if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x = parent; _x2 = property; _x3 = receiver; _again = true; continue _function; } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } };
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 6 other locations - About 1 day to fix
                                                                                                          dist/xing-frontend-utils.js on lines 238..238
                                                                                                          dist/xing-frontend-utils.js on lines 566..566
                                                                                                          dist/xing-frontend-utils.js on lines 932..932
                                                                                                          dist/xing-frontend-utils.js on lines 1545..1545
                                                                                                          dist/xing-frontend-utils.js on lines 2064..2064
                                                                                                          dist/xing-frontend-utils.js on lines 2269..2269

                                                                                                          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 243.

                                                                                                          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 7 locations. Consider refactoring.
                                                                                                          Open

                                                                                                              var _get = function get(_x, _x2, _x3) { var _again = true; _function: while (_again) { var object = _x, property = _x2, receiver = _x3; desc = parent = getter = undefined; _again = false; if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x = parent; _x2 = property; _x3 = receiver; _again = true; continue _function; } } else if ('value' in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } };
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 6 other locations - About 1 day to fix
                                                                                                          dist/xing-frontend-utils.js on lines 238..238
                                                                                                          dist/xing-frontend-utils.js on lines 566..566
                                                                                                          dist/xing-frontend-utils.js on lines 932..932
                                                                                                          dist/xing-frontend-utils.js on lines 2064..2064
                                                                                                          dist/xing-frontend-utils.js on lines 2220..2220
                                                                                                          dist/xing-frontend-utils.js on lines 2269..2269

                                                                                                          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 243.

                                                                                                          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 19 locations. Consider refactoring.
                                                                                                          Open

                                                                                                              var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 18 other locations - About 6 hrs to fix
                                                                                                          dist/xing-frontend-utils.js on lines 236..236
                                                                                                          dist/xing-frontend-utils.js on lines 880..880
                                                                                                          dist/xing-frontend-utils.js on lines 934..934
                                                                                                          dist/xing-frontend-utils.js on lines 1309..1309
                                                                                                          dist/xing-frontend-utils.js on lines 1653..1653
                                                                                                          dist/xing-frontend-utils.js on lines 1723..1723
                                                                                                          dist/xing-frontend-utils.js on lines 1828..1828
                                                                                                          dist/xing-frontend-utils.js on lines 1936..1936
                                                                                                          dist/xing-frontend-utils.js on lines 2062..2062
                                                                                                          dist/xing-frontend-utils.js on lines 2154..2154
                                                                                                          dist/xing-frontend-utils.js on lines 2218..2218
                                                                                                          dist/xing-frontend-utils.js on lines 2267..2267
                                                                                                          dist/xing-frontend-utils.js on lines 2464..2464
                                                                                                          dist/xing-frontend-utils.js on lines 2889..2897
                                                                                                          dist/xing-frontend-utils.js on lines 2948..2956
                                                                                                          dist/xing-frontend-utils.js on lines 3861..3869
                                                                                                          dist/xing-frontend-utils.js on lines 3910..3918
                                                                                                          dist/xing-frontend-utils.js on lines 4648..4656

                                                                                                          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 171.

                                                                                                          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 19 locations. Consider refactoring.
                                                                                                          Open

                                                                                                              var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 18 other locations - About 6 hrs to fix
                                                                                                          dist/xing-frontend-utils.js on lines 338..338
                                                                                                          dist/xing-frontend-utils.js on lines 880..880
                                                                                                          dist/xing-frontend-utils.js on lines 934..934
                                                                                                          dist/xing-frontend-utils.js on lines 1309..1309
                                                                                                          dist/xing-frontend-utils.js on lines 1653..1653
                                                                                                          dist/xing-frontend-utils.js on lines 1723..1723
                                                                                                          dist/xing-frontend-utils.js on lines 1828..1828
                                                                                                          dist/xing-frontend-utils.js on lines 1936..1936
                                                                                                          dist/xing-frontend-utils.js on lines 2062..2062
                                                                                                          dist/xing-frontend-utils.js on lines 2154..2154
                                                                                                          dist/xing-frontend-utils.js on lines 2218..2218
                                                                                                          dist/xing-frontend-utils.js on lines 2267..2267
                                                                                                          dist/xing-frontend-utils.js on lines 2464..2464
                                                                                                          dist/xing-frontend-utils.js on lines 2889..2897
                                                                                                          dist/xing-frontend-utils.js on lines 2948..2956
                                                                                                          dist/xing-frontend-utils.js on lines 3861..3869
                                                                                                          dist/xing-frontend-utils.js on lines 3910..3918
                                                                                                          dist/xing-frontend-utils.js on lines 4648..4656

                                                                                                          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 171.

                                                                                                          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 19 locations. Consider refactoring.
                                                                                                          Open

                                                                                                              var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 18 other locations - About 6 hrs to fix
                                                                                                          dist/xing-frontend-utils.js on lines 236..236
                                                                                                          dist/xing-frontend-utils.js on lines 338..338
                                                                                                          dist/xing-frontend-utils.js on lines 880..880
                                                                                                          dist/xing-frontend-utils.js on lines 934..934
                                                                                                          dist/xing-frontend-utils.js on lines 1309..1309
                                                                                                          dist/xing-frontend-utils.js on lines 1723..1723
                                                                                                          dist/xing-frontend-utils.js on lines 1828..1828
                                                                                                          dist/xing-frontend-utils.js on lines 1936..1936
                                                                                                          dist/xing-frontend-utils.js on lines 2062..2062
                                                                                                          dist/xing-frontend-utils.js on lines 2154..2154
                                                                                                          dist/xing-frontend-utils.js on lines 2218..2218
                                                                                                          dist/xing-frontend-utils.js on lines 2267..2267
                                                                                                          dist/xing-frontend-utils.js on lines 2464..2464
                                                                                                          dist/xing-frontend-utils.js on lines 2889..2897
                                                                                                          dist/xing-frontend-utils.js on lines 2948..2956
                                                                                                          dist/xing-frontend-utils.js on lines 3861..3869
                                                                                                          dist/xing-frontend-utils.js on lines 3910..3918
                                                                                                          dist/xing-frontend-utils.js on lines 4648..4656

                                                                                                          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 171.

                                                                                                          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 19 locations. Consider refactoring.
                                                                                                          Open

                                                                                                          var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 18 other locations - About 6 hrs to fix
                                                                                                          dist/xing-frontend-utils.js on lines 236..236
                                                                                                          dist/xing-frontend-utils.js on lines 338..338
                                                                                                          dist/xing-frontend-utils.js on lines 880..880
                                                                                                          dist/xing-frontend-utils.js on lines 934..934
                                                                                                          dist/xing-frontend-utils.js on lines 1309..1309
                                                                                                          dist/xing-frontend-utils.js on lines 1653..1653
                                                                                                          dist/xing-frontend-utils.js on lines 1723..1723
                                                                                                          dist/xing-frontend-utils.js on lines 1828..1828
                                                                                                          dist/xing-frontend-utils.js on lines 1936..1936
                                                                                                          dist/xing-frontend-utils.js on lines 2062..2062
                                                                                                          dist/xing-frontend-utils.js on lines 2154..2154
                                                                                                          dist/xing-frontend-utils.js on lines 2218..2218
                                                                                                          dist/xing-frontend-utils.js on lines 2267..2267
                                                                                                          dist/xing-frontend-utils.js on lines 2889..2897
                                                                                                          dist/xing-frontend-utils.js on lines 2948..2956
                                                                                                          dist/xing-frontend-utils.js on lines 3861..3869
                                                                                                          dist/xing-frontend-utils.js on lines 3910..3918
                                                                                                          dist/xing-frontend-utils.js on lines 4648..4656

                                                                                                          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 171.

                                                                                                          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 19 locations. Consider refactoring.
                                                                                                          Open

                                                                                                              var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 18 other locations - About 6 hrs to fix
                                                                                                          dist/xing-frontend-utils.js on lines 236..236
                                                                                                          dist/xing-frontend-utils.js on lines 338..338
                                                                                                          dist/xing-frontend-utils.js on lines 880..880
                                                                                                          dist/xing-frontend-utils.js on lines 934..934
                                                                                                          dist/xing-frontend-utils.js on lines 1309..1309
                                                                                                          dist/xing-frontend-utils.js on lines 1653..1653
                                                                                                          dist/xing-frontend-utils.js on lines 1723..1723
                                                                                                          dist/xing-frontend-utils.js on lines 1828..1828
                                                                                                          dist/xing-frontend-utils.js on lines 1936..1936
                                                                                                          dist/xing-frontend-utils.js on lines 2062..2062
                                                                                                          dist/xing-frontend-utils.js on lines 2154..2154
                                                                                                          dist/xing-frontend-utils.js on lines 2267..2267
                                                                                                          dist/xing-frontend-utils.js on lines 2464..2464
                                                                                                          dist/xing-frontend-utils.js on lines 2889..2897
                                                                                                          dist/xing-frontend-utils.js on lines 2948..2956
                                                                                                          dist/xing-frontend-utils.js on lines 3861..3869
                                                                                                          dist/xing-frontend-utils.js on lines 3910..3918
                                                                                                          dist/xing-frontend-utils.js on lines 4648..4656

                                                                                                          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 171.

                                                                                                          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 19 locations. Consider refactoring.
                                                                                                          Open

                                                                                                              var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 18 other locations - About 6 hrs to fix
                                                                                                          dist/xing-frontend-utils.js on lines 236..236
                                                                                                          dist/xing-frontend-utils.js on lines 338..338
                                                                                                          dist/xing-frontend-utils.js on lines 880..880
                                                                                                          dist/xing-frontend-utils.js on lines 934..934
                                                                                                          dist/xing-frontend-utils.js on lines 1309..1309
                                                                                                          dist/xing-frontend-utils.js on lines 1653..1653
                                                                                                          dist/xing-frontend-utils.js on lines 1723..1723
                                                                                                          dist/xing-frontend-utils.js on lines 1828..1828
                                                                                                          dist/xing-frontend-utils.js on lines 1936..1936
                                                                                                          dist/xing-frontend-utils.js on lines 2062..2062
                                                                                                          dist/xing-frontend-utils.js on lines 2154..2154
                                                                                                          dist/xing-frontend-utils.js on lines 2218..2218
                                                                                                          dist/xing-frontend-utils.js on lines 2464..2464
                                                                                                          dist/xing-frontend-utils.js on lines 2889..2897
                                                                                                          dist/xing-frontend-utils.js on lines 2948..2956
                                                                                                          dist/xing-frontend-utils.js on lines 3861..3869
                                                                                                          dist/xing-frontend-utils.js on lines 3910..3918
                                                                                                          dist/xing-frontend-utils.js on lines 4648..4656

                                                                                                          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 171.

                                                                                                          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 19 locations. Consider refactoring.
                                                                                                          Open

                                                                                                              var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 18 other locations - About 6 hrs to fix
                                                                                                          dist/xing-frontend-utils.js on lines 236..236
                                                                                                          dist/xing-frontend-utils.js on lines 338..338
                                                                                                          dist/xing-frontend-utils.js on lines 880..880
                                                                                                          dist/xing-frontend-utils.js on lines 934..934
                                                                                                          dist/xing-frontend-utils.js on lines 1309..1309
                                                                                                          dist/xing-frontend-utils.js on lines 1653..1653
                                                                                                          dist/xing-frontend-utils.js on lines 1723..1723
                                                                                                          dist/xing-frontend-utils.js on lines 1936..1936
                                                                                                          dist/xing-frontend-utils.js on lines 2062..2062
                                                                                                          dist/xing-frontend-utils.js on lines 2154..2154
                                                                                                          dist/xing-frontend-utils.js on lines 2218..2218
                                                                                                          dist/xing-frontend-utils.js on lines 2267..2267
                                                                                                          dist/xing-frontend-utils.js on lines 2464..2464
                                                                                                          dist/xing-frontend-utils.js on lines 2889..2897
                                                                                                          dist/xing-frontend-utils.js on lines 2948..2956
                                                                                                          dist/xing-frontend-utils.js on lines 3861..3869
                                                                                                          dist/xing-frontend-utils.js on lines 3910..3918
                                                                                                          dist/xing-frontend-utils.js on lines 4648..4656

                                                                                                          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 171.

                                                                                                          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 19 locations. Consider refactoring.
                                                                                                          Open

                                                                                                              var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 18 other locations - About 6 hrs to fix
                                                                                                          dist/xing-frontend-utils.js on lines 236..236
                                                                                                          dist/xing-frontend-utils.js on lines 338..338
                                                                                                          dist/xing-frontend-utils.js on lines 934..934
                                                                                                          dist/xing-frontend-utils.js on lines 1309..1309
                                                                                                          dist/xing-frontend-utils.js on lines 1653..1653
                                                                                                          dist/xing-frontend-utils.js on lines 1723..1723
                                                                                                          dist/xing-frontend-utils.js on lines 1828..1828
                                                                                                          dist/xing-frontend-utils.js on lines 1936..1936
                                                                                                          dist/xing-frontend-utils.js on lines 2062..2062
                                                                                                          dist/xing-frontend-utils.js on lines 2154..2154
                                                                                                          dist/xing-frontend-utils.js on lines 2218..2218
                                                                                                          dist/xing-frontend-utils.js on lines 2267..2267
                                                                                                          dist/xing-frontend-utils.js on lines 2464..2464
                                                                                                          dist/xing-frontend-utils.js on lines 2889..2897
                                                                                                          dist/xing-frontend-utils.js on lines 2948..2956
                                                                                                          dist/xing-frontend-utils.js on lines 3861..3869
                                                                                                          dist/xing-frontend-utils.js on lines 3910..3918
                                                                                                          dist/xing-frontend-utils.js on lines 4648..4656

                                                                                                          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 171.

                                                                                                          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 19 locations. Consider refactoring.
                                                                                                          Open

                                                                                                              var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 18 other locations - About 6 hrs to fix
                                                                                                          dist/xing-frontend-utils.js on lines 236..236
                                                                                                          dist/xing-frontend-utils.js on lines 338..338
                                                                                                          dist/xing-frontend-utils.js on lines 880..880
                                                                                                          dist/xing-frontend-utils.js on lines 934..934
                                                                                                          dist/xing-frontend-utils.js on lines 1309..1309
                                                                                                          dist/xing-frontend-utils.js on lines 1653..1653
                                                                                                          dist/xing-frontend-utils.js on lines 1828..1828
                                                                                                          dist/xing-frontend-utils.js on lines 1936..1936
                                                                                                          dist/xing-frontend-utils.js on lines 2062..2062
                                                                                                          dist/xing-frontend-utils.js on lines 2154..2154
                                                                                                          dist/xing-frontend-utils.js on lines 2218..2218
                                                                                                          dist/xing-frontend-utils.js on lines 2267..2267
                                                                                                          dist/xing-frontend-utils.js on lines 2464..2464
                                                                                                          dist/xing-frontend-utils.js on lines 2889..2897
                                                                                                          dist/xing-frontend-utils.js on lines 2948..2956
                                                                                                          dist/xing-frontend-utils.js on lines 3861..3869
                                                                                                          dist/xing-frontend-utils.js on lines 3910..3918
                                                                                                          dist/xing-frontend-utils.js on lines 4648..4656

                                                                                                          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 171.

                                                                                                          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 19 locations. Consider refactoring.
                                                                                                          Open

                                                                                                              var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 18 other locations - About 6 hrs to fix
                                                                                                          dist/xing-frontend-utils.js on lines 236..236
                                                                                                          dist/xing-frontend-utils.js on lines 338..338
                                                                                                          dist/xing-frontend-utils.js on lines 880..880
                                                                                                          dist/xing-frontend-utils.js on lines 1309..1309
                                                                                                          dist/xing-frontend-utils.js on lines 1653..1653
                                                                                                          dist/xing-frontend-utils.js on lines 1723..1723
                                                                                                          dist/xing-frontend-utils.js on lines 1828..1828
                                                                                                          dist/xing-frontend-utils.js on lines 1936..1936
                                                                                                          dist/xing-frontend-utils.js on lines 2062..2062
                                                                                                          dist/xing-frontend-utils.js on lines 2154..2154
                                                                                                          dist/xing-frontend-utils.js on lines 2218..2218
                                                                                                          dist/xing-frontend-utils.js on lines 2267..2267
                                                                                                          dist/xing-frontend-utils.js on lines 2464..2464
                                                                                                          dist/xing-frontend-utils.js on lines 2889..2897
                                                                                                          dist/xing-frontend-utils.js on lines 2948..2956
                                                                                                          dist/xing-frontend-utils.js on lines 3861..3869
                                                                                                          dist/xing-frontend-utils.js on lines 3910..3918
                                                                                                          dist/xing-frontend-utils.js on lines 4648..4656

                                                                                                          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 171.

                                                                                                          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 19 locations. Consider refactoring.
                                                                                                          Open

                                                                                                              var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 18 other locations - About 6 hrs to fix
                                                                                                          dist/xing-frontend-utils.js on lines 236..236
                                                                                                          dist/xing-frontend-utils.js on lines 338..338
                                                                                                          dist/xing-frontend-utils.js on lines 880..880
                                                                                                          dist/xing-frontend-utils.js on lines 934..934
                                                                                                          dist/xing-frontend-utils.js on lines 1309..1309
                                                                                                          dist/xing-frontend-utils.js on lines 1653..1653
                                                                                                          dist/xing-frontend-utils.js on lines 1723..1723
                                                                                                          dist/xing-frontend-utils.js on lines 1828..1828
                                                                                                          dist/xing-frontend-utils.js on lines 2062..2062
                                                                                                          dist/xing-frontend-utils.js on lines 2154..2154
                                                                                                          dist/xing-frontend-utils.js on lines 2218..2218
                                                                                                          dist/xing-frontend-utils.js on lines 2267..2267
                                                                                                          dist/xing-frontend-utils.js on lines 2464..2464
                                                                                                          dist/xing-frontend-utils.js on lines 2889..2897
                                                                                                          dist/xing-frontend-utils.js on lines 2948..2956
                                                                                                          dist/xing-frontend-utils.js on lines 3861..3869
                                                                                                          dist/xing-frontend-utils.js on lines 3910..3918
                                                                                                          dist/xing-frontend-utils.js on lines 4648..4656

                                                                                                          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 171.

                                                                                                          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 19 locations. Consider refactoring.
                                                                                                          Open

                                                                                                              var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 18 other locations - About 6 hrs to fix
                                                                                                          dist/xing-frontend-utils.js on lines 236..236
                                                                                                          dist/xing-frontend-utils.js on lines 338..338
                                                                                                          dist/xing-frontend-utils.js on lines 880..880
                                                                                                          dist/xing-frontend-utils.js on lines 934..934
                                                                                                          dist/xing-frontend-utils.js on lines 1309..1309
                                                                                                          dist/xing-frontend-utils.js on lines 1653..1653
                                                                                                          dist/xing-frontend-utils.js on lines 1723..1723
                                                                                                          dist/xing-frontend-utils.js on lines 1828..1828
                                                                                                          dist/xing-frontend-utils.js on lines 1936..1936
                                                                                                          dist/xing-frontend-utils.js on lines 2154..2154
                                                                                                          dist/xing-frontend-utils.js on lines 2218..2218
                                                                                                          dist/xing-frontend-utils.js on lines 2267..2267
                                                                                                          dist/xing-frontend-utils.js on lines 2464..2464
                                                                                                          dist/xing-frontend-utils.js on lines 2889..2897
                                                                                                          dist/xing-frontend-utils.js on lines 2948..2956
                                                                                                          dist/xing-frontend-utils.js on lines 3861..3869
                                                                                                          dist/xing-frontend-utils.js on lines 3910..3918
                                                                                                          dist/xing-frontend-utils.js on lines 4648..4656

                                                                                                          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 171.

                                                                                                          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 19 locations. Consider refactoring.
                                                                                                          Open

                                                                                                              var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 18 other locations - About 6 hrs to fix
                                                                                                          dist/xing-frontend-utils.js on lines 236..236
                                                                                                          dist/xing-frontend-utils.js on lines 338..338
                                                                                                          dist/xing-frontend-utils.js on lines 880..880
                                                                                                          dist/xing-frontend-utils.js on lines 934..934
                                                                                                          dist/xing-frontend-utils.js on lines 1309..1309
                                                                                                          dist/xing-frontend-utils.js on lines 1653..1653
                                                                                                          dist/xing-frontend-utils.js on lines 1723..1723
                                                                                                          dist/xing-frontend-utils.js on lines 1828..1828
                                                                                                          dist/xing-frontend-utils.js on lines 1936..1936
                                                                                                          dist/xing-frontend-utils.js on lines 2062..2062
                                                                                                          dist/xing-frontend-utils.js on lines 2218..2218
                                                                                                          dist/xing-frontend-utils.js on lines 2267..2267
                                                                                                          dist/xing-frontend-utils.js on lines 2464..2464
                                                                                                          dist/xing-frontend-utils.js on lines 2889..2897
                                                                                                          dist/xing-frontend-utils.js on lines 2948..2956
                                                                                                          dist/xing-frontend-utils.js on lines 3861..3869
                                                                                                          dist/xing-frontend-utils.js on lines 3910..3918
                                                                                                          dist/xing-frontend-utils.js on lines 4648..4656

                                                                                                          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 171.

                                                                                                          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 19 locations. Consider refactoring.
                                                                                                          Open

                                                                                                          var _createClass = (function () {
                                                                                                            function defineProperties(target, props) {
                                                                                                              for (var i = 0; i < props.length; i++) {
                                                                                                                var descriptor = props[i];descriptor.enumerable = descriptor.enumerable || false;descriptor.configurable = true;if ('value' in descriptor) descriptor.writable = true;Object.defineProperty(target, descriptor.key, descriptor);
                                                                                                              }
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 18 other locations - About 6 hrs to fix
                                                                                                          dist/xing-frontend-utils.js on lines 236..236
                                                                                                          dist/xing-frontend-utils.js on lines 338..338
                                                                                                          dist/xing-frontend-utils.js on lines 880..880
                                                                                                          dist/xing-frontend-utils.js on lines 934..934
                                                                                                          dist/xing-frontend-utils.js on lines 1309..1309
                                                                                                          dist/xing-frontend-utils.js on lines 1653..1653
                                                                                                          dist/xing-frontend-utils.js on lines 1723..1723
                                                                                                          dist/xing-frontend-utils.js on lines 1828..1828
                                                                                                          dist/xing-frontend-utils.js on lines 1936..1936
                                                                                                          dist/xing-frontend-utils.js on lines 2062..2062
                                                                                                          dist/xing-frontend-utils.js on lines 2154..2154
                                                                                                          dist/xing-frontend-utils.js on lines 2218..2218
                                                                                                          dist/xing-frontend-utils.js on lines 2267..2267
                                                                                                          dist/xing-frontend-utils.js on lines 2464..2464
                                                                                                          dist/xing-frontend-utils.js on lines 2889..2897
                                                                                                          dist/xing-frontend-utils.js on lines 2948..2956
                                                                                                          dist/xing-frontend-utils.js on lines 3910..3918
                                                                                                          dist/xing-frontend-utils.js on lines 4648..4656

                                                                                                          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 171.

                                                                                                          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 19 locations. Consider refactoring.
                                                                                                          Open

                                                                                                          var _createClass = (function () {
                                                                                                            function defineProperties(target, props) {
                                                                                                              for (var i = 0; i < props.length; i++) {
                                                                                                                var descriptor = props[i];descriptor.enumerable = descriptor.enumerable || false;descriptor.configurable = true;if ("value" in descriptor) descriptor.writable = true;Object.defineProperty(target, descriptor.key, descriptor);
                                                                                                              }
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 18 other locations - About 6 hrs to fix
                                                                                                          dist/xing-frontend-utils.js on lines 236..236
                                                                                                          dist/xing-frontend-utils.js on lines 338..338
                                                                                                          dist/xing-frontend-utils.js on lines 880..880
                                                                                                          dist/xing-frontend-utils.js on lines 934..934
                                                                                                          dist/xing-frontend-utils.js on lines 1309..1309
                                                                                                          dist/xing-frontend-utils.js on lines 1653..1653
                                                                                                          dist/xing-frontend-utils.js on lines 1723..1723
                                                                                                          dist/xing-frontend-utils.js on lines 1828..1828
                                                                                                          dist/xing-frontend-utils.js on lines 1936..1936
                                                                                                          dist/xing-frontend-utils.js on lines 2062..2062
                                                                                                          dist/xing-frontend-utils.js on lines 2154..2154
                                                                                                          dist/xing-frontend-utils.js on lines 2218..2218
                                                                                                          dist/xing-frontend-utils.js on lines 2267..2267
                                                                                                          dist/xing-frontend-utils.js on lines 2464..2464
                                                                                                          dist/xing-frontend-utils.js on lines 2889..2897
                                                                                                          dist/xing-frontend-utils.js on lines 2948..2956
                                                                                                          dist/xing-frontend-utils.js on lines 3861..3869
                                                                                                          dist/xing-frontend-utils.js on lines 4648..4656

                                                                                                          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 171.

                                                                                                          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 19 locations. Consider refactoring.
                                                                                                          Open

                                                                                                          var _createClass = (function () {
                                                                                                            function defineProperties(target, props) {
                                                                                                              for (var i = 0; i < props.length; i++) {
                                                                                                                var descriptor = props[i];descriptor.enumerable = descriptor.enumerable || false;descriptor.configurable = true;if ('value' in descriptor) descriptor.writable = true;Object.defineProperty(target, descriptor.key, descriptor);
                                                                                                              }
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 18 other locations - About 6 hrs to fix
                                                                                                          dist/xing-frontend-utils.js on lines 236..236
                                                                                                          dist/xing-frontend-utils.js on lines 338..338
                                                                                                          dist/xing-frontend-utils.js on lines 880..880
                                                                                                          dist/xing-frontend-utils.js on lines 934..934
                                                                                                          dist/xing-frontend-utils.js on lines 1309..1309
                                                                                                          dist/xing-frontend-utils.js on lines 1653..1653
                                                                                                          dist/xing-frontend-utils.js on lines 1723..1723
                                                                                                          dist/xing-frontend-utils.js on lines 1828..1828
                                                                                                          dist/xing-frontend-utils.js on lines 1936..1936
                                                                                                          dist/xing-frontend-utils.js on lines 2062..2062
                                                                                                          dist/xing-frontend-utils.js on lines 2154..2154
                                                                                                          dist/xing-frontend-utils.js on lines 2218..2218
                                                                                                          dist/xing-frontend-utils.js on lines 2267..2267
                                                                                                          dist/xing-frontend-utils.js on lines 2464..2464
                                                                                                          dist/xing-frontend-utils.js on lines 2948..2956
                                                                                                          dist/xing-frontend-utils.js on lines 3861..3869
                                                                                                          dist/xing-frontend-utils.js on lines 3910..3918
                                                                                                          dist/xing-frontend-utils.js on lines 4648..4656

                                                                                                          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 171.

                                                                                                          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 19 locations. Consider refactoring.
                                                                                                          Open

                                                                                                          var _createClass = (function () {
                                                                                                            function defineProperties(target, props) {
                                                                                                              for (var i = 0; i < props.length; i++) {
                                                                                                                var descriptor = props[i];descriptor.enumerable = descriptor.enumerable || false;descriptor.configurable = true;if ('value' in descriptor) descriptor.writable = true;Object.defineProperty(target, descriptor.key, descriptor);
                                                                                                              }
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 18 other locations - About 6 hrs to fix
                                                                                                          dist/xing-frontend-utils.js on lines 236..236
                                                                                                          dist/xing-frontend-utils.js on lines 338..338
                                                                                                          dist/xing-frontend-utils.js on lines 880..880
                                                                                                          dist/xing-frontend-utils.js on lines 934..934
                                                                                                          dist/xing-frontend-utils.js on lines 1309..1309
                                                                                                          dist/xing-frontend-utils.js on lines 1653..1653
                                                                                                          dist/xing-frontend-utils.js on lines 1723..1723
                                                                                                          dist/xing-frontend-utils.js on lines 1828..1828
                                                                                                          dist/xing-frontend-utils.js on lines 1936..1936
                                                                                                          dist/xing-frontend-utils.js on lines 2062..2062
                                                                                                          dist/xing-frontend-utils.js on lines 2154..2154
                                                                                                          dist/xing-frontend-utils.js on lines 2218..2218
                                                                                                          dist/xing-frontend-utils.js on lines 2267..2267
                                                                                                          dist/xing-frontend-utils.js on lines 2464..2464
                                                                                                          dist/xing-frontend-utils.js on lines 2889..2897
                                                                                                          dist/xing-frontend-utils.js on lines 3861..3869
                                                                                                          dist/xing-frontend-utils.js on lines 3910..3918
                                                                                                          dist/xing-frontend-utils.js on lines 4648..4656

                                                                                                          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 171.

                                                                                                          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 19 locations. Consider refactoring.
                                                                                                          Open

                                                                                                              var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 18 other locations - About 6 hrs to fix
                                                                                                          dist/xing-frontend-utils.js on lines 236..236
                                                                                                          dist/xing-frontend-utils.js on lines 338..338
                                                                                                          dist/xing-frontend-utils.js on lines 880..880
                                                                                                          dist/xing-frontend-utils.js on lines 934..934
                                                                                                          dist/xing-frontend-utils.js on lines 1653..1653
                                                                                                          dist/xing-frontend-utils.js on lines 1723..1723
                                                                                                          dist/xing-frontend-utils.js on lines 1828..1828
                                                                                                          dist/xing-frontend-utils.js on lines 1936..1936
                                                                                                          dist/xing-frontend-utils.js on lines 2062..2062
                                                                                                          dist/xing-frontend-utils.js on lines 2154..2154
                                                                                                          dist/xing-frontend-utils.js on lines 2218..2218
                                                                                                          dist/xing-frontend-utils.js on lines 2267..2267
                                                                                                          dist/xing-frontend-utils.js on lines 2464..2464
                                                                                                          dist/xing-frontend-utils.js on lines 2889..2897
                                                                                                          dist/xing-frontend-utils.js on lines 2948..2956
                                                                                                          dist/xing-frontend-utils.js on lines 3861..3869
                                                                                                          dist/xing-frontend-utils.js on lines 3910..3918
                                                                                                          dist/xing-frontend-utils.js on lines 4648..4656

                                                                                                          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 171.

                                                                                                          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 19 locations. Consider refactoring.
                                                                                                          Open

                                                                                                          var _createClass = (function () {
                                                                                                            function defineProperties(target, props) {
                                                                                                              for (var i = 0; i < props.length; i++) {
                                                                                                                var descriptor = props[i];descriptor.enumerable = descriptor.enumerable || false;descriptor.configurable = true;if ('value' in descriptor) descriptor.writable = true;Object.defineProperty(target, descriptor.key, descriptor);
                                                                                                              }
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 18 other locations - About 6 hrs to fix
                                                                                                          dist/xing-frontend-utils.js on lines 236..236
                                                                                                          dist/xing-frontend-utils.js on lines 338..338
                                                                                                          dist/xing-frontend-utils.js on lines 880..880
                                                                                                          dist/xing-frontend-utils.js on lines 934..934
                                                                                                          dist/xing-frontend-utils.js on lines 1309..1309
                                                                                                          dist/xing-frontend-utils.js on lines 1653..1653
                                                                                                          dist/xing-frontend-utils.js on lines 1723..1723
                                                                                                          dist/xing-frontend-utils.js on lines 1828..1828
                                                                                                          dist/xing-frontend-utils.js on lines 1936..1936
                                                                                                          dist/xing-frontend-utils.js on lines 2062..2062
                                                                                                          dist/xing-frontend-utils.js on lines 2154..2154
                                                                                                          dist/xing-frontend-utils.js on lines 2218..2218
                                                                                                          dist/xing-frontend-utils.js on lines 2267..2267
                                                                                                          dist/xing-frontend-utils.js on lines 2464..2464
                                                                                                          dist/xing-frontend-utils.js on lines 2889..2897
                                                                                                          dist/xing-frontend-utils.js on lines 2948..2956
                                                                                                          dist/xing-frontend-utils.js on lines 3861..3869
                                                                                                          dist/xing-frontend-utils.js on lines 3910..3918

                                                                                                          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 171.

                                                                                                          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 8 locations. Consider refactoring.
                                                                                                          Open

                                                                                                              var FilterInjector = (function (_ListInjector11) {
                                                                                                                _inherits(FilterInjector, _ListInjector11);
                                                                                                          
                                                                                                                function FilterInjector() {
                                                                                                                  _classCallCheck(this, FilterInjector);
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 7 other locations - About 6 hrs to fix
                                                                                                          dist/xing-frontend-utils.js on lines 1047..1070
                                                                                                          dist/xing-frontend-utils.js on lines 1074..1097
                                                                                                          dist/xing-frontend-utils.js on lines 1101..1124
                                                                                                          dist/xing-frontend-utils.js on lines 1128..1151
                                                                                                          dist/xing-frontend-utils.js on lines 1155..1178
                                                                                                          dist/xing-frontend-utils.js on lines 1182..1205
                                                                                                          dist/xing-frontend-utils.js on lines 1209..1232

                                                                                                          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 162.

                                                                                                          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 8 locations. Consider refactoring.
                                                                                                          Open

                                                                                                              var ValueInjector = (function (_ListInjector8) {
                                                                                                                _inherits(ValueInjector, _ListInjector8);
                                                                                                          
                                                                                                                function ValueInjector() {
                                                                                                                  _classCallCheck(this, ValueInjector);
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 7 other locations - About 6 hrs to fix
                                                                                                          dist/xing-frontend-utils.js on lines 1047..1070
                                                                                                          dist/xing-frontend-utils.js on lines 1074..1097
                                                                                                          dist/xing-frontend-utils.js on lines 1101..1124
                                                                                                          dist/xing-frontend-utils.js on lines 1128..1151
                                                                                                          dist/xing-frontend-utils.js on lines 1182..1205
                                                                                                          dist/xing-frontend-utils.js on lines 1209..1232
                                                                                                          dist/xing-frontend-utils.js on lines 1236..1259

                                                                                                          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 162.

                                                                                                          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 8 locations. Consider refactoring.
                                                                                                          Open

                                                                                                              var ServiceInjector = (function (_ListInjector5) {
                                                                                                                _inherits(ServiceInjector, _ListInjector5);
                                                                                                          
                                                                                                                function ServiceInjector() {
                                                                                                                  _classCallCheck(this, ServiceInjector);
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 7 other locations - About 6 hrs to fix
                                                                                                          dist/xing-frontend-utils.js on lines 1047..1070
                                                                                                          dist/xing-frontend-utils.js on lines 1101..1124
                                                                                                          dist/xing-frontend-utils.js on lines 1128..1151
                                                                                                          dist/xing-frontend-utils.js on lines 1155..1178
                                                                                                          dist/xing-frontend-utils.js on lines 1182..1205
                                                                                                          dist/xing-frontend-utils.js on lines 1209..1232
                                                                                                          dist/xing-frontend-utils.js on lines 1236..1259

                                                                                                          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 162.

                                                                                                          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 8 locations. Consider refactoring.
                                                                                                          Open

                                                                                                              var AnimationInjector = (function (_ListInjector10) {
                                                                                                                _inherits(AnimationInjector, _ListInjector10);
                                                                                                          
                                                                                                                function AnimationInjector() {
                                                                                                                  _classCallCheck(this, AnimationInjector);
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 7 other locations - About 6 hrs to fix
                                                                                                          dist/xing-frontend-utils.js on lines 1047..1070
                                                                                                          dist/xing-frontend-utils.js on lines 1074..1097
                                                                                                          dist/xing-frontend-utils.js on lines 1101..1124
                                                                                                          dist/xing-frontend-utils.js on lines 1128..1151
                                                                                                          dist/xing-frontend-utils.js on lines 1155..1178
                                                                                                          dist/xing-frontend-utils.js on lines 1182..1205
                                                                                                          dist/xing-frontend-utils.js on lines 1236..1259

                                                                                                          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 162.

                                                                                                          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 8 locations. Consider refactoring.
                                                                                                          Open

                                                                                                              var ProviderInjector = (function (_ListInjector7) {
                                                                                                                _inherits(ProviderInjector, _ListInjector7);
                                                                                                          
                                                                                                                function ProviderInjector() {
                                                                                                                  _classCallCheck(this, ProviderInjector);
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 7 other locations - About 6 hrs to fix
                                                                                                          dist/xing-frontend-utils.js on lines 1047..1070
                                                                                                          dist/xing-frontend-utils.js on lines 1074..1097
                                                                                                          dist/xing-frontend-utils.js on lines 1101..1124
                                                                                                          dist/xing-frontend-utils.js on lines 1155..1178
                                                                                                          dist/xing-frontend-utils.js on lines 1182..1205
                                                                                                          dist/xing-frontend-utils.js on lines 1209..1232
                                                                                                          dist/xing-frontend-utils.js on lines 1236..1259

                                                                                                          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 162.

                                                                                                          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 8 locations. Consider refactoring.
                                                                                                          Open

                                                                                                              var ConstantInjector = (function (_ListInjector9) {
                                                                                                                _inherits(ConstantInjector, _ListInjector9);
                                                                                                          
                                                                                                                function ConstantInjector() {
                                                                                                                  _classCallCheck(this, ConstantInjector);
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 7 other locations - About 6 hrs to fix
                                                                                                          dist/xing-frontend-utils.js on lines 1047..1070
                                                                                                          dist/xing-frontend-utils.js on lines 1074..1097
                                                                                                          dist/xing-frontend-utils.js on lines 1101..1124
                                                                                                          dist/xing-frontend-utils.js on lines 1128..1151
                                                                                                          dist/xing-frontend-utils.js on lines 1155..1178
                                                                                                          dist/xing-frontend-utils.js on lines 1209..1232
                                                                                                          dist/xing-frontend-utils.js on lines 1236..1259

                                                                                                          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 162.

                                                                                                          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 8 locations. Consider refactoring.
                                                                                                          Open

                                                                                                              var DirectiveInjector = (function (_ListInjector4) {
                                                                                                                _inherits(DirectiveInjector, _ListInjector4);
                                                                                                          
                                                                                                                function DirectiveInjector() {
                                                                                                                  _classCallCheck(this, DirectiveInjector);
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 7 other locations - About 6 hrs to fix
                                                                                                          dist/xing-frontend-utils.js on lines 1074..1097
                                                                                                          dist/xing-frontend-utils.js on lines 1101..1124
                                                                                                          dist/xing-frontend-utils.js on lines 1128..1151
                                                                                                          dist/xing-frontend-utils.js on lines 1155..1178
                                                                                                          dist/xing-frontend-utils.js on lines 1182..1205
                                                                                                          dist/xing-frontend-utils.js on lines 1209..1232
                                                                                                          dist/xing-frontend-utils.js on lines 1236..1259

                                                                                                          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 162.

                                                                                                          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 8 locations. Consider refactoring.
                                                                                                          Open

                                                                                                              var FactoryInjector = (function (_ListInjector6) {
                                                                                                                _inherits(FactoryInjector, _ListInjector6);
                                                                                                          
                                                                                                                function FactoryInjector() {
                                                                                                                  _classCallCheck(this, FactoryInjector);
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 7 other locations - About 6 hrs to fix
                                                                                                          dist/xing-frontend-utils.js on lines 1047..1070
                                                                                                          dist/xing-frontend-utils.js on lines 1074..1097
                                                                                                          dist/xing-frontend-utils.js on lines 1128..1151
                                                                                                          dist/xing-frontend-utils.js on lines 1155..1178
                                                                                                          dist/xing-frontend-utils.js on lines 1182..1205
                                                                                                          dist/xing-frontend-utils.js on lines 1209..1232
                                                                                                          dist/xing-frontend-utils.js on lines 1236..1259

                                                                                                          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 162.

                                                                                                          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

                                                                                                              value: function link(scope, element, attrs, controller, transcludeFn) {
                                                                                                                var name = this.getUiViewName(attrs, element.inheritedData('$uiView'));
                                                                                                                var locals = name && this.$state.$current && this.$state.$current.locals[name];
                                                                                                                if (locals) {
                                                                                                                  var viewStateName = locals.$$state.self.name;
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 1 other location - About 6 hrs to fix
                                                                                                          src/xing-frontend-utils/components/stateAttrs/stateAttrs.js on lines 18..31

                                                                                                          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 161.

                                                                                                          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 RunInjector = (function (_ListInjector2) {
                                                                                                                _inherits(RunInjector, _ListInjector2);
                                                                                                          
                                                                                                                function RunInjector() {
                                                                                                                  _classCallCheck(this, RunInjector);
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 1 other location - About 6 hrs to fix
                                                                                                          dist/xing-frontend-utils.js on lines 965..988

                                                                                                          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 157.

                                                                                                          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 ConfigInjector = (function (_ListInjector) {
                                                                                                                _inherits(ConfigInjector, _ListInjector);
                                                                                                          
                                                                                                                function ConfigInjector() {
                                                                                                                  _classCallCheck(this, ConfigInjector);
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 1 other location - About 6 hrs to fix
                                                                                                          dist/xing-frontend-utils.js on lines 992..1015

                                                                                                          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 157.

                                                                                                          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

                                                                                                            function onShow(scope, element, options) {
                                                                                                              element.addClass(options.position);
                                                                                                              options.parent.addClass(toastOpenClass(options.position));
                                                                                                          
                                                                                                              var configureSwipe = $xngSwipe(scope, 'swipeleft swiperight');
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 1 other location - About 4 hrs to fix
                                                                                                          src/xing-frontend-utils/components/toast/toast.js on lines 200..212

                                                                                                          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 127.

                                                                                                          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

                                                                                                                  show: function show() {
                                                                                                                    return $xngCompiler.compile(options).then(function (compiledData) {
                                                                                                                      element = compiledData.link(options.scope);
                                                                                                                      var ret = options.onShow(options.scope, element, options);
                                                                                                                      return $q.when(ret).then(startHideTimeout);
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 1 other location - About 4 hrs to fix
                                                                                                          src/xing-frontend-utils/components/toast/interimElement.js on lines 160..173

                                                                                                          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 127.

                                                                                                          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

                                                                                                              value: function recordTransition(from, to) {
                                                                                                                if (typeof this.failedTransitions[from] === "undefined") {
                                                                                                                  this.failedTransitions[from] = {};
                                                                                                                }
                                                                                                          
                                                                                                          
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 1 other location - About 4 hrs to fix
                                                                                                          src/xing-frontend-utils/errorLimiter.js on lines 9..19

                                                                                                          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 120.

                                                                                                          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 7 locations. Consider refactoring.
                                                                                                          Open

                                                                                                              function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) subClass.__proto__ = superClass; }
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 6 other locations - About 3 hrs to fix
                                                                                                          dist/xing-frontend-utils.js on lines 244..244
                                                                                                          dist/xing-frontend-utils.js on lines 568..568
                                                                                                          dist/xing-frontend-utils.js on lines 936..936
                                                                                                          dist/xing-frontend-utils.js on lines 1551..1551
                                                                                                          dist/xing-frontend-utils.js on lines 2070..2070
                                                                                                          dist/xing-frontend-utils.js on lines 2271..2271

                                                                                                          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 114.

                                                                                                          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 7 locations. Consider refactoring.
                                                                                                          Open

                                                                                                              function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) subClass.__proto__ = superClass; }
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 6 other locations - About 3 hrs to fix
                                                                                                          dist/xing-frontend-utils.js on lines 244..244
                                                                                                          dist/xing-frontend-utils.js on lines 568..568
                                                                                                          dist/xing-frontend-utils.js on lines 1551..1551
                                                                                                          dist/xing-frontend-utils.js on lines 2070..2070
                                                                                                          dist/xing-frontend-utils.js on lines 2226..2226
                                                                                                          dist/xing-frontend-utils.js on lines 2271..2271

                                                                                                          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 114.

                                                                                                          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 7 locations. Consider refactoring.
                                                                                                          Open

                                                                                                              function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) subClass.__proto__ = superClass; }
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 6 other locations - About 3 hrs to fix
                                                                                                          dist/xing-frontend-utils.js on lines 244..244
                                                                                                          dist/xing-frontend-utils.js on lines 936..936
                                                                                                          dist/xing-frontend-utils.js on lines 1551..1551
                                                                                                          dist/xing-frontend-utils.js on lines 2070..2070
                                                                                                          dist/xing-frontend-utils.js on lines 2226..2226
                                                                                                          dist/xing-frontend-utils.js on lines 2271..2271

                                                                                                          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 114.

                                                                                                          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 7 locations. Consider refactoring.
                                                                                                          Open

                                                                                                              function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) subClass.__proto__ = superClass; }
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 6 other locations - About 3 hrs to fix
                                                                                                          dist/xing-frontend-utils.js on lines 244..244
                                                                                                          dist/xing-frontend-utils.js on lines 568..568
                                                                                                          dist/xing-frontend-utils.js on lines 936..936
                                                                                                          dist/xing-frontend-utils.js on lines 2070..2070
                                                                                                          dist/xing-frontend-utils.js on lines 2226..2226
                                                                                                          dist/xing-frontend-utils.js on lines 2271..2271

                                                                                                          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 114.

                                                                                                          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 7 locations. Consider refactoring.
                                                                                                          Open

                                                                                                              function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) subClass.__proto__ = superClass; }
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 6 other locations - About 3 hrs to fix
                                                                                                          dist/xing-frontend-utils.js on lines 568..568
                                                                                                          dist/xing-frontend-utils.js on lines 936..936
                                                                                                          dist/xing-frontend-utils.js on lines 1551..1551
                                                                                                          dist/xing-frontend-utils.js on lines 2070..2070
                                                                                                          dist/xing-frontend-utils.js on lines 2226..2226
                                                                                                          dist/xing-frontend-utils.js on lines 2271..2271

                                                                                                          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 114.

                                                                                                          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 7 locations. Consider refactoring.
                                                                                                          Open

                                                                                                              function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) subClass.__proto__ = superClass; }
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 6 other locations - About 3 hrs to fix
                                                                                                          dist/xing-frontend-utils.js on lines 244..244
                                                                                                          dist/xing-frontend-utils.js on lines 568..568
                                                                                                          dist/xing-frontend-utils.js on lines 936..936
                                                                                                          dist/xing-frontend-utils.js on lines 1551..1551
                                                                                                          dist/xing-frontend-utils.js on lines 2070..2070
                                                                                                          dist/xing-frontend-utils.js on lines 2226..2226

                                                                                                          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 114.

                                                                                                          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 7 locations. Consider refactoring.
                                                                                                          Open

                                                                                                              function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) subClass.__proto__ = superClass; }
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 6 other locations - About 3 hrs to fix
                                                                                                          dist/xing-frontend-utils.js on lines 244..244
                                                                                                          dist/xing-frontend-utils.js on lines 568..568
                                                                                                          dist/xing-frontend-utils.js on lines 936..936
                                                                                                          dist/xing-frontend-utils.js on lines 1551..1551
                                                                                                          dist/xing-frontend-utils.js on lines 2226..2226
                                                                                                          dist/xing-frontend-utils.js on lines 2271..2271

                                                                                                          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 114.

                                                                                                          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

                                                                                                            $xngToast.notice = function (message) {
                                                                                                              var type = arguments.length <= 1 || arguments[1] === undefined ? "notice" : arguments[1];
                                                                                                          
                                                                                                              return this.show({
                                                                                                                parent: toastElement,
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 1 other location - About 3 hrs to fix
                                                                                                          dist/xing-frontend-utils.js on lines 3777..3790

                                                                                                          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 106.

                                                                                                          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

                                                                                                            $xngToast.error = function (message) {
                                                                                                              var type = arguments.length <= 1 || arguments[1] === undefined ? "error" : arguments[1];
                                                                                                          
                                                                                                              return this.show({
                                                                                                                parent: toastElement,
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 1 other location - About 3 hrs to fix
                                                                                                          dist/xing-frontend-utils.js on lines 3762..3775

                                                                                                          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 106.

                                                                                                          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

                                                                                                              $rootScope.$on('$stateChangeError', function (event, toState, toParams, fromState, fromParams, error) {
                                                                                                                console.group();
                                                                                                                /*jshint -W075 */
                                                                                                                console.table({ event: event });
                                                                                                                console.table({ error: error });
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 1 other location - About 3 hrs to fix
                                                                                                          src/xing-frontend-utils/ui-route-logger.js on lines 53..62

                                                                                                          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 104.

                                                                                                          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 14 locations. Consider refactoring.
                                                                                                          Open

                                                                                                              var Filter = (function (_NgNamedAnnotation8) {
                                                                                                                _inherits(Filter, _NgNamedAnnotation8);
                                                                                                          
                                                                                                                function Filter() {
                                                                                                                  _classCallCheck(this, _Filter);
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 13 other locations - About 3 hrs to fix
                                                                                                          dist/xing-frontend-utils.js on lines 593..605
                                                                                                          dist/xing-frontend-utils.js on lines 609..621
                                                                                                          dist/xing-frontend-utils.js on lines 625..637
                                                                                                          dist/xing-frontend-utils.js on lines 641..653
                                                                                                          dist/xing-frontend-utils.js on lines 657..669
                                                                                                          dist/xing-frontend-utils.js on lines 673..685
                                                                                                          dist/xing-frontend-utils.js on lines 689..701
                                                                                                          dist/xing-frontend-utils.js on lines 705..717
                                                                                                          dist/xing-frontend-utils.js on lines 721..733
                                                                                                          dist/xing-frontend-utils.js on lines 753..765
                                                                                                          dist/xing-frontend-utils.js on lines 783..795
                                                                                                          dist/xing-frontend-utils.js on lines 1585..1597
                                                                                                          dist/xing-frontend-utils.js on lines 1601..1613

                                                                                                          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 103.

                                                                                                          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 14 locations. Consider refactoring.
                                                                                                          Open

                                                                                                              var Animation = (function (_NgNamedAnnotation9) {
                                                                                                                _inherits(Animation, _NgNamedAnnotation9);
                                                                                                          
                                                                                                                function Animation() {
                                                                                                                  _classCallCheck(this, _Animation);
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 13 other locations - About 3 hrs to fix
                                                                                                          dist/xing-frontend-utils.js on lines 593..605
                                                                                                          dist/xing-frontend-utils.js on lines 609..621
                                                                                                          dist/xing-frontend-utils.js on lines 625..637
                                                                                                          dist/xing-frontend-utils.js on lines 641..653
                                                                                                          dist/xing-frontend-utils.js on lines 657..669
                                                                                                          dist/xing-frontend-utils.js on lines 673..685
                                                                                                          dist/xing-frontend-utils.js on lines 689..701
                                                                                                          dist/xing-frontend-utils.js on lines 705..717
                                                                                                          dist/xing-frontend-utils.js on lines 721..733
                                                                                                          dist/xing-frontend-utils.js on lines 737..749
                                                                                                          dist/xing-frontend-utils.js on lines 783..795
                                                                                                          dist/xing-frontend-utils.js on lines 1585..1597
                                                                                                          dist/xing-frontend-utils.js on lines 1601..1613

                                                                                                          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 103.

                                                                                                          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 14 locations. Consider refactoring.
                                                                                                          Open

                                                                                                              var Service = (function (_NgNamedAnnotation3) {
                                                                                                                _inherits(Service, _NgNamedAnnotation3);
                                                                                                          
                                                                                                                function Service() {
                                                                                                                  _classCallCheck(this, _Service);
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 13 other locations - About 3 hrs to fix
                                                                                                          dist/xing-frontend-utils.js on lines 593..605
                                                                                                          dist/xing-frontend-utils.js on lines 609..621
                                                                                                          dist/xing-frontend-utils.js on lines 625..637
                                                                                                          dist/xing-frontend-utils.js on lines 641..653
                                                                                                          dist/xing-frontend-utils.js on lines 673..685
                                                                                                          dist/xing-frontend-utils.js on lines 689..701
                                                                                                          dist/xing-frontend-utils.js on lines 705..717
                                                                                                          dist/xing-frontend-utils.js on lines 721..733
                                                                                                          dist/xing-frontend-utils.js on lines 737..749
                                                                                                          dist/xing-frontend-utils.js on lines 753..765
                                                                                                          dist/xing-frontend-utils.js on lines 783..795
                                                                                                          dist/xing-frontend-utils.js on lines 1585..1597
                                                                                                          dist/xing-frontend-utils.js on lines 1601..1613

                                                                                                          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 103.

                                                                                                          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 14 locations. Consider refactoring.
                                                                                                          Open

                                                                                                              var Constant = (function (_NgNamedAnnotation7) {
                                                                                                                _inherits(Constant, _NgNamedAnnotation7);
                                                                                                          
                                                                                                                function Constant() {
                                                                                                                  _classCallCheck(this, _Constant);
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 13 other locations - About 3 hrs to fix
                                                                                                          dist/xing-frontend-utils.js on lines 593..605
                                                                                                          dist/xing-frontend-utils.js on lines 609..621
                                                                                                          dist/xing-frontend-utils.js on lines 625..637
                                                                                                          dist/xing-frontend-utils.js on lines 641..653
                                                                                                          dist/xing-frontend-utils.js on lines 657..669
                                                                                                          dist/xing-frontend-utils.js on lines 673..685
                                                                                                          dist/xing-frontend-utils.js on lines 689..701
                                                                                                          dist/xing-frontend-utils.js on lines 705..717
                                                                                                          dist/xing-frontend-utils.js on lines 737..749
                                                                                                          dist/xing-frontend-utils.js on lines 753..765
                                                                                                          dist/xing-frontend-utils.js on lines 783..795
                                                                                                          dist/xing-frontend-utils.js on lines 1585..1597
                                                                                                          dist/xing-frontend-utils.js on lines 1601..1613

                                                                                                          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 103.

                                                                                                          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 14 locations. Consider refactoring.
                                                                                                          Open

                                                                                                              var Provider = (function (_NgNamedAnnotation5) {
                                                                                                                _inherits(Provider, _NgNamedAnnotation5);
                                                                                                          
                                                                                                                function Provider() {
                                                                                                                  _classCallCheck(this, _Provider);
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 13 other locations - About 3 hrs to fix
                                                                                                          dist/xing-frontend-utils.js on lines 593..605
                                                                                                          dist/xing-frontend-utils.js on lines 609..621
                                                                                                          dist/xing-frontend-utils.js on lines 625..637
                                                                                                          dist/xing-frontend-utils.js on lines 641..653
                                                                                                          dist/xing-frontend-utils.js on lines 657..669
                                                                                                          dist/xing-frontend-utils.js on lines 673..685
                                                                                                          dist/xing-frontend-utils.js on lines 705..717
                                                                                                          dist/xing-frontend-utils.js on lines 721..733
                                                                                                          dist/xing-frontend-utils.js on lines 737..749
                                                                                                          dist/xing-frontend-utils.js on lines 753..765
                                                                                                          dist/xing-frontend-utils.js on lines 783..795
                                                                                                          dist/xing-frontend-utils.js on lines 1585..1597
                                                                                                          dist/xing-frontend-utils.js on lines 1601..1613

                                                                                                          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 103.

                                                                                                          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 14 locations. Consider refactoring.
                                                                                                          Open

                                                                                                              var Controller = (function (_NgNamedAnnotation) {
                                                                                                                _inherits(Controller, _NgNamedAnnotation);
                                                                                                          
                                                                                                                function Controller() {
                                                                                                                  _classCallCheck(this, _Controller);
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 13 other locations - About 3 hrs to fix
                                                                                                          dist/xing-frontend-utils.js on lines 593..605
                                                                                                          dist/xing-frontend-utils.js on lines 609..621
                                                                                                          dist/xing-frontend-utils.js on lines 641..653
                                                                                                          dist/xing-frontend-utils.js on lines 657..669
                                                                                                          dist/xing-frontend-utils.js on lines 673..685
                                                                                                          dist/xing-frontend-utils.js on lines 689..701
                                                                                                          dist/xing-frontend-utils.js on lines 705..717
                                                                                                          dist/xing-frontend-utils.js on lines 721..733
                                                                                                          dist/xing-frontend-utils.js on lines 737..749
                                                                                                          dist/xing-frontend-utils.js on lines 753..765
                                                                                                          dist/xing-frontend-utils.js on lines 783..795
                                                                                                          dist/xing-frontend-utils.js on lines 1585..1597
                                                                                                          dist/xing-frontend-utils.js on lines 1601..1613

                                                                                                          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 103.

                                                                                                          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 14 locations. Consider refactoring.
                                                                                                          Open

                                                                                                              var Template = (function (_ViewBase) {
                                                                                                                _inherits(Template, _ViewBase);
                                                                                                          
                                                                                                                function Template() {
                                                                                                                  _classCallCheck(this, _Template);
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 13 other locations - About 3 hrs to fix
                                                                                                          dist/xing-frontend-utils.js on lines 593..605
                                                                                                          dist/xing-frontend-utils.js on lines 609..621
                                                                                                          dist/xing-frontend-utils.js on lines 625..637
                                                                                                          dist/xing-frontend-utils.js on lines 641..653
                                                                                                          dist/xing-frontend-utils.js on lines 657..669
                                                                                                          dist/xing-frontend-utils.js on lines 673..685
                                                                                                          dist/xing-frontend-utils.js on lines 689..701
                                                                                                          dist/xing-frontend-utils.js on lines 705..717
                                                                                                          dist/xing-frontend-utils.js on lines 721..733
                                                                                                          dist/xing-frontend-utils.js on lines 737..749
                                                                                                          dist/xing-frontend-utils.js on lines 753..765
                                                                                                          dist/xing-frontend-utils.js on lines 783..795
                                                                                                          dist/xing-frontend-utils.js on lines 1601..1613

                                                                                                          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 103.

                                                                                                          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 14 locations. Consider refactoring.
                                                                                                          Open

                                                                                                              var AsModule = (function (_Module) {
                                                                                                                _inherits(AsModule, _Module);
                                                                                                          
                                                                                                                function AsModule() {
                                                                                                                  _classCallCheck(this, _AsModule);
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 13 other locations - About 3 hrs to fix
                                                                                                          dist/xing-frontend-utils.js on lines 593..605
                                                                                                          dist/xing-frontend-utils.js on lines 609..621
                                                                                                          dist/xing-frontend-utils.js on lines 625..637
                                                                                                          dist/xing-frontend-utils.js on lines 641..653
                                                                                                          dist/xing-frontend-utils.js on lines 657..669
                                                                                                          dist/xing-frontend-utils.js on lines 673..685
                                                                                                          dist/xing-frontend-utils.js on lines 689..701
                                                                                                          dist/xing-frontend-utils.js on lines 705..717
                                                                                                          dist/xing-frontend-utils.js on lines 721..733
                                                                                                          dist/xing-frontend-utils.js on lines 737..749
                                                                                                          dist/xing-frontend-utils.js on lines 753..765
                                                                                                          dist/xing-frontend-utils.js on lines 1585..1597
                                                                                                          dist/xing-frontend-utils.js on lines 1601..1613

                                                                                                          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 103.

                                                                                                          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 14 locations. Consider refactoring.
                                                                                                          Open

                                                                                                              var View = (function (_ViewBase2) {
                                                                                                                _inherits(View, _ViewBase2);
                                                                                                          
                                                                                                                function View() {
                                                                                                                  _classCallCheck(this, _View);
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 13 other locations - About 3 hrs to fix
                                                                                                          dist/xing-frontend-utils.js on lines 593..605
                                                                                                          dist/xing-frontend-utils.js on lines 609..621
                                                                                                          dist/xing-frontend-utils.js on lines 625..637
                                                                                                          dist/xing-frontend-utils.js on lines 641..653
                                                                                                          dist/xing-frontend-utils.js on lines 657..669
                                                                                                          dist/xing-frontend-utils.js on lines 673..685
                                                                                                          dist/xing-frontend-utils.js on lines 689..701
                                                                                                          dist/xing-frontend-utils.js on lines 705..717
                                                                                                          dist/xing-frontend-utils.js on lines 721..733
                                                                                                          dist/xing-frontend-utils.js on lines 737..749
                                                                                                          dist/xing-frontend-utils.js on lines 753..765
                                                                                                          dist/xing-frontend-utils.js on lines 783..795
                                                                                                          dist/xing-frontend-utils.js on lines 1585..1597

                                                                                                          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 103.

                                                                                                          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 14 locations. Consider refactoring.
                                                                                                          Open

                                                                                                              var Run = (function (_NgAnnotation2) {
                                                                                                                _inherits(Run, _NgAnnotation2);
                                                                                                          
                                                                                                                function Run() {
                                                                                                                  _classCallCheck(this, _Run);
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 13 other locations - About 3 hrs to fix
                                                                                                          dist/xing-frontend-utils.js on lines 593..605
                                                                                                          dist/xing-frontend-utils.js on lines 625..637
                                                                                                          dist/xing-frontend-utils.js on lines 641..653
                                                                                                          dist/xing-frontend-utils.js on lines 657..669
                                                                                                          dist/xing-frontend-utils.js on lines 673..685
                                                                                                          dist/xing-frontend-utils.js on lines 689..701
                                                                                                          dist/xing-frontend-utils.js on lines 705..717
                                                                                                          dist/xing-frontend-utils.js on lines 721..733
                                                                                                          dist/xing-frontend-utils.js on lines 737..749
                                                                                                          dist/xing-frontend-utils.js on lines 753..765
                                                                                                          dist/xing-frontend-utils.js on lines 783..795
                                                                                                          dist/xing-frontend-utils.js on lines 1585..1597
                                                                                                          dist/xing-frontend-utils.js on lines 1601..1613

                                                                                                          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 103.

                                                                                                          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 14 locations. Consider refactoring.
                                                                                                          Open

                                                                                                              var Factory = (function (_NgNamedAnnotation4) {
                                                                                                                _inherits(Factory, _NgNamedAnnotation4);
                                                                                                          
                                                                                                                function Factory() {
                                                                                                                  _classCallCheck(this, _Factory);
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 13 other locations - About 3 hrs to fix
                                                                                                          dist/xing-frontend-utils.js on lines 593..605
                                                                                                          dist/xing-frontend-utils.js on lines 609..621
                                                                                                          dist/xing-frontend-utils.js on lines 625..637
                                                                                                          dist/xing-frontend-utils.js on lines 641..653
                                                                                                          dist/xing-frontend-utils.js on lines 657..669
                                                                                                          dist/xing-frontend-utils.js on lines 689..701
                                                                                                          dist/xing-frontend-utils.js on lines 705..717
                                                                                                          dist/xing-frontend-utils.js on lines 721..733
                                                                                                          dist/xing-frontend-utils.js on lines 737..749
                                                                                                          dist/xing-frontend-utils.js on lines 753..765
                                                                                                          dist/xing-frontend-utils.js on lines 783..795
                                                                                                          dist/xing-frontend-utils.js on lines 1585..1597
                                                                                                          dist/xing-frontend-utils.js on lines 1601..1613

                                                                                                          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 103.

                                                                                                          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 14 locations. Consider refactoring.
                                                                                                          Open

                                                                                                              var Config = (function (_NgAnnotation) {
                                                                                                                _inherits(Config, _NgAnnotation);
                                                                                                          
                                                                                                                function Config() {
                                                                                                                  _classCallCheck(this, _Config);
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 13 other locations - About 3 hrs to fix
                                                                                                          dist/xing-frontend-utils.js on lines 609..621
                                                                                                          dist/xing-frontend-utils.js on lines 625..637
                                                                                                          dist/xing-frontend-utils.js on lines 641..653
                                                                                                          dist/xing-frontend-utils.js on lines 657..669
                                                                                                          dist/xing-frontend-utils.js on lines 673..685
                                                                                                          dist/xing-frontend-utils.js on lines 689..701
                                                                                                          dist/xing-frontend-utils.js on lines 705..717
                                                                                                          dist/xing-frontend-utils.js on lines 721..733
                                                                                                          dist/xing-frontend-utils.js on lines 737..749
                                                                                                          dist/xing-frontend-utils.js on lines 753..765
                                                                                                          dist/xing-frontend-utils.js on lines 783..795
                                                                                                          dist/xing-frontend-utils.js on lines 1585..1597
                                                                                                          dist/xing-frontend-utils.js on lines 1601..1613

                                                                                                          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 103.

                                                                                                          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 14 locations. Consider refactoring.
                                                                                                          Open

                                                                                                              var Directive = (function (_NgNamedAnnotation2) {
                                                                                                                _inherits(Directive, _NgNamedAnnotation2);
                                                                                                          
                                                                                                                function Directive() {
                                                                                                                  _classCallCheck(this, _Directive);
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 13 other locations - About 3 hrs to fix
                                                                                                          dist/xing-frontend-utils.js on lines 593..605
                                                                                                          dist/xing-frontend-utils.js on lines 609..621
                                                                                                          dist/xing-frontend-utils.js on lines 625..637
                                                                                                          dist/xing-frontend-utils.js on lines 657..669
                                                                                                          dist/xing-frontend-utils.js on lines 673..685
                                                                                                          dist/xing-frontend-utils.js on lines 689..701
                                                                                                          dist/xing-frontend-utils.js on lines 705..717
                                                                                                          dist/xing-frontend-utils.js on lines 721..733
                                                                                                          dist/xing-frontend-utils.js on lines 737..749
                                                                                                          dist/xing-frontend-utils.js on lines 753..765
                                                                                                          dist/xing-frontend-utils.js on lines 783..795
                                                                                                          dist/xing-frontend-utils.js on lines 1585..1597
                                                                                                          dist/xing-frontend-utils.js on lines 1601..1613

                                                                                                          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 103.

                                                                                                          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 14 locations. Consider refactoring.
                                                                                                          Open

                                                                                                              var Value = (function (_NgNamedAnnotation6) {
                                                                                                                _inherits(Value, _NgNamedAnnotation6);
                                                                                                          
                                                                                                                function Value() {
                                                                                                                  _classCallCheck(this, _Value);
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 13 other locations - About 3 hrs to fix
                                                                                                          dist/xing-frontend-utils.js on lines 593..605
                                                                                                          dist/xing-frontend-utils.js on lines 609..621
                                                                                                          dist/xing-frontend-utils.js on lines 625..637
                                                                                                          dist/xing-frontend-utils.js on lines 641..653
                                                                                                          dist/xing-frontend-utils.js on lines 657..669
                                                                                                          dist/xing-frontend-utils.js on lines 673..685
                                                                                                          dist/xing-frontend-utils.js on lines 689..701
                                                                                                          dist/xing-frontend-utils.js on lines 721..733
                                                                                                          dist/xing-frontend-utils.js on lines 737..749
                                                                                                          dist/xing-frontend-utils.js on lines 753..765
                                                                                                          dist/xing-frontend-utils.js on lines 783..795
                                                                                                          dist/xing-frontend-utils.js on lines 1585..1597
                                                                                                          dist/xing-frontend-utils.js on lines 1601..1613

                                                                                                          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 103.

                                                                                                          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

                                                                                                              function show(options) {
                                                                                                                if (stack.length) {
                                                                                                                  service.hide();
                                                                                                                }
                                                                                                          
                                                                                                          
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 1 other location - About 2 hrs to fix
                                                                                                          src/xing-frontend-utils/components/toast/interimElement.js on lines 90..100

                                                                                                          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 90.

                                                                                                          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

                                                                                                                _createClass(AnnotationFinder, [{
                                                                                                                  key: "annotationFor",
                                                                                                                  value: function annotationFor(AnnotationClass) {
                                                                                                                    var OriginalClass = AnnotationClass.originalClass || AnnotationClass;
                                                                                                                    if (this.AnnotatedClass.annotations) {
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 1 other location - About 2 hrs to fix
                                                                                                          dist/xing-frontend-utils.js on lines 903..915

                                                                                                          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 89.

                                                                                                          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

                                                                                                                }, {
                                                                                                                  key: "annotationsFor",
                                                                                                                  value: function annotationsFor(AnnotationClass) {
                                                                                                                    var OriginalClass = AnnotationClass.originalClass || AnnotationClass;
                                                                                                                    if (this.AnnotatedClass.annotations) {
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 1 other location - About 2 hrs to fix
                                                                                                          dist/xing-frontend-utils.js on lines 891..903

                                                                                                          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 89.

                                                                                                          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

                                                                                                                    resolveItem.annotations.forEach(function (annotation) {
                                                                                                                      if (annotation instanceof (Resolve.originalClass || Resolve)) {
                                                                                                                        resolveItem['$inject'] = annotation.inject;
                                                                                                                        state.resolve[prop] = resolveItem;
                                                                                                                      }
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 1 other location - About 2 hrs to fix
                                                                                                          src/xing-frontend-utils/stateInjector.js on lines 35..43

                                                                                                          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 87.

                                                                                                          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

                                                                                                            }, {
                                                                                                              key: 'dasherize',
                                                                                                              value: function dasherize(key) {
                                                                                                                if (!angular.isString(key)) {
                                                                                                                  return key;
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 1 other location - About 2 hrs to fix
                                                                                                          dist/xing-frontend-utils.js on lines 2499..2511

                                                                                                          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 87.

                                                                                                          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

                                                                                                              $rootScope.$on('$stateChangeStart', function (event, toState, toParams, fromState, fromParams) {
                                                                                                                /*jshint -W075 */
                                                                                                                console.group();
                                                                                                                console.table({ event: event });
                                                                                                                console.table({ fromState: fromState, toState: toState });
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 1 other location - About 2 hrs to fix
                                                                                                          src/xing-frontend-utils/ui-route-logger.js on lines 35..42

                                                                                                          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 87.

                                                                                                          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

                                                                                                            }, {
                                                                                                              key: 'underscore',
                                                                                                              value: function underscore(key) {
                                                                                                                if (!angular.isString(key)) {
                                                                                                                  return key;
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 1 other location - About 2 hrs to fix
                                                                                                          dist/xing-frontend-utils.js on lines 2511..2523

                                                                                                          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 87.

                                                                                                          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

                                                                                                              var NgAnnotation = function NgAnnotation() {
                                                                                                                _classCallCheck(this, NgAnnotation);
                                                                                                          
                                                                                                                for (var _len = arguments.length, dependencies = Array(_len), _key = 0; _key < _len; _key++) {
                                                                                                                  dependencies[_key] = arguments[_key];
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 2 other locations - About 2 hrs to fix
                                                                                                          dist/xing-frontend-utils.js on lines 4681..4689
                                                                                                          dist/xing-frontend-utils.js on lines 4699..4707

                                                                                                          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 79.

                                                                                                          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

                                                                                                            function Inject() {
                                                                                                              _classCallCheck(this, _Inject);
                                                                                                          
                                                                                                              for (var _len2 = arguments.length, inject = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
                                                                                                                inject[_key2] = arguments[_key2];
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 2 other locations - About 2 hrs to fix
                                                                                                          dist/xing-frontend-utils.js on lines 574..582
                                                                                                          dist/xing-frontend-utils.js on lines 4681..4689

                                                                                                          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 79.

                                                                                                          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

                                                                                                            function Resolve() {
                                                                                                              _classCallCheck(this, _Resolve);
                                                                                                          
                                                                                                              for (var _len = arguments.length, inject = Array(_len), _key = 0; _key < _len; _key++) {
                                                                                                                inject[_key] = arguments[_key];
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 2 other locations - About 2 hrs to fix
                                                                                                          dist/xing-frontend-utils.js on lines 574..582
                                                                                                          dist/xing-frontend-utils.js on lines 4699..4707

                                                                                                          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 79.

                                                                                                          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 RouteConfig = (function () {
                                                                                                                function RouteConfig(routeDescription) {
                                                                                                                  _classCallCheck(this, _RouteConfig);
                                                                                                          
                                                                                                                  this.routeDescription = routeDescription;
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 1 other location - About 2 hrs to fix
                                                                                                          dist/xing-frontend-utils.js on lines 4666..4676

                                                                                                          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 75.

                                                                                                          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 State = (function () {
                                                                                                            function State(stateName) {
                                                                                                              _classCallCheck(this, _State);
                                                                                                          
                                                                                                              this.stateName = stateName;
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 1 other location - About 2 hrs to fix
                                                                                                          dist/xing-frontend-utils.js on lines 1804..1814

                                                                                                          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 75.

                                                                                                          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

                                                                                                                for (var _len = arguments.length, params = Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
                                                                                                                  params[_key - 2] = arguments[_key];
                                                                                                                }
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 1 other location - About 1 hr to fix
                                                                                                          dist/xing-frontend-utils.js on lines 854..856

                                                                                                          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 74.

                                                                                                          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

                                                                                                          function RequestInterceptor(Serializer) {
                                                                                                            var serializer = new Serializer();
                                                                                                          
                                                                                                            return function (elem, operation, what) {
                                                                                                              var retElem = elem;
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 1 other location - About 1 hr to fix
                                                                                                          src/xing-frontend-utils/serializer.js on lines 434..444

                                                                                                          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 74.

                                                                                                          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

                                                                                                                    for (var _len2 = arguments.length, otherParams = Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
                                                                                                                      otherParams[_key2 - 1] = arguments[_key2];
                                                                                                                    }
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 1 other location - About 1 hr to fix
                                                                                                          dist/xing-frontend-utils.js on lines 2447..2449

                                                                                                          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 74.

                                                                                                          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

                                                                                                                  remove: function remove() {
                                                                                                                    self.cancelTimeout();
                                                                                                                    var ret = options.onRemove(options.scope, element, options);
                                                                                                                    return $q.when(ret).then(function () {
                                                                                                                      options.scope.$destroy();
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 1 other location - About 1 hr to fix
                                                                                                          src/xing-frontend-utils/components/toast/interimElement.js on lines 180..186

                                                                                                          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 73.

                                                                                                          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 NgNamedAnnotation = function NgNamedAnnotation(token) {
                                                                                                                var dependencies = arguments.length <= 1 || arguments[1] === undefined ? [] : arguments[1];
                                                                                                          
                                                                                                                _classCallCheck(this, NgNamedAnnotation);
                                                                                                          
                                                                                                          
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 1 other location - About 1 hr to fix
                                                                                                          dist/xing-frontend-utils.js on lines 2282..2289

                                                                                                          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 72.

                                                                                                          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

                                                                                                                function DirectiveObject(token) {
                                                                                                                  var dependencies = arguments.length <= 1 || arguments[1] === undefined ? [] : arguments[1];
                                                                                                          
                                                                                                                  _classCallCheck(this, _DirectiveObject);
                                                                                                          
                                                                                                          
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 1 other location - About 1 hr to fix
                                                                                                          dist/xing-frontend-utils.js on lines 584..591

                                                                                                          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 72.

                                                                                                          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

                                                                                                              $rootScope.$on('$stateChangeError', function (event, toState, toParams, fromState, fromParams, error) {
                                                                                                                console.log("Routing Event", event.name);
                                                                                                                console.log("From State", fromState);
                                                                                                                console.log("To State", toState);
                                                                                                                console.log("Error", error);
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 1 other location - About 1 hr to fix
                                                                                                          src/xing-frontend-utils/ui-route-logger.js on lines 24..30

                                                                                                          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 71.

                                                                                                          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

                                                                                                              value: function transitionCount(from, to) {
                                                                                                                if (typeof this.failedTransitions[from] === "undefined") {
                                                                                                                  return 0;
                                                                                                                }
                                                                                                          
                                                                                                          
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 1 other location - About 1 hr to fix
                                                                                                          src/xing-frontend-utils/errorLimiter.js on lines 21..31

                                                                                                          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 71.

                                                                                                          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

                                                                                                              value: function transitionError(fromState, toState) {
                                                                                                                var from = fromState.name,
                                                                                                                    to = toState.name;
                                                                                                                this.recordTransition(from, to);
                                                                                                                if (this.transitionCount(from, to) >= this.errorLimit) {
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 1 other location - About 1 hr to fix
                                                                                                          src/xing-frontend-utils/errorLimiter.js on lines 41..47

                                                                                                          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 70.

                                                                                                          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

                                                                                                              value: function getUiViewName(attrs, inherited) {
                                                                                                                var name = attrs.uiView || attrs.name || '';
                                                                                                                return name.indexOf('@') >= 0 ? name : name + '@' + (inherited ? inherited.state.name : '');
                                                                                                              }
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 1 other location - About 1 hr to fix
                                                                                                          src/xing-frontend-utils/components/stateAttrs/stateAttrs.js on lines 13..16

                                                                                                          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 70.

                                                                                                          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 6 locations. Consider refactoring.
                                                                                                          Open

                                                                                                          },{"./xing-frontend-utils/app/exampleForm/exampleForm.js":5,"./xing-frontend-utils/app/fallback/fallback.js":9,"./xing-frontend-utils/appConfig.js":10,"./xing-frontend-utils/components/responsiveMenu/responsiveMenu.js":12,"./xing-frontend-utils/components/stateAttrs/stateAttrs.js":13,"./xing-frontend-utils/components/toast/toast.js":20,"./xing-frontend-utils/components/unimplemented/unimplemented.js":21,"./xing-frontend-utils/serializer.js":23,"./xing-frontend-utils/stateClasses.js":24,"./xing-frontend-utils/stateFallback.js":25,"./xing-frontend-utils/stateInjector.js":26,"./xing-frontend-utils/ui-route-logger.js":27,"./xing-frontend-utils/whenGoto.js":28}],4:[function(require,module,exports){
                                                                                                          "use strict";
                                                                                                          
                                                                                                          Object.defineProperty(exports, "__esModule", {
                                                                                                            value: true
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 5 other locations - About 1 hr to fix
                                                                                                          dist/xing-frontend-utils.js on lines 2763..2773
                                                                                                          dist/xing-frontend-utils.js on lines 2872..2882
                                                                                                          dist/xing-frontend-utils.js on lines 3146..3156
                                                                                                          dist/xing-frontend-utils.js on lines 3156..3166
                                                                                                          dist/xing-frontend-utils.js on lines 3348..3358

                                                                                                          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 68.

                                                                                                          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 6 locations. Consider refactoring.
                                                                                                          Open

                                                                                                          },{}],16:[function(require,module,exports){
                                                                                                          "use strict";
                                                                                                          
                                                                                                          Object.defineProperty(exports, "__esModule", {
                                                                                                            value: true
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 5 other locations - About 1 hr to fix
                                                                                                          dist/xing-frontend-utils.js on lines 2648..2658
                                                                                                          dist/xing-frontend-utils.js on lines 2763..2773
                                                                                                          dist/xing-frontend-utils.js on lines 2872..2882
                                                                                                          dist/xing-frontend-utils.js on lines 3146..3156
                                                                                                          dist/xing-frontend-utils.js on lines 3348..3358

                                                                                                          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 68.

                                                                                                          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 6 locations. Consider refactoring.
                                                                                                          Open

                                                                                                          },{"a1atscript":1}],11:[function(require,module,exports){
                                                                                                          "use strict";
                                                                                                          
                                                                                                          Object.defineProperty(exports, "__esModule", {
                                                                                                            value: true
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 5 other locations - About 1 hr to fix
                                                                                                          dist/xing-frontend-utils.js on lines 2648..2658
                                                                                                          dist/xing-frontend-utils.js on lines 2763..2773
                                                                                                          dist/xing-frontend-utils.js on lines 3146..3156
                                                                                                          dist/xing-frontend-utils.js on lines 3156..3166
                                                                                                          dist/xing-frontend-utils.js on lines 3348..3358

                                                                                                          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 68.

                                                                                                          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 6 locations. Consider refactoring.
                                                                                                          Open

                                                                                                          },{"./compiler.js":14}],18:[function(require,module,exports){
                                                                                                          "use strict";
                                                                                                          
                                                                                                          Object.defineProperty(exports, "__esModule", {
                                                                                                            value: true
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 5 other locations - About 1 hr to fix
                                                                                                          dist/xing-frontend-utils.js on lines 2648..2658
                                                                                                          dist/xing-frontend-utils.js on lines 2763..2773
                                                                                                          dist/xing-frontend-utils.js on lines 2872..2882
                                                                                                          dist/xing-frontend-utils.js on lines 3146..3156
                                                                                                          dist/xing-frontend-utils.js on lines 3156..3166

                                                                                                          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 68.

                                                                                                          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 6 locations. Consider refactoring.
                                                                                                          Open

                                                                                                          },{"../../stateInjector.js":26,"./example-form.tpl.js":4}],8:[function(require,module,exports){
                                                                                                          "use strict";
                                                                                                          
                                                                                                          Object.defineProperty(exports, "__esModule", {
                                                                                                            value: true
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 5 other locations - About 1 hr to fix
                                                                                                          dist/xing-frontend-utils.js on lines 2648..2658
                                                                                                          dist/xing-frontend-utils.js on lines 2872..2882
                                                                                                          dist/xing-frontend-utils.js on lines 3146..3156
                                                                                                          dist/xing-frontend-utils.js on lines 3156..3166
                                                                                                          dist/xing-frontend-utils.js on lines 3348..3358

                                                                                                          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 68.

                                                                                                          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 6 locations. Consider refactoring.
                                                                                                          Open

                                                                                                          },{}],15:[function(require,module,exports){
                                                                                                          "use strict";
                                                                                                          
                                                                                                          Object.defineProperty(exports, "__esModule", {
                                                                                                            value: true
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 5 other locations - About 1 hr to fix
                                                                                                          dist/xing-frontend-utils.js on lines 2648..2658
                                                                                                          dist/xing-frontend-utils.js on lines 2763..2773
                                                                                                          dist/xing-frontend-utils.js on lines 2872..2882
                                                                                                          dist/xing-frontend-utils.js on lines 3156..3166
                                                                                                          dist/xing-frontend-utils.js on lines 3348..3358

                                                                                                          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 68.

                                                                                                          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 4 locations. Consider refactoring.
                                                                                                          Open

                                                                                                              function cancel(reason) {
                                                                                                                var interimElement = stack.shift();
                                                                                                                interimElement.remove().then(function () {
                                                                                                                  interimElement.deferred.reject(reason);
                                                                                                                });
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 3 other locations - About 1 hr to fix
                                                                                                          dist/xing-frontend-utils.js on lines 3272..3277
                                                                                                          src/xing-frontend-utils/components/toast/interimElement.js on lines 115..120
                                                                                                          src/xing-frontend-utils/components/toast/interimElement.js on lines 135..140

                                                                                                          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 65.

                                                                                                          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 4 locations. Consider refactoring.
                                                                                                          Open

                                                                                                              function hide(success) {
                                                                                                                var interimElement = stack.shift();
                                                                                                                interimElement.remove().then(function () {
                                                                                                                  interimElement.deferred.resolve(success);
                                                                                                                });
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 3 other locations - About 1 hr to fix
                                                                                                          dist/xing-frontend-utils.js on lines 3292..3297
                                                                                                          src/xing-frontend-utils/components/toast/interimElement.js on lines 115..120
                                                                                                          src/xing-frontend-utils/components/toast/interimElement.js on lines 135..140

                                                                                                          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 65.

                                                                                                          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

                                                                                                              $rootScope.$on('$stateChangeStart', function (event, toState, toParams, fromState, fromParams) {
                                                                                                                /*jshint -W075 */
                                                                                                                console.log("Routing Event", event.name);
                                                                                                                console.log("From State", fromState.name, fromState.url);
                                                                                                                console.log("To State", toState.name, toState.url);
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 1 other location - About 1 hr to fix
                                                                                                          src/xing-frontend-utils/ui-route-logger.js on lines 5..10

                                                                                                          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 64.

                                                                                                          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

                                                                                                                    Object.defineProperty(this._component.prototype, BIND_PREFIX + key, {
                                                                                                                      enumerable: true,
                                                                                                                      configurable: true,
                                                                                                                      set: genericSetter(BINDING, RAW_STRING),
                                                                                                                      get: function get() {
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 1 other location - About 1 hr to fix
                                                                                                          dist/xing-frontend-utils.js on lines 2107..2114

                                                                                                          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 64.

                                                                                                          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

                                                                                                                    Object.defineProperty(this._component.prototype, STRING_PREFIX + key, {
                                                                                                                      enumerable: true,
                                                                                                                      configurable: true,
                                                                                                                      set: genericSetter(RAW_STRING, BINDING),
                                                                                                                      get: function get() {
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 1 other location - About 1 hr to fix
                                                                                                          dist/xing-frontend-utils.js on lines 2097..2104

                                                                                                          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 64.

                                                                                                          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

                                                                                                                  dependencyList.forEach(function (dependencyObject) {
                                                                                                                    var metadata = dependencyObject.metadata;
                                                                                                                    var StateClass = dependencyObject.dependency;
                                                                                                                    var state = new StateClass();
                                                                                                                    injector.annotateResolves(state);
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 1 other location - About 1 hr to fix
                                                                                                          src/xing-frontend-utils/stateInjector.js on lines 51..60

                                                                                                          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 63.

                                                                                                          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

                                                                                                              $rootScope.$on('$stateChangeSuccess', function (event, toState) {
                                                                                                                console.group();
                                                                                                                console.table({ event: event });
                                                                                                                console.table({ toState: toState });
                                                                                                                console.groupEnd();
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 1 other location - About 1 hr to fix
                                                                                                          src/xing-frontend-utils/ui-route-logger.js on lines 47..52

                                                                                                          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

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

                                                                                                            function onRemove(scope, element, options) {
                                                                                                              options.detachSwipe();
                                                                                                              options.parent.removeClass(toastOpenClass(options.position));
                                                                                                              return $animate.leave(element);
                                                                                                            }
                                                                                                          Severity: Major
                                                                                                          Found in dist/xing-frontend-utils.js and 1 other location - About 1 hr to fix
                                                                                                          src/xing-frontend-utils/components/toast/toast.js on lines 214..218

                                                                                                          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 55.

                                                                                                          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

                                                                                                                }, {
                                                                                                                  key: "inlineTemplateCache",
                                                                                                                  get: function get() {
                                                                                                                    this._inlineTemplateCache = this._inlineTemplateCache || {};
                                                                                                                    return this._inlineTemplateCache;
                                                                                                          Severity: Minor
                                                                                                          Found in dist/xing-frontend-utils.js and 2 other locations - About 35 mins to fix
                                                                                                          dist/xing-frontend-utils.js on lines 1504..1510
                                                                                                          dist/xing-frontend-utils.js on lines 1516..1522

                                                                                                          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 46.

                                                                                                          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

                                                                                                                }, {
                                                                                                                  key: "registry",
                                                                                                                  get: function get() {
                                                                                                                    this._componentRegistry = this._componentRegistry || {};
                                                                                                                    return this._componentRegistry;
                                                                                                          Severity: Minor
                                                                                                          Found in dist/xing-frontend-utils.js and 2 other locations - About 35 mins to fix
                                                                                                          dist/xing-frontend-utils.js on lines 1516..1522
                                                                                                          dist/xing-frontend-utils.js on lines 1522..1528

                                                                                                          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 46.

                                                                                                          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

                                                                                                                }, {
                                                                                                                  key: "controllerRegistry",
                                                                                                                  get: function get() {
                                                                                                                    this._controllerRegistry = this._controllerRegistry || {};
                                                                                                                    return this._controllerRegistry;
                                                                                                          Severity: Minor
                                                                                                          Found in dist/xing-frontend-utils.js and 2 other locations - About 35 mins to fix
                                                                                                          dist/xing-frontend-utils.js on lines 1504..1510
                                                                                                          dist/xing-frontend-utils.js on lines 1522..1528

                                                                                                          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 46.

                                                                                                          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

                                                                                                                    events[key] = "=?on" + this.bindObj[key][0].toUpperCase() + this.bindObj[key].slice(1);
                                                                                                          Severity: Minor
                                                                                                          Found in dist/xing-frontend-utils.js and 1 other location - About 30 mins to fix
                                                                                                          dist/xing-frontend-utils.js on lines 2094..2094

                                                                                                          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 45.

                                                                                                          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

                                                                                                                    properties[BIND_PREFIX + key] = "=?bind" + this.bindObj[key][0].toUpperCase() + this.bindObj[key].slice(1);
                                                                                                          Severity: Minor
                                                                                                          Found in dist/xing-frontend-utils.js and 1 other location - About 30 mins to fix
                                                                                                          dist/xing-frontend-utils.js on lines 2246..2246

                                                                                                          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 45.

                                                                                                          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