Remove IIFEs29219-remove-iifes-g

6 files changed, 1202 insertions, 1254 deletions

diff --git a/app/assets/javascripts/gl_dropdown.js b/app/assets/javascripts/gl_dropdown.js
index a03f1202a6d..859316903af 100644
--- a/app/assets/javascripts/gl_dropdown.js
+++ b/app/assets/javascripts/gl_dropdown.js
@@ -1,843 +1,801 @@
 /* eslint-disable func-names, space-before-function-paren, no-var, one-var, one-var-declaration-per-line, prefer-rest-params, max-len, vars-on-top, wrap-iife, no-unused-vars, quotes, no-shadow, no-cond-assign, prefer-arrow-callback, no-return-assign, no-else-return, camelcase, comma-dangle, no-lonely-if, guard-for-in, no-restricted-syntax, consistent-return, prefer-template, no-param-reassign, no-loop-func, no-mixed-operators */
 /* global fuzzaldrinPlus */
 
-var GitLabDropdown, GitLabDropdownFilter, GitLabDropdownRemote,
-  bind = function(fn, me) { return function() { return fn.apply(me, arguments); }; },
+var bind = function(fn, me) { return function() { return fn.apply(me, arguments); }; },
   indexOf = [].indexOf || function(item) { for (var i = 0, l = this.length; i < l; i += 1) { if (i in this && this[i] === item) return i; } return -1; };
 
-GitLabDropdownFilter = (function() {
-  var ARROW_KEY_CODES, BLUR_KEYCODES, HAS_VALUE_CLASS;
+// GitLabDropdownFilter
+var ARROW_KEY_CODES, BLUR_KEYCODES, HAS_VALUE_CLASS;
 
-  BLUR_KEYCODES = [27, 40];
+BLUR_KEYCODES = [27, 40];
 
-  ARROW_KEY_CODES = [38, 40];
+ARROW_KEY_CODES = [38, 40];
+
+HAS_VALUE_CLASS = "has-value";
 
-  HAS_VALUE_CLASS = "has-value";
-
-  function GitLabDropdownFilter(input, options) {
-    var $clearButton, $inputContainer, ref, timeout;
-    this.input = input;
-    this.options = options;
-    this.filterInputBlur = (ref = this.options.filterInputBlur) != null ? ref : true;
-    $inputContainer = this.input.parent();
-    $clearButton = $inputContainer.find('.js-dropdown-input-clear');
-    $clearButton.on('click', (function(_this) {
-      // Clear click
-      return function(e) {
+function GitLabDropdownFilter(input, options) {
+  var $clearButton, $inputContainer, ref, timeout;
+  this.input = input;
+  this.options = options;
+  this.filterInputBlur = (ref = this.options.filterInputBlur) != null ? ref : true;
+  $inputContainer = this.input.parent();
+  $clearButton = $inputContainer.find('.js-dropdown-input-clear');
+  $clearButton.on('click', (e) => {
+    e.preventDefault();
+    e.stopPropagation();
+    return this.input.val('').trigger('input').focus();
+  });
+  // Key events
+  timeout = "";
+  this.input
+    .on('keydown', function (e) {
+      var keyCode = e.which;
+      if (keyCode === 13 && !options.elIsInput) {
         e.preventDefault();
-        e.stopPropagation();
-        return _this.input.val('').trigger('input').focus();
-      };
-    })(this));
-    // Key events
-    timeout = "";
-    this.input
-      .on('keydown', function (e) {
-        var keyCode = e.which;
-        if (keyCode === 13 && !options.elIsInput) {
-          e.preventDefault();
-        }
-      })
-      .on('input', function() {
-        if (this.input.val() !== "" && !$inputContainer.hasClass(HAS_VALUE_CLASS)) {
-          $inputContainer.addClass(HAS_VALUE_CLASS);
-        } else if (this.input.val() === "" && $inputContainer.hasClass(HAS_VALUE_CLASS)) {
-          $inputContainer.removeClass(HAS_VALUE_CLASS);
-        }
-        // Only filter asynchronously only if option remote is set
-        if (this.options.remote) {
-          clearTimeout(timeout);
-          return timeout = setTimeout(function() {
-            $inputContainer.parent().addClass('is-loading');
-
-            return this.options.query(this.input.val(), function(data) {
-              $inputContainer.parent().removeClass('is-loading');
-              return this.options.callback(data);
-            }.bind(this));
-          }.bind(this), 250);
-        } else {
-          return this.filter(this.input.val());
-        }
-      }.bind(this));
-  }
+      }
+    })
+    .on('input', function() {
+      if (this.input.val() !== "" && !$inputContainer.hasClass(HAS_VALUE_CLASS)) {
+        $inputContainer.addClass(HAS_VALUE_CLASS);
+      } else if (this.input.val() === "" && $inputContainer.hasClass(HAS_VALUE_CLASS)) {
+        $inputContainer.removeClass(HAS_VALUE_CLASS);
+      }
+      // Only filter asynchronously only if option remote is set
+      if (this.options.remote) {
+        clearTimeout(timeout);
+        return timeout = setTimeout(function() {
+          $inputContainer.parent().addClass('is-loading');
+
+          return this.options.query(this.input.val(), function(data) {
+            $inputContainer.parent().removeClass('is-loading');
+            return this.options.callback(data);
+          }.bind(this));
+        }.bind(this), 250);
+      } else {
+        return this.filter(this.input.val());
+      }
+    }.bind(this));
+}
 
-  GitLabDropdownFilter.prototype.shouldBlur = function(keyCode) {
-    return BLUR_KEYCODES.indexOf(keyCode) !== -1;
-  };
+GitLabDropdownFilter.prototype.shouldBlur = function(keyCode) {
+  return BLUR_KEYCODES.indexOf(keyCode) !== -1;
+};
 
-  GitLabDropdownFilter.prototype.filter = function(search_text) {
-    var data, elements, group, key, results, tmp;
-    if (this.options.onFilter) {
-      this.options.onFilter(search_text);
-    }
-    data = this.options.data();
-    if ((data != null) && !this.options.filterByText) {
-      results = data;
-      if (search_text !== '') {
-        // When data is an array of objects therefore [object Array] e.g.
-        // [
-        //   { prop: 'foo' },
-        //   { prop: 'baz' }
-        // ]
-        if (_.isArray(data)) {
-          results = fuzzaldrinPlus.filter(data, search_text, {
-            key: this.options.keys
-          });
-        } else {
-          // If data is grouped therefore an [object Object]. e.g.
-          // {
-          //   groupName1: [
-          //     { prop: 'foo' },
-          //     { prop: 'baz' }
-          //   ],
-          //   groupName2: [
-          //     { prop: 'abc' },
-          //     { prop: 'def' }
-          //   ]
-          // }
-          if (gl.utils.isObject(data)) {
-            results = {};
-            for (key in data) {
-              group = data[key];
-              tmp = fuzzaldrinPlus.filter(group, search_text, {
-                key: this.options.keys
+GitLabDropdownFilter.prototype.filter = function(search_text) {
+  var data, elements, group, key, results, tmp;
+  if (this.options.onFilter) {
+    this.options.onFilter(search_text);
+  }
+  data = this.options.data();
+  if ((data != null) && !this.options.filterByText) {
+    results = data;
+    if (search_text !== '') {
+      // When data is an array of objects therefore [object Array] e.g.
+      // [
+      //   { prop: 'foo' },
+      //   { prop: 'baz' }
+      // ]
+      if (_.isArray(data)) {
+        results = fuzzaldrinPlus.filter(data, search_text, {
+          key: this.options.keys
+        });
+      } else {
+        // If data is grouped therefore an [object Object]. e.g.
+        // {
+        //   groupName1: [
+        //     { prop: 'foo' },
+        //     { prop: 'baz' }
+        //   ],
+        //   groupName2: [
+        //     { prop: 'abc' },
+        //     { prop: 'def' }
+        //   ]
+        // }
+        if (gl.utils.isObject(data)) {
+          results = {};
+          for (key in data) {
+            group = data[key];
+            tmp = fuzzaldrinPlus.filter(group, search_text, {
+              key: this.options.keys
+            });
+            if (tmp.length) {
+              results[key] = tmp.map(function(item) {
+                return item;
               });
-              if (tmp.length) {
-                results[key] = tmp.map(function(item) {
-                  return item;
-                });
-              }
             }
           }
         }
       }
-      return this.options.callback(results);
-    } else {
-      elements = this.options.elements();
-      if (search_text) {
-        return elements.each(function() {
-          var $el, matches;
-          $el = $(this);
-          matches = fuzzaldrinPlus.match($el.text().trim(), search_text);
-          if (!$el.is('.dropdown-header')) {
-            if (matches.length) {
-              return $el.show().removeClass('option-hidden');
-            } else {
-              return $el.hide().addClass('option-hidden');
-            }
+    }
+    return this.options.callback(results);
+  } else {
+    elements = this.options.elements();
+    if (search_text) {
+      return elements.each(function() {
+        var $el, matches;
+        $el = $(this);
+        matches = fuzzaldrinPlus.match($el.text().trim(), search_text);
+        if (!$el.is('.dropdown-header')) {
+          if (matches.length) {
+            return $el.show().removeClass('option-hidden');
+          } else {
+            return $el.hide().addClass('option-hidden');
           }
-        });
-      } else {
-        return elements.show().removeClass('option-hidden');
-      }
+        }
+      });
+    } else {
+      return elements.show().removeClass('option-hidden');
     }
-  };
-
-  return GitLabDropdownFilter;
-})();
-
-GitLabDropdownRemote = (function() {
-  function GitLabDropdownRemote(dataEndpoint, options) {
-    this.dataEndpoint = dataEndpoint;
-    this.options = options;
   }
+};
 
-  GitLabDropdownRemote.prototype.execute = function() {
-    if (typeof this.dataEndpoint === "string") {
-      return this.fetchData();
-    } else if (typeof this.dataEndpoint === "function") {
+// GitLabDropdownRemote
+function GitLabDropdownRemote(dataEndpoint, options) {
+  this.dataEndpoint = dataEndpoint;
+  this.options = options;
+}
+
+GitLabDropdownRemote.prototype.execute = function() {
+  if (typeof this.dataEndpoint === "string") {
+    return this.fetchData();
+  } else if (typeof this.dataEndpoint === "function") {
+    if (this.options.beforeSend) {
+      this.options.beforeSend();
+    }
+    return this.dataEndpoint("", (data) => {
+      // Fetch the data by calling the data funcfion
+      if (this.options.success) {
+        this.options.success(data);
+      }
       if (this.options.beforeSend) {
-        this.options.beforeSend();
+        return this.options.beforeSend();
       }
-      return this.dataEndpoint("", (function(_this) {
-        // Fetch the data by calling the data funcfion
-        return function(data) {
-          if (_this.options.success) {
-            _this.options.success(data);
-          }
-          if (_this.options.beforeSend) {
-            return _this.options.beforeSend();
-          }
-        };
-      })(this));
-    }
-  };
-
-  GitLabDropdownRemote.prototype.fetchData = function() {
-    return $.ajax({
-      url: this.dataEndpoint,
-      dataType: this.options.dataType,
-      beforeSend: (function(_this) {
-        return function() {
-          if (_this.options.beforeSend) {
-            return _this.options.beforeSend();
-          }
-        };
-      })(this),
-      success: (function(_this) {
-        return function(data) {
-          if (_this.options.success) {
-            return _this.options.success(data);
-          }
-        };
-      })(this)
     });
-  // Fetch the data through ajax if the data is a string
-  };
+  }
+};
 
-  return GitLabDropdownRemote;
-})();
+GitLabDropdownRemote.prototype.fetchData = function() {
+  return $.ajax({
+    url: this.dataEndpoint,
+    dataType: this.options.dataType,
+    beforeSend: () => {
+      if (this.options.beforeSend) {
+        return this.options.beforeSend();
+      }
+    },
+    success: (data) => {
+      if (this.options.success) {
+        return this.options.success(data);
+      }
+    },
+  });
+// Fetch the data through ajax if the data is a string
+};
 
-GitLabDropdown = (function() {
-  var ACTIVE_CLASS, FILTER_INPUT, INDETERMINATE_CLASS, LOADING_CLASS, PAGE_TWO_CLASS, NON_SELECTABLE_CLASSES, SELECTABLE_CLASSES, CURSOR_SELECT_SCROLL_PADDING, currentIndex;
+// GitLabDropdown
+var ACTIVE_CLASS, FILTER_INPUT, INDETERMINATE_CLASS, LOADING_CLASS, PAGE_TWO_CLASS, NON_SELECTABLE_CLASSES, SELECTABLE_CLASSES, CURSOR_SELECT_SCROLL_PADDING, currentIndex;
 
-  LOADING_CLASS = "is-loading";
+LOADING_CLASS = "is-loading";
 
-  PAGE_TWO_CLASS = "is-page-two";
+PAGE_TWO_CLASS = "is-page-two";
 
-  ACTIVE_CLASS = "is-active";
+ACTIVE_CLASS = "is-active";
 
-  INDETERMINATE_CLASS = "is-indeterminate";
+INDETERMINATE_CLASS = "is-indeterminate";
 
-  currentIndex = -1;
+currentIndex = -1;
 
-  NON_SELECTABLE_CLASSES = '.divider, .separator, .dropdown-header, .dropdown-menu-empty-link';
-
-  SELECTABLE_CLASSES = ".dropdown-content li:not(" + NON_SELECTABLE_CLASSES + ", .option-hidden)";
-
-  CURSOR_SELECT_SCROLL_PADDING = 5;
-
-  FILTER_INPUT = '.dropdown-input .dropdown-input-field';
-
-  function GitLabDropdown(el1, options) {
-    var searchFields, selector, self;
-    this.el = el1;
-    this.options = options;
-    this.updateLabel = bind(this.updateLabel, this);
-    this.hidden = bind(this.hidden, this);
-    this.opened = bind(this.opened, this);
-    this.shouldPropagate = bind(this.shouldPropagate, this);
-    self = this;
-    selector = $(this.el).data("target");
-    this.dropdown = selector != null ? $(selector) : $(this.el).parent();
-    // Set Defaults
-    this.filterInput = this.options.filterInput || this.getElement(FILTER_INPUT);
-    this.highlight = !!this.options.highlight;
-    this.filterInputBlur = this.options.filterInputBlur != null
-      ? this.options.filterInputBlur
-      : true;
-    // If no input is passed create a default one
-    self = this;
-    // If selector was passed
-    if (_.isString(this.filterInput)) {
-      this.filterInput = this.getElement(this.filterInput);
-    }
-    searchFields = this.options.search ? this.options.search.fields : [];
-    if (this.options.data) {
-      // If we provided data
-      // data could be an array of objects or a group of arrays
-      if (_.isObject(this.options.data) && !_.isFunction(this.options.data)) {
-        this.fullData = this.options.data;
-        currentIndex = -1;
-        this.parseData(this.options.data);
-        this.focusTextInput();
-      } else {
-        this.remote = new GitLabDropdownRemote(this.options.data, {
-          dataType: this.options.dataType,
-          beforeSend: this.toggleLoading.bind(this),
-          success: (function(_this) {
-            return function(data) {
-              _this.fullData = data;
-              _this.parseData(_this.fullData);
-              _this.focusTextInput();
-              if (_this.options.filterable && _this.filter && _this.filter.input && _this.filter.input.val() && _this.filter.input.val().trim() !== '') {
-                return _this.filter.input.trigger('input');
-              }
-            };
-          // Remote data
-          })(this)
-        });
-      }
-    }
-    // Init filterable
-    if (this.options.filterable) {
-      this.filter = new GitLabDropdownFilter(this.filterInput, {
-        elIsInput: $(this.el).is('input'),
-        filterInputBlur: this.filterInputBlur,
-        filterByText: this.options.filterByText,
-        onFilter: this.options.onFilter,
-        remote: this.options.filterRemote,
-        query: this.options.data,
-        keys: searchFields,
-        elements: (function(_this) {
-          return function() {
-            selector = '.dropdown-content li:not(' + NON_SELECTABLE_CLASSES + ')';
-            if (_this.dropdown.find('.dropdown-toggle-page').length) {
-              selector = ".dropdown-page-one " + selector;
-            }
-            return $(selector);
-          };
-        })(this),
-        data: (function(_this) {
-          return function() {
-            return _this.fullData;
-          };
-        })(this),
-        callback: (function(_this) {
-          return function(data) {
-            _this.parseData(data);
-            if (_this.filterInput.val() !== '') {
-              selector = SELECTABLE_CLASSES;
-              if (_this.dropdown.find('.dropdown-toggle-page').length) {
-                selector = ".dropdown-page-one " + selector;
-              }
-              if ($(_this.el).is('input')) {
-                currentIndex = -1;
-              } else {
-                $(selector, _this.dropdown).first().find('a').addClass('is-focused');
-                currentIndex = 0;
-              }
-            }
-          };
-        })(this)
+NON_SELECTABLE_CLASSES = '.divider, .separator, .dropdown-header, .dropdown-menu-empty-link';
+
+SELECTABLE_CLASSES = ".dropdown-content li:not(" + NON_SELECTABLE_CLASSES + ", .option-hidden)";
+
+CURSOR_SELECT_SCROLL_PADDING = 5;
+
+FILTER_INPUT = '.dropdown-input .dropdown-input-field';
+
+function GitLabDropdown(el1, options) {
+  var searchFields, selector, self;
+  this.el = el1;
+  this.options = options;
+  this.updateLabel = bind(this.updateLabel, this);
+  this.hidden = bind(this.hidden, this);
+  this.opened = bind(this.opened, this);
+  this.shouldPropagate = bind(this.shouldPropagate, this);
+  self = this;
+  selector = $(this.el).data("target");
+  this.dropdown = selector != null ? $(selector) : $(this.el).parent();
+  // Set Defaults
+  this.filterInput = this.options.filterInput || this.getElement(FILTER_INPUT);
+  this.highlight = !!this.options.highlight;
+  this.filterInputBlur = this.options.filterInputBlur != null
+    ? this.options.filterInputBlur
+    : true;
+  // If no input is passed create a default one
+  self = this;
+  // If selector was passed
+  if (_.isString(this.filterInput)) {
+    this.filterInput = this.getElement(this.filterInput);
+  }
+  searchFields = this.options.search ? this.options.search.fields : [];
+  if (this.options.data) {
+    // If we provided data
+    // data could be an array of objects or a group of arrays
+    if (_.isObject(this.options.data) && !_.isFunction(this.options.data)) {
+      this.fullData = this.options.data;
+      currentIndex = -1;
+      this.parseData(this.options.data);
+      this.focusTextInput();
+    } else {
+      this.remote = new GitLabDropdownRemote(this.options.data, {
+        dataType: this.options.dataType,
+        beforeSend: this.toggleLoading.bind(this),
+        success: (data) => {
+          this.fullData = data;
+          this.parseData(this.fullData);
+          this.focusTextInput();
+          if (this.options.filterable && this.filter && this.filter.input && this.filter.input.val() && this.filter.input.val().trim() !== '') {
+            return this.filter.input.trigger('input');
+          }
+        },
       });
     }
-    // Event listeners
-    this.dropdown.on("shown.bs.dropdown", this.opened);
-    this.dropdown.on("hidden.bs.dropdown", this.hidden);
-    $(this.el).on("update.label", this.updateLabel);
-    this.dropdown.on("click", ".dropdown-menu, .dropdown-menu-close", this.shouldPropagate);
-    this.dropdown.on('keyup', (function(_this) {
-      return function(e) {
-        // Escape key
-        if (e.which === 27) {
-          return $('.dropdown-menu-close', _this.dropdown).trigger('click');
+  }
+  // Init filterable
+  if (this.options.filterable) {
+    this.filter = new GitLabDropdownFilter(this.filterInput, {
+      elIsInput: $(this.el).is('input'),
+      filterInputBlur: this.filterInputBlur,
+      filterByText: this.options.filterByText,
+      onFilter: this.options.onFilter,
+      remote: this.options.filterRemote,
+      query: this.options.data,
+      keys: searchFields,
+      elements: () => {
+        selector = '.dropdown-content li:not(' + NON_SELECTABLE_CLASSES + ')';
+        if (this.dropdown.find('.dropdown-toggle-page').length) {
+          selector = ".dropdown-page-one " + selector;
         }
-      };
-    })(this));
-    this.dropdown.on('blur', 'a', (function(_this) {
-      return function(e) {
-        var $dropdownMenu, $relatedTarget;
-        if (e.relatedTarget != null) {
-          $relatedTarget = $(e.relatedTarget);
-          $dropdownMenu = $relatedTarget.closest('.dropdown-menu');
-          if ($dropdownMenu.length === 0) {
-            return _this.dropdown.removeClass('open');
+        return $(selector);
+      },
+      data: () => this.fullData,
+      callback: (data) => {
+        this.parseData(data);
+        if (this.filterInput.val() !== '') {
+          selector = SELECTABLE_CLASSES;
+          if (this.dropdown.find('.dropdown-toggle-page').length) {
+            selector = ".dropdown-page-one " + selector;
+          }
+          if ($(this.el).is('input')) {
+            currentIndex = -1;
+          } else {
+            $(selector, this.dropdown).first().find('a').addClass('is-focused');
+            currentIndex = 0;
           }
         }
-      };
-    })(this));
-    if (this.dropdown.find(".dropdown-toggle-page").length) {
-      this.dropdown.find(".dropdown-toggle-page, .dropdown-menu-back").on("click", (function(_this) {
-        return function(e) {
-          e.preventDefault();
-          e.stopPropagation();
-          return _this.togglePage();
-        };
-      })(this));
+      },
+    });
+  }
+  // Event listeners
+  this.dropdown.on("shown.bs.dropdown", this.opened);
+  this.dropdown.on("hidden.bs.dropdown", this.hidden);
+  $(this.el).on("update.label", this.updateLabel);
+  this.dropdown.on("click", ".dropdown-menu, .dropdown-menu-close", this.shouldPropagate);
+  this.dropdown.on('keyup', (e) => {
+    // Escape key
+    if (e.which === 27) {
+      return $('.dropdown-menu-close', this.dropdown).trigger('click');
     }
-    if (this.options.selectable) {
-      selector = ".dropdown-content a";
-      if (this.dropdown.find(".dropdown-toggle-page").length) {
-        selector = ".dropdown-page-one .dropdown-content a";
+  });
+  this.dropdown.on('blur', 'a', (e) => {
+    var $dropdownMenu, $relatedTarget;
+    if (e.relatedTarget != null) {
+      $relatedTarget = $(e.relatedTarget);
+      $dropdownMenu = $relatedTarget.closest('.dropdown-menu');
+      if ($dropdownMenu.length === 0) {
+        return this.dropdown.removeClass('open');
+      }
+    }
+  });
+  if (this.dropdown.find(".dropdown-toggle-page").length) {
+    this.dropdown.find(".dropdown-toggle-page, .dropdown-menu-back").on("click", (e) => {
+      e.preventDefault();
+      e.stopPropagation();
+      return this.togglePage();
+    });
+  }
+  if (this.options.selectable) {
+    selector = ".dropdown-content a";
+    if (this.dropdown.find(".dropdown-toggle-page").length) {
+      selector = ".dropdown-page-one .dropdown-content a";
+    }
+    this.dropdown.on("click", selector, function(e) {
+      var $el, selected, selectedObj, isMarking;
+      $el = $(this);
+      selected = self.rowClicked($el);
+      selectedObj = selected ? selected[0] : null;
+      isMarking = selected ? selected[1] : null;
+      if (self.options.clicked) {
+        self.options.clicked(selectedObj, $el, e, isMarking);
       }
-      this.dropdown.on("click", selector, function(e) {
-        var $el, selected, selectedObj, isMarking;
-        $el = $(this);
-        selected = self.rowClicked($el);
-        selectedObj = selected ? selected[0] : null;
-        isMarking = selected ? selected[1] : null;
-        if (self.options.clicked) {
-          self.options.clicked(selectedObj, $el, e, isMarking);
-        }
 
-        // Update label right after all modifications in dropdown has been done
-        if (self.options.toggleLabel) {
-          self.updateLabel(selectedObj, $el, self);
-        }
+      // Update label right after all modifications in dropdown has been done
+      if (self.options.toggleLabel) {
+        self.updateLabel(selectedObj, $el, self);
+      }
 
-        $el.trigger('blur');
-      });
-    }
+      $el.trigger('blur');
+    });
   }
+}
 
-  // Finds an element inside wrapper element
-  GitLabDropdown.prototype.getElement = function(selector) {
-    return this.dropdown.find(selector);
-  };
+// Finds an element inside wrapper element
+GitLabDropdown.prototype.getElement = function(selector) {
+  return this.dropdown.find(selector);
+};
 
-  GitLabDropdown.prototype.toggleLoading = function() {
-    return $('.dropdown-menu', this.dropdown).toggleClass(LOADING_CLASS);
-  };
+GitLabDropdown.prototype.toggleLoading = function() {
+  return $('.dropdown-menu', this.dropdown).toggleClass(LOADING_CLASS);
+};
 
-  GitLabDropdown.prototype.togglePage = function() {
-    var menu;
-    menu = $('.dropdown-menu', this.dropdown);
-    if (menu.hasClass(PAGE_TWO_CLASS)) {
-      if (this.remote) {
-        this.remote.execute();
-      }
-    }
-    menu.toggleClass(PAGE_TWO_CLASS);
-    // Focus first visible input on active page
-    return this.dropdown.find('[class^="dropdown-page-"]:visible :text:visible:first').focus();
-  };
-
-  GitLabDropdown.prototype.parseData = function(data) {
-    var full_html, groupData, html, name;
-    this.renderedData = data;
-    if (this.options.filterable && data.length === 0) {
-      // render no matching results
-      html = [this.noResults()];
-    } else {
-      // Handle array groups
-      if (gl.utils.isObject(data)) {
-        html = [];
-        for (name in data) {
-          groupData = data[name];
-          html.push(this.renderItem({
-            header: name
-          // Add header for each group
-          }, name));
-          this.renderData(groupData, name).map(function(item) {
-            return html.push(item);
-          });
-        }
-      } else {
-        // Render each row
-        html = this.renderData(data);
-      }
-    }
-    // Render the full menu
-    full_html = this.renderMenu(html);
-    return this.appendMenu(full_html);
-  };
-
-  GitLabDropdown.prototype.renderData = function(data, group) {
-    if (group == null) {
-      group = false;
+GitLabDropdown.prototype.togglePage = function() {
+  var menu;
+  menu = $('.dropdown-menu', this.dropdown);
+  if (menu.hasClass(PAGE_TWO_CLASS)) {
+    if (this.remote) {
+      this.remote.execute();
     }
-    return data.map((function(_this) {
-      return function(obj, index) {
-        return _this.renderItem(obj, group, index);
-      };
-    })(this));
-  };
-
-  GitLabDropdown.prototype.shouldPropagate = function(e) {
-    var $target;
-    if (this.options.multiSelect) {
-      $target = $(e.target);
-      if ($target && !$target.hasClass('dropdown-menu-close') &&
-                     !$target.hasClass('dropdown-menu-close-icon') &&
-                     !$target.data('is-link')) {
-        e.stopPropagation();
-        return false;
-      } else {
-        return true;
+  }
+  menu.toggleClass(PAGE_TWO_CLASS);
+  // Focus first visible input on active page
+  return this.dropdown.find('[class^="dropdown-page-"]:visible :text:visible:first').focus();
+};
+
+GitLabDropdown.prototype.parseData = function(data) {
+  var full_html, groupData, html, name;
+  this.renderedData = data;
+  if (this.options.filterable && data.length === 0) {
+    // render no matching results
+    html = [this.noResults()];
+  } else {
+    // Handle array groups
+    if (gl.utils.isObject(data)) {
+      html = [];
+      for (name in data) {
+        groupData = data[name];
+        html.push(this.renderItem({
+          header: name
+        // Add header for each group
+        }, name));
+        this.renderData(groupData, name).map(function(item) {
+          return html.push(item);
+        });
       }
+    } else {
+      // Render each row
+      html = this.renderData(data);
     }
-  };
+  }
+  // Render the full menu
+  full_html = this.renderMenu(html);
+  return this.appendMenu(full_html);
+};
 
-  GitLabDropdown.prototype.opened = function(e) {
-    var contentHtml;
-    this.resetRows();
-    this.addArrowKeyEvent();
+GitLabDropdown.prototype.renderData = function(data, group) {
+  if (group == null) {
+    group = false;
+  }
+  return data.map((obj, index) => this.renderItem(obj, group, index));
+};
 
-    // Makes indeterminate items effective
-    if (this.fullData && this.dropdown.find('.dropdown-menu-toggle').hasClass('js-filter-bulk-update')) {
-      this.parseData(this.fullData);
-    }
-    contentHtml = $('.dropdown-content', this.dropdown).html();
-    if (this.remote && contentHtml === "") {
-      this.remote.execute();
+GitLabDropdown.prototype.shouldPropagate = function(e) {
+  var $target;
+  if (this.options.multiSelect) {
+    $target = $(e.target);
+    if ($target && !$target.hasClass('dropdown-menu-close') &&
+                   !$target.hasClass('dropdown-menu-close-icon') &&
+                   !$target.data('is-link')) {
+      e.stopPropagation();
+      return false;
     } else {
-      this.focusTextInput();
+      return true;
     }
+  }
+};
 
-    if (this.options.showMenuAbove) {
-      this.positionMenuAbove();
-    }
+GitLabDropdown.prototype.opened = function(e) {
+  var contentHtml;
+  this.resetRows();
+  this.addArrowKeyEvent();
 
-    if (this.options.opened) {
-      this.options.opened.call(this, e);
-    }
+  // Makes indeterminate items effective
+  if (this.fullData && this.dropdown.find('.dropdown-menu-toggle').hasClass('js-filter-bulk-update')) {
+    this.parseData(this.fullData);
+  }
+  contentHtml = $('.dropdown-content', this.dropdown).html();
+  if (this.remote && contentHtml === "") {
+    this.remote.execute();
+  } else {
+    this.focusTextInput();
+  }
 
-    return this.dropdown.trigger('shown.gl.dropdown');
-  };
+  if (this.options.showMenuAbove) {
+    this.positionMenuAbove();
+  }
 
-  GitLabDropdown.prototype.positionMenuAbove = function() {
-    var $button = $(this.el);
-    var $menu = this.dropdown.find('.dropdown-menu');
+  if (this.options.opened) {
+    this.options.opened.call(this, e);
+  }
 
-    $menu.css('top', ($button.height() + $menu.height()) * -1);
-  };
+  return this.dropdown.trigger('shown.gl.dropdown');
+};
 
-  GitLabDropdown.prototype.hidden = function(e) {
-    var $input;
-    this.resetRows();
-    this.removeArrayKeyEvent();
-    $input = this.dropdown.find(".dropdown-input-field");
-    if (this.options.filterable) {
-      $input.blur();
-    }
-    if (this.dropdown.find(".dropdown-toggle-page").length) {
-      $('.dropdown-menu', this.dropdown).removeClass(PAGE_TWO_CLASS);
-    }
-    if (this.options.hidden) {
-      this.options.hidden.call(this, e);
-    }
-    return this.dropdown.trigger('hidden.gl.dropdown');
-  };
+GitLabDropdown.prototype.positionMenuAbove = function() {
+  var $button = $(this.el);
+  var $menu = this.dropdown.find('.dropdown-menu');
 
-  // Render the full menu
-  GitLabDropdown.prototype.renderMenu = function(html) {
-    if (this.options.renderMenu) {
-      return this.options.renderMenu(html);
-    } else {
-      var ul = document.createElement('ul');
+  $menu.css('top', ($button.height() + $menu.height()) * -1);
+};
 
-      for (var i = 0; i < html.length; i += 1) {
-        var el = html[i];
+GitLabDropdown.prototype.hidden = function(e) {
+  var $input;
+  this.resetRows();
+  this.removeArrayKeyEvent();
+  $input = this.dropdown.find(".dropdown-input-field");
+  if (this.options.filterable) {
+    $input.blur();
+  }
+  if (this.dropdown.find(".dropdown-toggle-page").length) {
+    $('.dropdown-menu', this.dropdown).removeClass(PAGE_TWO_CLASS);
+  }
+  if (this.options.hidden) {
+    this.options.hidden.call(this, e);
+  }
+  return this.dropdown.trigger('hidden.gl.dropdown');
+};
 
-        if (el instanceof jQuery) {
-          el = el.get(0);
-        }
+// Render the full menu
+GitLabDropdown.prototype.renderMenu = function(html) {
+  if (this.options.renderMenu) {
+    return this.options.renderMenu(html);
+  } else {
+    var ul = document.createElement('ul');
 
-        if (typeof el === 'string') {
-          ul.innerHTML += el;
-        } else {
-          ul.appendChild(el);
-        }
+    for (var i = 0; i < html.length; i += 1) {
+      var el = html[i];
+
+      if (el instanceof jQuery) {
+        el = el.get(0);
       }
 
-      return ul;
+      if (typeof el === 'string') {
+        ul.innerHTML += el;
+      } else {
+        ul.appendChild(el);
+      }
     }
-  };
 
-  // Append the menu into the dropdown
-  GitLabDropdown.prototype.appendMenu = function(html) {
-    return this.clearMenu().append(html);
-  };
+    return ul;
+  }
+};
 
-  GitLabDropdown.prototype.clearMenu = function() {
-    var selector;
-    selector = '.dropdown-content';
-    if (this.dropdown.find(".dropdown-toggle-page").length) {
-      selector = ".dropdown-page-one .dropdown-content";
-    }
+// Append the menu into the dropdown
+GitLabDropdown.prototype.appendMenu = function(html) {
+  return this.clearMenu().append(html);
+};
 
-    return $(selector, this.dropdown).empty();
-  };
+GitLabDropdown.prototype.clearMenu = function() {
+  var selector;
+  selector = '.dropdown-content';
+  if (this.dropdown.find(".dropdown-toggle-page").length) {
+    selector = ".dropdown-page-one .dropdown-content";
+  }
+
+  return $(selector, this.dropdown).empty();
+};
 
-  GitLabDropdown.prototype.renderItem = function(data, group, index) {
-    var field, fieldName, html, selected, text, url, value;
-    if (group == null) {
-      group = false;
+GitLabDropdown.prototype.renderItem = function(data, group, index) {
+  var field, fieldName, html, selected, text, url, value;
+  if (group == null) {
+    group = false;
+  }
+  if (index == null) {
+    // Render the row
+    index = false;
+  }
+  html = document.createElement('li');
+  if (data === 'divider' || data === 'separator') {
+    html.className = data;
+    return html;
+  }
+  // Header
+  if (data.header != null) {
+    html.className = 'dropdown-header';
+    html.innerHTML = data.header;
+    return html;
+  }
+  if (this.options.renderRow) {
+    // Call the render function
+    html = this.options.renderRow.call(this.options, data, this);
+  } else {
+    if (!selected) {
+      value = this.options.id ? this.options.id(data) : data.id;
+      fieldName = this.options.fieldName;
+
+      if (value) { value = value.toString().replace(/'/g, '\\\''); }
+
+      field = this.dropdown.parent().find("input[name='" + fieldName + "'][value='" + value + "']");
+      if (field.length) {
+        selected = true;
+      }
     }
-    if (index == null) {
-      // Render the row
-      index = false;
+    // Set URL
+    if (this.options.url != null) {
+      url = this.options.url(data);
+    } else {
+      url = data.url != null ? data.url : '#';
     }
-    html = document.createElement('li');
-    if (data === 'divider' || data === 'separator') {
-      html.className = data;
-      return html;
+    // Set Text
+    if (this.options.text != null) {
+      text = this.options.text(data);
+    } else {
+      text = data.text != null ? data.text : '';
     }
-    // Header
-    if (data.header != null) {
-      html.className = 'dropdown-header';
-      html.innerHTML = data.header;
-      return html;
+    if (this.highlight) {
+      text = this.highlightTextMatches(text, this.filterInput.val());
     }
-    if (this.options.renderRow) {
-      // Call the render function
-      html = this.options.renderRow.call(this.options, data, this);
-    } else {
-      if (!selected) {
-        value = this.options.id ? this.options.id(data) : data.id;
-        fieldName = this.options.fieldName;
+    // Create the list item & the link
+    var link = document.createElement('a');
 
-        if (value) { value = value.toString().replace(/'/g, '\\\''); }
+    link.href = url;
+    link.innerHTML = text;
 
-        field = this.dropdown.parent().find("input[name='" + fieldName + "'][value='" + value + "']");
-        if (field.length) {
-          selected = true;
-        }
-      }
-      // Set URL
-      if (this.options.url != null) {
-        url = this.options.url(data);
-      } else {
-        url = data.url != null ? data.url : '#';
-      }
-      // Set Text
-      if (this.options.text != null) {
-        text = this.options.text(data);
-      } else {
-        text = data.text != null ? data.text : '';
-      }
-      if (this.highlight) {
-        text = this.highlightTextMatches(text, this.filterInput.val());
-      }
-      // Create the list item & the link
-      var link = document.createElement('a');
-
-      link.href = url;
-      link.innerHTML = text;
-
-      if (selected) {
-        link.className = 'is-active';
-      }
-
-      if (group) {
-        link.dataset.group = group;
-        link.dataset.index = index;
-      }
-
-      html.appendChild(link);
+    if (selected) {
+      link.className = 'is-active';
     }
-    return html;
-  };
-
-  GitLabDropdown.prototype.highlightTextMatches = function(text, term) {
-    var occurrences;
-    occurrences = fuzzaldrinPlus.match(text, term);
-    return text.split('').map(function(character, i) {
-      if (indexOf.call(occurrences, i) !== -1) {
-        return "<b>" + character + "</b>";
-      } else {
-        return character;
-      }
-    }).join('');
-  };
-
-  GitLabDropdown.prototype.noResults = function() {
-    var html;
-    return html = "<li class='dropdown-menu-empty-link'> <a href='#' class='is-focused'> No matching results. </a> </li>";
-  };
-
-  GitLabDropdown.prototype.rowClicked = function(el) {
-    var field, fieldName, groupName, isInput, selectedIndex, selectedObject, value, isMarking;
-
-    fieldName = this.options.fieldName;
-    isInput = $(this.el).is('input');
-    if (this.renderedData) {
-      groupName = el.data('group');
-      if (groupName) {
-        selectedIndex = el.data('index');
-        selectedObject = this.renderedData[groupName][selectedIndex];
-      } else {
-        selectedIndex = el.closest('li').index();
-        selectedObject = this.renderedData[selectedIndex];
-      }
+
+    if (group) {
+      link.dataset.group = group;
+      link.dataset.index = index;
     }
 
-    if (this.options.vue) {
-      if (el.hasClass(ACTIVE_CLASS)) {
-        el.removeClass(ACTIVE_CLASS);
-      } else {
-        el.addClass(ACTIVE_CLASS);
-      }
+    html.appendChild(link);
+  }
+  return html;
+};
 
-      return [selectedObject];
+GitLabDropdown.prototype.highlightTextMatches = function(text, term) {
+  var occurrences;
+  occurrences = fuzzaldrinPlus.match(text, term);
+  return text.split('').map(function(character, i) {
+    if (indexOf.call(occurrences, i) !== -1) {
+      return "<b>" + character + "</b>";
+    } else {
+      return character;
     }
+  }).join('');
+};
 
-    field = [];
-    value = this.options.id
-      ? this.options.id(selectedObject, el)
-      : selectedObject.id;
-    if (isInput) {
-      field = $(this.el);
-    } else if (value) {
-      field = this.dropdown.parent().find("input[name='" + fieldName + "'][value='" + value.toString().replace(/'/g, '\\\'') + "']");
-    }
+GitLabDropdown.prototype.noResults = function() {
+  var html;
+  return html = "<li class='dropdown-menu-empty-link'> <a href='#' class='is-focused'> No matching results. </a> </li>";
+};
 
-    if (this.options.isSelectable && !this.options.isSelectable(selectedObject, el)) {
-      return;
+GitLabDropdown.prototype.rowClicked = function(el) {
+  var field, fieldName, groupName, isInput, selectedIndex, selectedObject, value, isMarking;
+
+  fieldName = this.options.fieldName;
+  isInput = $(this.el).is('input');
+  if (this.renderedData) {
+    groupName = el.data('group');
+    if (groupName) {
+      selectedIndex = el.data('index');
+      selectedObject = this.renderedData[groupName][selectedIndex];
+    } else {
+      selectedIndex = el.closest('li').index();
+      selectedObject = this.renderedData[selectedIndex];
     }
+  }
 
+  if (this.options.vue) {
     if (el.hasClass(ACTIVE_CLASS)) {
-      isMarking = false;
       el.removeClass(ACTIVE_CLASS);
-      if (field && field.length) {
-        this.clearField(field, isInput);
-      }
-    } else if (el.hasClass(INDETERMINATE_CLASS)) {
-      isMarking = true;
-      el.addClass(ACTIVE_CLASS);
-      el.removeClass(INDETERMINATE_CLASS);
-      if (field && field.length && value == null) {
-        this.clearField(field, isInput);
-      }
-      if ((!field || !field.length) && fieldName) {
-        this.addInput(fieldName, value, selectedObject);
-      }
     } else {
-      isMarking = true;
-      if (!this.options.multiSelect || el.hasClass('dropdown-clear-active')) {
-        this.dropdown.find("." + ACTIVE_CLASS).removeClass(ACTIVE_CLASS);
-        if (!isInput) {
-          this.dropdown.parent().find("input[name='" + fieldName + "']").remove();
-        }
-      }
-      if (field && field.length && value == null) {
-        this.clearField(field, isInput);
-      }
-      // Toggle active class for the tick mark
       el.addClass(ACTIVE_CLASS);
-      if (value != null) {
-        if ((!field || !field.length) && fieldName) {
-          this.addInput(fieldName, value, selectedObject);
-        } else if (field && field.length) {
-          field.val(value).trigger('change');
-        }
-      }
     }
 
-    return [selectedObject, isMarking];
-  };
+    return [selectedObject];
+  }
 
-  GitLabDropdown.prototype.focusTextInput = function() {
-    if (this.options.filterable) { this.filterInput.focus(); }
-  };
+  field = [];
+  value = this.options.id
+    ? this.options.id(selectedObject, el)
+    : selectedObject.id;
+  if (isInput) {
+    field = $(this.el);
+  } else if (value) {
+    field = this.dropdown.parent().find("input[name='" + fieldName + "'][value='" + value.toString().replace(/'/g, '\\\'') + "']");
+  }
 
-  GitLabDropdown.prototype.addInput = function(fieldName, value, selectedObject) {
-    var $input;
-    // Create hidden input for form
-    $input = $('<input>').attr('type', 'hidden').attr('name', fieldName).val(value);
-    if (this.options.inputId != null) {
-      $input.attr('id', this.options.inputId);
-    }
-    return this.dropdown.before($input);
-  };
-
-  GitLabDropdown.prototype.selectRowAtIndex = function(index) {
-    var $el, selector;
-    // If we pass an option index
-    if (typeof index !== "undefined") {
-      selector = SELECTABLE_CLASSES + ":eq(" + index + ") a";
-    } else {
-      selector = ".dropdown-content .is-focused";
+  if (this.options.isSelectable && !this.options.isSelectable(selectedObject, el)) {
+    return;
+  }
+
+  if (el.hasClass(ACTIVE_CLASS)) {
+    isMarking = false;
+    el.removeClass(ACTIVE_CLASS);
+    if (field && field.length) {
+      this.clearField(field, isInput);
+    }
+  } else if (el.hasClass(INDETERMINATE_CLASS)) {
+    isMarking = true;
+    el.addClass(ACTIVE_CLASS);
+    el.removeClass(INDETERMINATE_CLASS);
+    if (field && field.length && value == null) {
+      this.clearField(field, isInput);
+    }
+    if ((!field || !field.length) && fieldName) {
+      this.addInput(fieldName, value, selectedObject);
+    }
+  } else {
+    isMarking = true;
+    if (!this.options.multiSelect || el.hasClass('dropdown-clear-active')) {
+      this.dropdown.find("." + ACTIVE_CLASS).removeClass(ACTIVE_CLASS);
+      if (!isInput) {
+        this.dropdown.parent().find("input[name='" + fieldName + "']").remove();
+      }
     }
-    if (this.dropdown.find(".dropdown-toggle-page").length) {
-      selector = ".dropdown-page-one " + selector;
+    if (field && field.length && value == null) {
+      this.clearField(field, isInput);
     }
-    // simulate a click on the first link
-    $el = $(selector, this.dropdown);
-    if ($el.length) {
-      var href = $el.attr('href');
-      if (href && href !== '#') {
-        gl.utils.visitUrl(href);
-      } else {
-        $el.first().trigger('click');
+    // Toggle active class for the tick mark
+    el.addClass(ACTIVE_CLASS);
+    if (value != null) {
+      if ((!field || !field.length) && fieldName) {
+        this.addInput(fieldName, value, selectedObject);
+      } else if (field && field.length) {
+        field.val(value).trigger('change');
       }
     }
-  };
+  }
 
-  GitLabDropdown.prototype.addArrowKeyEvent = function() {
-    var $input, ARROW_KEY_CODES, selector;
-    ARROW_KEY_CODES = [38, 40];
-    $input = this.dropdown.find(".dropdown-input-field");
-    selector = SELECTABLE_CLASSES;
-    if (this.dropdown.find(".dropdown-toggle-page").length) {
-      selector = ".dropdown-page-one " + selector;
+  return [selectedObject, isMarking];
+};
+
+GitLabDropdown.prototype.focusTextInput = function() {
+  if (this.options.filterable) { this.filterInput.focus(); }
+};
+
+GitLabDropdown.prototype.addInput = function(fieldName, value, selectedObject) {
+  var $input;
+  // Create hidden input for form
+  $input = $('<input>').attr('type', 'hidden').attr('name', fieldName).val(value);
+  if (this.options.inputId != null) {
+    $input.attr('id', this.options.inputId);
+  }
+  return this.dropdown.before($input);
+};
+
+GitLabDropdown.prototype.selectRowAtIndex = function(index) {
+  var $el, selector;
+  // If we pass an option index
+  if (typeof index !== "undefined") {
+    selector = SELECTABLE_CLASSES + ":eq(" + index + ") a";
+  } else {
+    selector = ".dropdown-content .is-focused";
+  }
+  if (this.dropdown.find(".dropdown-toggle-page").length) {
+    selector = ".dropdown-page-one " + selector;
+  }
+  // simulate a click on the first link
+  $el = $(selector, this.dropdown);
+  if ($el.length) {
+    var href = $el.attr('href');
+    if (href && href !== '#') {
+      gl.utils.visitUrl(href);
+    } else {
+      $el.first().trigger('click');
     }
-    return $('body').on('keydown', (function(_this) {
-      return function(e) {
-        var $listItems, PREV_INDEX, currentKeyCode;
-        currentKeyCode = e.which;
-        if (ARROW_KEY_CODES.indexOf(currentKeyCode) !== -1) {
-          e.preventDefault();
-          e.stopImmediatePropagation();
-          PREV_INDEX = currentIndex;
-          $listItems = $(selector, _this.dropdown);
-          // if @options.filterable
-          //   $input.blur()
-          if (currentKeyCode === 40) {
-            // Move down
-            if (currentIndex < ($listItems.length - 1)) {
-              currentIndex += 1;
-            }
-          } else if (currentKeyCode === 38) {
-            // Move up
-            if (currentIndex > 0) {
-              currentIndex -= 1;
-            }
-          }
-          if (currentIndex !== PREV_INDEX) {
-            _this.highlightRowAtIndex($listItems, currentIndex);
-          }
-          return false;
+  }
+};
+
+GitLabDropdown.prototype.addArrowKeyEvent = function() {
+  var $input, ARROW_KEY_CODES, selector;
+  ARROW_KEY_CODES = [38, 40];
+  $input = this.dropdown.find(".dropdown-input-field");
+  selector = SELECTABLE_CLASSES;
+  if (this.dropdown.find(".dropdown-toggle-page").length) {
+    selector = ".dropdown-page-one " + selector;
+  }
+  return $('body').on('keydown', (e) => {
+    var $listItems, PREV_INDEX, currentKeyCode;
+    currentKeyCode = e.which;
+    if (ARROW_KEY_CODES.indexOf(currentKeyCode) !== -1) {
+      e.preventDefault();
+      e.stopImmediatePropagation();
+      PREV_INDEX = currentIndex;
+      $listItems = $(selector, this.dropdown);
+      // if @options.filterable
+      //   $input.blur()
+      if (currentKeyCode === 40) {
+        // Move down
+        if (currentIndex < ($listItems.length - 1)) {
+          currentIndex += 1;
         }
-        if (currentKeyCode === 13 && currentIndex !== -1) {
-          e.preventDefault();
-          _this.selectRowAtIndex();
+      } else if (currentKeyCode === 38) {
+        // Move up
+        if (currentIndex > 0) {
+          currentIndex -= 1;
         }
-      };
-    })(this));
-  };
-
-  GitLabDropdown.prototype.removeArrayKeyEvent = function() {
-    return $('body').off('keydown');
-  };
-
-  GitLabDropdown.prototype.resetRows = function resetRows() {
-    currentIndex = -1;
-    $('.is-focused', this.dropdown).removeClass('is-focused');
-  };
-
-  GitLabDropdown.prototype.highlightRowAtIndex = function($listItems, index) {
-    var $dropdownContent, $listItem, dropdownContentBottom, dropdownContentHeight, dropdownContentTop, dropdownScrollTop, listItemBottom, listItemHeight, listItemTop;
-    // Remove the class for the previously focused row
-    $('.is-focused', this.dropdown).removeClass('is-focused');
-    // Update the class for the row at the specific index
-    $listItem = $listItems.eq(index);
-    $listItem.find('a:first-child').addClass("is-focused");
-    // Dropdown content scroll area
-    $dropdownContent = $listItem.closest('.dropdown-content');
-    dropdownScrollTop = $dropdownContent.scrollTop();
-    dropdownContentHeight = $dropdownContent.outerHeight();
-    dropdownContentTop = $dropdownContent.prop('offsetTop');
-    dropdownContentBottom = dropdownContentTop + dropdownContentHeight;
-    // Get the offset bottom of the list item
-    listItemHeight = $listItem.outerHeight();
-    listItemTop = $listItem.prop('offsetTop');
-    listItemBottom = listItemTop + listItemHeight;
-    if (!index) {
-      // Scroll the dropdown content to the top
-      $dropdownContent.scrollTop(0);
-    } else if (index === ($listItems.length - 1)) {
-      // Scroll the dropdown content to the bottom
-      $dropdownContent.scrollTop($dropdownContent.prop('scrollHeight'));
-    } else if (listItemBottom > (dropdownContentBottom + dropdownScrollTop)) {
-      // Scroll the dropdown content down
-      $dropdownContent.scrollTop(listItemBottom - dropdownContentBottom + CURSOR_SELECT_SCROLL_PADDING);
-    } else if (listItemTop < (dropdownContentTop + dropdownScrollTop)) {
-      // Scroll the dropdown content up
-      return $dropdownContent.scrollTop(listItemTop - dropdownContentTop - CURSOR_SELECT_SCROLL_PADDING);
-    }
-  };
-
-  GitLabDropdown.prototype.updateLabel = function(selected, el, instance) {
-    if (selected == null) {
-      selected = null;
-    }
-    if (el == null) {
-      el = null;
+      }
+      if (currentIndex !== PREV_INDEX) {
+        this.highlightRowAtIndex($listItems, currentIndex);
+      }
+      return false;
     }
-    if (instance == null) {
-      instance = null;
+    if (currentKeyCode === 13 && currentIndex !== -1) {
+      e.preventDefault();
+      this.selectRowAtIndex();
     }
-    return $(this.el).find(".dropdown-toggle-text").text(this.options.toggleLabel(selected, el, instance));
-  };
+  });
+};
+
+GitLabDropdown.prototype.removeArrayKeyEvent = function() {
+  return $('body').off('keydown');
+};
+
+GitLabDropdown.prototype.resetRows = function resetRows() {
+  currentIndex = -1;
+  $('.is-focused', this.dropdown).removeClass('is-focused');
+};
+
+GitLabDropdown.prototype.highlightRowAtIndex = function($listItems, index) {
+  var $dropdownContent, $listItem, dropdownContentBottom, dropdownContentHeight, dropdownContentTop, dropdownScrollTop, listItemBottom, listItemHeight, listItemTop;
+  // Remove the class for the previously focused row
+  $('.is-focused', this.dropdown).removeClass('is-focused');
+  // Update the class for the row at the specific index
+  $listItem = $listItems.eq(index);
+  $listItem.find('a:first-child').addClass("is-focused");
+  // Dropdown content scroll area
+  $dropdownContent = $listItem.closest('.dropdown-content');
+  dropdownScrollTop = $dropdownContent.scrollTop();
+  dropdownContentHeight = $dropdownContent.outerHeight();
+  dropdownContentTop = $dropdownContent.prop('offsetTop');
+  dropdownContentBottom = dropdownContentTop + dropdownContentHeight;
+  // Get the offset bottom of the list item
+  listItemHeight = $listItem.outerHeight();
+  listItemTop = $listItem.prop('offsetTop');
+  listItemBottom = listItemTop + listItemHeight;
+  if (!index) {
+    // Scroll the dropdown content to the top
+    $dropdownContent.scrollTop(0);
+  } else if (index === ($listItems.length - 1)) {
+    // Scroll the dropdown content to the bottom
+    $dropdownContent.scrollTop($dropdownContent.prop('scrollHeight'));
+  } else if (listItemBottom > (dropdownContentBottom + dropdownScrollTop)) {
+    // Scroll the dropdown content down
+    $dropdownContent.scrollTop(listItemBottom - dropdownContentBottom + CURSOR_SELECT_SCROLL_PADDING);
+  } else if (listItemTop < (dropdownContentTop + dropdownScrollTop)) {
+    // Scroll the dropdown content up
+    return $dropdownContent.scrollTop(listItemTop - dropdownContentTop - CURSOR_SELECT_SCROLL_PADDING);
+  }
+};
 
-  GitLabDropdown.prototype.clearField = function(field, isInput) {
-    return isInput ? field.val('') : field.remove();
-  };
+GitLabDropdown.prototype.updateLabel = function(selected, el, instance) {
+  if (selected == null) {
+    selected = null;
+  }
+  if (el == null) {
+    el = null;
+  }
+  if (instance == null) {
+    instance = null;
+  }
+  return $(this.el).find(".dropdown-toggle-text").text(this.options.toggleLabel(selected, el, instance));
+};
 
-  return GitLabDropdown;
-})();
+GitLabDropdown.prototype.clearField = function(field, isInput) {
+  return isInput ? field.val('') : field.remove();
+};
 
 $.fn.glDropdown = function(opts) {
   return this.each(function() {
diff --git a/app/assets/javascripts/group_avatar.js b/app/assets/javascripts/group_avatar.js
index f03b47b1c1d..e60a33fbf4a 100644
--- a/app/assets/javascripts/group_avatar.js
+++ b/app/assets/javascripts/group_avatar.js
@@ -1,19 +1,17 @@
 /* eslint-disable func-names, space-before-function-paren, wrap-iife, quotes, no-var, one-var, one-var-declaration-per-line, no-useless-escape, max-len */
 
-window.GroupAvatar = (function() {
-  function GroupAvatar() {
-    $('.js-choose-group-avatar-button').on("click", function() {
-      var form;
-      form = $(this).closest("form");
-      return form.find(".js-group-avatar-input").click();
-    });
-    $('.js-group-avatar-input').on("change", function() {
-      var filename, form;
-      form = $(this).closest("form");
-      filename = $(this).val().replace(/^.*[\\\/]/, '');
-      return form.find(".js-avatar-filename").text(filename);
-    });
-  }
+function GroupAvatar() {
+  $('.js-choose-group-avatar-button').on("click", function() {
+    var form;
+    form = $(this).closest("form");
+    return form.find(".js-group-avatar-input").click();
+  });
+  $('.js-group-avatar-input').on("change", function() {
+    var filename, form;
+    form = $(this).closest("form");
+    filename = $(this).val().replace(/^.*[\\\/]/, '');
+    return form.find(".js-avatar-filename").text(filename);
+  });
+}
 
-  return GroupAvatar;
-})();
+window.GroupAvatar = GroupAvatar;
diff --git a/app/assets/javascripts/groups_select.js b/app/assets/javascripts/groups_select.js
index 602a3b78189..6235b422665 100644
--- a/app/assets/javascripts/groups_select.js
+++ b/app/assets/javascripts/groups_select.js
@@ -3,115 +3,109 @@
 
 var slice = [].slice;
 
-window.GroupsSelect = (function() {
-  function GroupsSelect() {
-    $('.ajax-groups-select').each((function(_this) {
-      const self = _this;
+function GroupsSelect() {
+  $('.ajax-groups-select').each((i, select) => {
+    var all_available, skip_groups;
+    const $select = $(select);
+    all_available = $select.data('all-available');
+    skip_groups = $select.data('skip-groups') || [];
 
-      return function(i, select) {
-        var all_available, skip_groups;
-        const $select = $(select);
-        all_available = $select.data('all-available');
-        skip_groups = $select.data('skip-groups') || [];
+    $select.select2({
+      placeholder: "Search for a group",
+      multiple: $select.hasClass('multiselect'),
+      minimumInputLength: 0,
+      ajax: {
+        url: Api.buildUrl(Api.groupsPath),
+        dataType: 'json',
+        quietMillis: 250,
+        transport: function (params) {
+          $.ajax(params).then((data, status, xhr) => {
+            const results = data || [];
 
-        $select.select2({
-          placeholder: "Search for a group",
-          multiple: $select.hasClass('multiselect'),
-          minimumInputLength: 0,
-          ajax: {
-            url: Api.buildUrl(Api.groupsPath),
-            dataType: 'json',
-            quietMillis: 250,
-            transport: function (params) {
-              $.ajax(params).then((data, status, xhr) => {
-                const results = data || [];
+            const headers = gl.utils.normalizeCRLFHeaders(xhr.getAllResponseHeaders());
+            const currentPage = parseInt(headers['X-PAGE'], 10) || 0;
+            const totalPages = parseInt(headers['X-TOTAL-PAGES'], 10) || 0;
+            const more = currentPage < totalPages;
 
-                const headers = gl.utils.normalizeCRLFHeaders(xhr.getAllResponseHeaders());
-                const currentPage = parseInt(headers['X-PAGE'], 10) || 0;
-                const totalPages = parseInt(headers['X-TOTAL-PAGES'], 10) || 0;
-                const more = currentPage < totalPages;
+            return {
+              results,
+              pagination: {
+                more,
+              },
+            };
+          }).then(params.success).fail(params.error);
+        },
+        data: function (search, page) {
+          return {
+            search,
+            page,
+            per_page: GroupsSelect.PER_PAGE,
+            all_available,
+            skip_groups,
+          };
+        },
+        results: function (data, page) {
+          if (data.length) return { results: [] };
 
-                return {
-                  results,
-                  pagination: {
-                    more,
-                  },
-                };
-              }).then(params.success).fail(params.error);
-            },
-            data: function (search, page) {
-              return {
-                search,
-                page,
-                per_page: GroupsSelect.PER_PAGE,
-                all_available,
-                skip_groups,
-              };
-            },
-            results: function (data, page) {
-              if (data.length) return { results: [] };
+          const results = data.length ? data : data.results || [];
+          const more = data.pagination ? data.pagination.more : false;
 
-              const results = data.length ? data : data.results || [];
-              const more = data.pagination ? data.pagination.more : false;
+          return {
+            results,
+            page,
+            more,
+          };
+        },
+      },
+      initSelection: function(element, callback) {
+        var id;
+        id = $(element).val();
+        if (id !== "") {
+          return Api.group(id, callback);
+        }
+      },
+      formatResult: function() {
+        var args;
+        args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
+        return this.formatResult.apply(this, args);
+      },
+      formatSelection: function() {
+        var args;
+        args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
+        return this.formatSelection.apply(this, args);
+      },
+      dropdownCssClass: "ajax-groups-dropdown select2-infinite",
+      // we do not want to escape markup since we are displaying html in results
+      escapeMarkup: function(m) {
+        return m;
+      }
+    });
 
-              return {
-                results,
-                page,
-                more,
-              };
-            },
-          },
-          initSelection: function(element, callback) {
-            var id;
-            id = $(element).val();
-            if (id !== "") {
-              return Api.group(id, callback);
-            }
-          },
-          formatResult: function() {
-            var args;
-            args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
-            return self.formatResult.apply(self, args);
-          },
-          formatSelection: function() {
-            var args;
-            args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
-            return self.formatSelection.apply(self, args);
-          },
-          dropdownCssClass: "ajax-groups-dropdown select2-infinite",
-          // we do not want to escape markup since we are displaying html in results
-          escapeMarkup: function(m) {
-            return m;
-          }
-        });
+    this.dropdown = document.querySelector('.select2-infinite .select2-results');
 
-        self.dropdown = document.querySelector('.select2-infinite .select2-results');
+    $select.on('select2-loaded', this.forceOverflow.bind(this));
+  });
+}
 
-        $select.on('select2-loaded', self.forceOverflow.bind(self));
-      };
-    })(this));
+GroupsSelect.prototype.formatResult = function(group) {
+  var avatar;
+  if (group.avatar_url) {
+    avatar = group.avatar_url;
+  } else {
+    avatar = gon.default_avatar_url;
   }
+  return "<div class='group-result'> <div class='group-name'>" + group.full_name + "</div> <div class='group-path'>" + group.full_path + "</div> </div>";
+};
 
-  GroupsSelect.prototype.formatResult = function(group) {
-    var avatar;
-    if (group.avatar_url) {
-      avatar = group.avatar_url;
-    } else {
-      avatar = gon.default_avatar_url;
-    }
-    return "<div class='group-result'> <div class='group-name'>" + group.full_name + "</div> <div class='group-path'>" + group.full_path + "</div> </div>";
-  };
-
-  GroupsSelect.prototype.formatSelection = function(group) {
-    return group.full_name;
-  };
+GroupsSelect.prototype.formatSelection = function(group) {
+  return group.full_name;
+};
 
-  GroupsSelect.prototype.forceOverflow = function (e) {
-    const itemHeight = this.dropdown.querySelector('.select2-result:first-child').clientHeight;
-    this.dropdown.style.height = `${Math.floor(this.dropdown.scrollHeight - (itemHeight * 0.9))}px`;
-  };
+GroupsSelect.prototype.forceOverflow = function (e) {
+  const itemHeight = this.dropdown.querySelector('.select2-result:first-child').clientHeight;
+  this.dropdown.style.height = `${Math.floor(this.dropdown.scrollHeight - (itemHeight * 0.9))}px`;
+};
 
-  GroupsSelect.PER_PAGE = 20;
+GroupsSelect.PER_PAGE = 20;
 
-  return GroupsSelect;
-})();
+window.GroupsSelect = GroupsSelect;
diff --git a/app/assets/javascripts/profile/gl_crop.js b/app/assets/javascripts/profile/gl_crop.js
index cf1566eeb87..3ce5588ad0d 100644
--- a/app/assets/javascripts/profile/gl_crop.js
+++ b/app/assets/javascripts/profile/gl_crop.js
@@ -2,172 +2,172 @@
 
 import 'vendor/cropper';
 
-((global) => {
-  // Matches everything but the file name
-  const FILENAMEREGEX = /^.*[\\\/]/;
-
-  class GitLabCrop {
-    constructor(input, { filename, previewImage, modalCrop, pickImageEl, uploadImageBtn, modalCropImg,
-        exportWidth = 200, exportHeight = 200, cropBoxWidth = 200, cropBoxHeight = 200 } = {}) {
-      this.onUploadImageBtnClick = this.onUploadImageBtnClick.bind(this);
-      this.onModalHide = this.onModalHide.bind(this);
-      this.onModalShow = this.onModalShow.bind(this);
-      this.onPickImageClick = this.onPickImageClick.bind(this);
-      this.fileInput = $(input);
-      this.modalCropImg = _.isString(this.modalCropImg) ? $(this.modalCropImg) : this.modalCropImg;
-      this.fileInput.attr('name', `${this.fileInput.attr('name')}-trigger`).attr('id', `${this.fileInput.attr('id')}-trigger`);
-      this.exportWidth = exportWidth;
-      this.exportHeight = exportHeight;
-      this.cropBoxWidth = cropBoxWidth;
-      this.cropBoxHeight = cropBoxHeight;
-      this.form = this.fileInput.parents('form');
-      this.filename = filename;
-      this.previewImage = previewImage;
-      this.modalCrop = modalCrop;
-      this.pickImageEl = pickImageEl;
-      this.uploadImageBtn = uploadImageBtn;
-      this.modalCropImg = modalCropImg;
-      this.filename = this.getElement(filename);
-      this.previewImage = this.getElement(previewImage);
-      this.pickImageEl = this.getElement(pickImageEl);
-      this.modalCrop = _.isString(modalCrop) ? $(modalCrop) : modalCrop;
-      this.uploadImageBtn = _.isString(uploadImageBtn) ? $(uploadImageBtn) : uploadImageBtn;
-      this.modalCropImg = _.isString(modalCropImg) ? $(modalCropImg) : modalCropImg;
-      this.cropActionsBtn = this.modalCrop.find('[data-method]');
-      this.bindEvents();
-    }
+window.gl = window.gl || (window.gl = {});
+
+// Matches everything but the file name
+const FILENAMEREGEX = /^.*[\\\/]/;
+
+class GitLabCrop {
+  constructor(input, { filename, previewImage, modalCrop, pickImageEl, uploadImageBtn, modalCropImg,
+      exportWidth = 200, exportHeight = 200, cropBoxWidth = 200, cropBoxHeight = 200 } = {}) {
+    this.onUploadImageBtnClick = this.onUploadImageBtnClick.bind(this);
+    this.onModalHide = this.onModalHide.bind(this);
+    this.onModalShow = this.onModalShow.bind(this);
+    this.onPickImageClick = this.onPickImageClick.bind(this);
+    this.fileInput = $(input);
+    this.modalCropImg = _.isString(this.modalCropImg) ? $(this.modalCropImg) : this.modalCropImg;
+    this.fileInput.attr('name', `${this.fileInput.attr('name')}-trigger`).attr('id', `${this.fileInput.attr('id')}-trigger`);
+    this.exportWidth = exportWidth;
+    this.exportHeight = exportHeight;
+    this.cropBoxWidth = cropBoxWidth;
+    this.cropBoxHeight = cropBoxHeight;
+    this.form = this.fileInput.parents('form');
+    this.filename = filename;
+    this.previewImage = previewImage;
+    this.modalCrop = modalCrop;
+    this.pickImageEl = pickImageEl;
+    this.uploadImageBtn = uploadImageBtn;
+    this.modalCropImg = modalCropImg;
+    this.filename = this.getElement(filename);
+    this.previewImage = this.getElement(previewImage);
+    this.pickImageEl = this.getElement(pickImageEl);
+    this.modalCrop = _.isString(modalCrop) ? $(modalCrop) : modalCrop;
+    this.uploadImageBtn = _.isString(uploadImageBtn) ? $(uploadImageBtn) : uploadImageBtn;
+    this.modalCropImg = _.isString(modalCropImg) ? $(modalCropImg) : modalCropImg;
+    this.cropActionsBtn = this.modalCrop.find('[data-method]');
+    this.bindEvents();
+  }
 
-    getElement(selector) {
-      return $(selector, this.form);
-    }
+  getElement(selector) {
+    return $(selector, this.form);
+  }
 
-    bindEvents() {
-      var _this;
-      _this = this;
-      this.fileInput.on('change', function(e) {
-        return _this.onFileInputChange(e, this);
-      });
-      this.pickImageEl.on('click', this.onPickImageClick);
-      this.modalCrop.on('shown.bs.modal', this.onModalShow);
-      this.modalCrop.on('hidden.bs.modal', this.onModalHide);
-      this.uploadImageBtn.on('click', this.onUploadImageBtnClick);
-      this.cropActionsBtn.on('click', function(e) {
-        var btn;
-        btn = this;
-        return _this.onActionBtnClick(btn);
-      });
-      return this.croppedImageBlob = null;
-    }
+  bindEvents() {
+    var _this;
+    _this = this;
+    this.fileInput.on('change', function(e) {
+      return _this.onFileInputChange(e, this);
+    });
+    this.pickImageEl.on('click', this.onPickImageClick);
+    this.modalCrop.on('shown.bs.modal', this.onModalShow);
+    this.modalCrop.on('hidden.bs.modal', this.onModalHide);
+    this.uploadImageBtn.on('click', this.onUploadImageBtnClick);
+    this.cropActionsBtn.on('click', function(e) {
+      var btn;
+      btn = this;
+      return _this.onActionBtnClick(btn);
+    });
+    return this.croppedImageBlob = null;
+  }
 
-    onPickImageClick() {
-      return this.fileInput.trigger('click');
-    }
+  onPickImageClick() {
+    return this.fileInput.trigger('click');
+  }
 
-    onModalShow() {
-      var _this;
-      _this = this;
-      return this.modalCropImg.cropper({
-        viewMode: 1,
-        center: false,
-        aspectRatio: 1,
-        modal: true,
-        scalable: false,
-        rotatable: false,
-        zoomable: true,
-        dragMode: 'move',
-        guides: false,
-        zoomOnTouch: false,
-        zoomOnWheel: false,
-        cropBoxMovable: false,
-        cropBoxResizable: false,
-        toggleDragModeOnDblclick: false,
-        built: function() {
-          var $image, container, cropBoxHeight, cropBoxWidth;
-          $image = $(this);
-          container = $image.cropper('getContainerData');
-          cropBoxWidth = _this.cropBoxWidth;
-          cropBoxHeight = _this.cropBoxHeight;
-          return $image.cropper('setCropBoxData', {
-            width: cropBoxWidth,
-            height: cropBoxHeight,
-            left: (container.width - cropBoxWidth) / 2,
-            top: (container.height - cropBoxHeight) / 2
-          });
-        }
-      });
-    }
+  onModalShow() {
+    var _this;
+    _this = this;
+    return this.modalCropImg.cropper({
+      viewMode: 1,
+      center: false,
+      aspectRatio: 1,
+      modal: true,
+      scalable: false,
+      rotatable: false,
+      zoomable: true,
+      dragMode: 'move',
+      guides: false,
+      zoomOnTouch: false,
+      zoomOnWheel: false,
+      cropBoxMovable: false,
+      cropBoxResizable: false,
+      toggleDragModeOnDblclick: false,
+      built: function() {
+        var $image, container, cropBoxHeight, cropBoxWidth;
+        $image = $(this);
+        container = $image.cropper('getContainerData');
+        cropBoxWidth = _this.cropBoxWidth;
+        cropBoxHeight = _this.cropBoxHeight;
+        return $image.cropper('setCropBoxData', {
+          width: cropBoxWidth,
+          height: cropBoxHeight,
+          left: (container.width - cropBoxWidth) / 2,
+          top: (container.height - cropBoxHeight) / 2
+        });
+      }
+    });
+  }
 
-    onModalHide() {
-      return this.modalCropImg.attr('src', '').cropper('destroy');
-    }
+  onModalHide() {
+    return this.modalCropImg.attr('src', '').cropper('destroy');
+  }
 
-    onUploadImageBtnClick(e) {
-      e.preventDefault();
-      this.setBlob();
-      this.setPreview();
-      this.modalCrop.modal('hide');
-      return this.fileInput.val('');
-    }
+  onUploadImageBtnClick(e) {
+    e.preventDefault();
+    this.setBlob();
+    this.setPreview();
+    this.modalCrop.modal('hide');
+    return this.fileInput.val('');
+  }
 
-    onActionBtnClick(btn) {
-      var data, result;
-      data = $(btn).data();
-      if (this.modalCropImg.data('cropper') && data.method) {
-        return result = this.modalCropImg.cropper(data.method, data.option);
-      }
+  onActionBtnClick(btn) {
+    var data, result;
+    data = $(btn).data();
+    if (this.modalCropImg.data('cropper') && data.method) {
+      return result = this.modalCropImg.cropper(data.method, data.option);
     }
+  }
 
-    onFileInputChange(e, input) {
-      return this.readFile(input);
-    }
+  onFileInputChange(e, input) {
+    return this.readFile(input);
+  }
 
-    readFile(input) {
-      var _this, reader;
-      _this = this;
-      reader = new FileReader;
-      reader.onload = () => {
-        _this.modalCropImg.attr('src', reader.result);
-        return _this.modalCrop.modal('show');
-      };
-      return reader.readAsDataURL(input.files[0]);
-    }
+  readFile(input) {
+    var _this, reader;
+    _this = this;
+    reader = new FileReader;
+    reader.onload = () => {
+      _this.modalCropImg.attr('src', reader.result);
+      return _this.modalCrop.modal('show');
+    };
+    return reader.readAsDataURL(input.files[0]);
+  }
 
-    dataURLtoBlob(dataURL) {
-      var array, binary, i, k, len, v;
-      binary = atob(dataURL.split(',')[1]);
-      array = [];
-      for (k = i = 0, len = binary.length; i < len; k = (i += 1)) {
-        v = binary[k];
-        array.push(binary.charCodeAt(k));
-      }
-      return new Blob([new Uint8Array(array)], {
-        type: 'image/png'
-      });
+  dataURLtoBlob(dataURL) {
+    var array, binary, i, k, len, v;
+    binary = atob(dataURL.split(',')[1]);
+    array = [];
+    for (k = i = 0, len = binary.length; i < len; k = (i += 1)) {
+      v = binary[k];
+      array.push(binary.charCodeAt(k));
     }
+    return new Blob([new Uint8Array(array)], {
+      type: 'image/png'
+    });
+  }
 
-    setPreview() {
-      var filename;
-      this.previewImage.attr('src', this.dataURL);
-      filename = this.fileInput.val().replace(FILENAMEREGEX, '');
-      return this.filename.text(filename);
-    }
+  setPreview() {
+    var filename;
+    this.previewImage.attr('src', this.dataURL);
+    filename = this.fileInput.val().replace(FILENAMEREGEX, '');
+    return this.filename.text(filename);
+  }
 
-    setBlob() {
-      this.dataURL = this.modalCropImg.cropper('getCroppedCanvas', {
-        width: 200,
-        height: 200
-      }).toDataURL('image/png');
-      return this.croppedImageBlob = this.dataURLtoBlob(this.dataURL);
-    }
+  setBlob() {
+    this.dataURL = this.modalCropImg.cropper('getCroppedCanvas', {
+      width: 200,
+      height: 200
+    }).toDataURL('image/png');
+    return this.croppedImageBlob = this.dataURLtoBlob(this.dataURL);
+  }
 
-    getBlob() {
-      return this.croppedImageBlob;
-    }
+  getBlob() {
+    return this.croppedImageBlob;
   }
+}
 
-  $.fn.glCrop = function(opts) {
-    return this.each(function() {
-      return $(this).data('glcrop', new GitLabCrop(this, opts));
-    });
-  };
-})(window.gl || (window.gl = {}));
+$.fn.glCrop = function(opts) {
+  return this.each(function() {
+    return $(this).data('glcrop', new GitLabCrop(this, opts));
+  });
+};
diff --git a/spec/javascripts/gl_dropdown_spec.js b/spec/javascripts/gl_dropdown_spec.js
index c207fb00a47..04fdf060462 100644
--- a/spec/javascripts/gl_dropdown_spec.js
+++ b/spec/javascripts/gl_dropdown_spec.js
@@ -5,192 +5,190 @@ require('~/lib/utils/common_utils');
 require('~/lib/utils/type_utility');
 require('~/lib/utils/url_utility');
 
-(() => {
-  const NON_SELECTABLE_CLASSES = '.divider, .separator, .dropdown-header, .dropdown-menu-empty-link';
-  const SEARCH_INPUT_SELECTOR = '.dropdown-input-field';
-  const ITEM_SELECTOR = `.dropdown-content li:not(${NON_SELECTABLE_CLASSES})`;
-  const FOCUSED_ITEM_SELECTOR = `${ITEM_SELECTOR} a.is-focused`;
-
-  const ARROW_KEYS = {
-    DOWN: 40,
-    UP: 38,
-    ENTER: 13,
-    ESC: 27
-  };
-
-  let remoteCallback;
-
-  const navigateWithKeys = function navigateWithKeys(direction, steps, cb, i) {
-    i = i || 0;
-    if (!i) direction = direction.toUpperCase();
-    $('body').trigger({
-      type: 'keydown',
-      which: ARROW_KEYS[direction],
-      keyCode: ARROW_KEYS[direction]
+const NON_SELECTABLE_CLASSES = '.divider, .separator, .dropdown-header, .dropdown-menu-empty-link';
+const SEARCH_INPUT_SELECTOR = '.dropdown-input-field';
+const ITEM_SELECTOR = `.dropdown-content li:not(${NON_SELECTABLE_CLASSES})`;
+const FOCUSED_ITEM_SELECTOR = `${ITEM_SELECTOR} a.is-focused`;
+
+const ARROW_KEYS = {
+  DOWN: 40,
+  UP: 38,
+  ENTER: 13,
+  ESC: 27
+};
+
+let remoteCallback;
+
+const navigateWithKeys = function navigateWithKeys(direction, steps, cb, i) {
+  i = i || 0;
+  if (!i) direction = direction.toUpperCase();
+  $('body').trigger({
+    type: 'keydown',
+    which: ARROW_KEYS[direction],
+    keyCode: ARROW_KEYS[direction]
+  });
+  i += 1;
+  if (i <= steps) {
+    navigateWithKeys(direction, steps, cb, i);
+  } else {
+    cb();
+  }
+};
+
+const remoteMock = function remoteMock(data, term, callback) {
+  remoteCallback = callback.bind({}, data);
+};
+
+describe('Dropdown', function describeDropdown() {
+  preloadFixtures('static/gl_dropdown.html.raw');
+  loadJSONFixtures('projects.json');
+
+  function initDropDown(hasRemote, isFilterable) {
+    this.dropdownButtonElement = $('#js-project-dropdown', this.dropdownContainerElement).glDropdown({
+      selectable: true,
+      filterable: isFilterable,
+      data: hasRemote ? remoteMock.bind({}, this.projectsData) : this.projectsData,
+      search: {
+        fields: ['name']
+      },
+      text: (project) => {
+        (project.name_with_namespace || project.name);
+      },
+      id: (project) => {
+        project.id;
+      }
     });
-    i += 1;
-    if (i <= steps) {
-      navigateWithKeys(direction, steps, cb, i);
-    } else {
-      cb();
-    }
-  };
-
-  const remoteMock = function remoteMock(data, term, callback) {
-    remoteCallback = callback.bind({}, data);
-  };
-
-  describe('Dropdown', function describeDropdown() {
-    preloadFixtures('static/gl_dropdown.html.raw');
-    loadJSONFixtures('projects.json');
-
-    function initDropDown(hasRemote, isFilterable) {
-      this.dropdownButtonElement = $('#js-project-dropdown', this.dropdownContainerElement).glDropdown({
-        selectable: true,
-        filterable: isFilterable,
-        data: hasRemote ? remoteMock.bind({}, this.projectsData) : this.projectsData,
-        search: {
-          fields: ['name']
-        },
-        text: (project) => {
-          (project.name_with_namespace || project.name);
-        },
-        id: (project) => {
-          project.id;
-        }
-      });
-    }
+  }
 
-    beforeEach(() => {
-      loadFixtures('static/gl_dropdown.html.raw');
-      this.dropdownContainerElement = $('.dropdown.inline');
-      this.$dropdownMenuElement = $('.dropdown-menu', this.dropdownContainerElement);
-      this.projectsData = getJSONFixture('projects.json');
-    });
+  beforeEach(() => {
+    loadFixtures('static/gl_dropdown.html.raw');
+    this.dropdownContainerElement = $('.dropdown.inline');
+    this.$dropdownMenuElement = $('.dropdown-menu', this.dropdownContainerElement);
+    this.projectsData = getJSONFixture('projects.json');
+  });
 
-    afterEach(() => {
-      $('body').unbind('keydown');
-      this.dropdownContainerElement.unbind('keyup');
-    });
+  afterEach(() => {
+    $('body').unbind('keydown');
+    this.dropdownContainerElement.unbind('keyup');
+  });
 
-    it('should open on click', () => {
-      initDropDown.call(this, false);
-      expect(this.dropdownContainerElement).not.toHaveClass('open');
+  it('should open on click', () => {
+    initDropDown.call(this, false);
+    expect(this.dropdownContainerElement).not.toHaveClass('open');
+    this.dropdownButtonElement.click();
+    expect(this.dropdownContainerElement).toHaveClass('open');
+  });
+
+  describe('that is open', () => {
+    beforeEach(() => {
+      initDropDown.call(this, false, false);
       this.dropdownButtonElement.click();
-      expect(this.dropdownContainerElement).toHaveClass('open');
     });
 
-    describe('that is open', () => {
-      beforeEach(() => {
-        initDropDown.call(this, false, false);
-        this.dropdownButtonElement.click();
-      });
-
-      it('should select a following item on DOWN keypress', () => {
-        expect($(FOCUSED_ITEM_SELECTOR, this.$dropdownMenuElement).length).toBe(0);
-        const randomIndex = (Math.floor(Math.random() * (this.projectsData.length - 1)) + 0);
-        navigateWithKeys('down', randomIndex, () => {
-          expect($(FOCUSED_ITEM_SELECTOR, this.$dropdownMenuElement).length).toBe(1);
-          expect($(`${ITEM_SELECTOR}:eq(${randomIndex}) a`, this.$dropdownMenuElement)).toHaveClass('is-focused');
-        });
+    it('should select a following item on DOWN keypress', () => {
+      expect($(FOCUSED_ITEM_SELECTOR, this.$dropdownMenuElement).length).toBe(0);
+      const randomIndex = (Math.floor(Math.random() * (this.projectsData.length - 1)) + 0);
+      navigateWithKeys('down', randomIndex, () => {
+        expect($(FOCUSED_ITEM_SELECTOR, this.$dropdownMenuElement).length).toBe(1);
+        expect($(`${ITEM_SELECTOR}:eq(${randomIndex}) a`, this.$dropdownMenuElement)).toHaveClass('is-focused');
       });
+    });
 
-      it('should select a previous item on UP keypress', () => {
-        expect($(FOCUSED_ITEM_SELECTOR, this.$dropdownMenuElement).length).toBe(0);
-        navigateWithKeys('down', (this.projectsData.length - 1), () => {
+    it('should select a previous item on UP keypress', () => {
+      expect($(FOCUSED_ITEM_SELECTOR, this.$dropdownMenuElement).length).toBe(0);
+      navigateWithKeys('down', (this.projectsData.length - 1), () => {
+        expect($(FOCUSED_ITEM_SELECTOR, this.$dropdownMenuElement).length).toBe(1);
+        const randomIndex = (Math.floor(Math.random() * (this.projectsData.length - 2)) + 0);
+        navigateWithKeys('up', randomIndex, () => {
           expect($(FOCUSED_ITEM_SELECTOR, this.$dropdownMenuElement).length).toBe(1);
-          const randomIndex = (Math.floor(Math.random() * (this.projectsData.length - 2)) + 0);
-          navigateWithKeys('up', randomIndex, () => {
-            expect($(FOCUSED_ITEM_SELECTOR, this.$dropdownMenuElement).length).toBe(1);
-            expect($(`${ITEM_SELECTOR}:eq(${((this.projectsData.length - 2) - randomIndex)}) a`, this.$dropdownMenuElement)).toHaveClass('is-focused');
-          });
-        });
-      });
-
-      it('should click the selected item on ENTER keypress', () => {
-        expect(this.dropdownContainerElement).toHaveClass('open');
-        const randomIndex = Math.floor(Math.random() * (this.projectsData.length - 1)) + 0;
-        navigateWithKeys('down', randomIndex, () => {
-          spyOn(gl.utils, 'visitUrl').and.stub();
-          navigateWithKeys('enter', null, () => {
-            expect(this.dropdownContainerElement).not.toHaveClass('open');
-            const link = $(`${ITEM_SELECTOR}:eq(${randomIndex}) a`, this.$dropdownMenuElement);
-            expect(link).toHaveClass('is-active');
-            const linkedLocation = link.attr('href');
-            if (linkedLocation && linkedLocation !== '#') expect(gl.utils.visitUrl).toHaveBeenCalledWith(linkedLocation);
-          });
+          expect($(`${ITEM_SELECTOR}:eq(${((this.projectsData.length - 2) - randomIndex)}) a`, this.$dropdownMenuElement)).toHaveClass('is-focused');
         });
       });
+    });
 
-      it('should close on ESC keypress', () => {
-        expect(this.dropdownContainerElement).toHaveClass('open');
-        this.dropdownContainerElement.trigger({
-          type: 'keyup',
-          which: ARROW_KEYS.ESC,
-          keyCode: ARROW_KEYS.ESC
+    it('should click the selected item on ENTER keypress', () => {
+      expect(this.dropdownContainerElement).toHaveClass('open');
+      const randomIndex = Math.floor(Math.random() * (this.projectsData.length - 1)) + 0;
+      navigateWithKeys('down', randomIndex, () => {
+        spyOn(gl.utils, 'visitUrl').and.stub();
+        navigateWithKeys('enter', null, () => {
+          expect(this.dropdownContainerElement).not.toHaveClass('open');
+          const link = $(`${ITEM_SELECTOR}:eq(${randomIndex}) a`, this.$dropdownMenuElement);
+          expect(link).toHaveClass('is-active');
+          const linkedLocation = link.attr('href');
+          if (linkedLocation && linkedLocation !== '#') expect(gl.utils.visitUrl).toHaveBeenCalledWith(linkedLocation);
         });
-        expect(this.dropdownContainerElement).not.toHaveClass('open');
       });
     });
 
-    describe('opened and waiting for a remote callback', () => {
-      beforeEach(() => {
-        initDropDown.call(this, true, true);
-        this.dropdownButtonElement.click();
+    it('should close on ESC keypress', () => {
+      expect(this.dropdownContainerElement).toHaveClass('open');
+      this.dropdownContainerElement.trigger({
+        type: 'keyup',
+        which: ARROW_KEYS.ESC,
+        keyCode: ARROW_KEYS.ESC
       });
+      expect(this.dropdownContainerElement).not.toHaveClass('open');
+    });
+  });
 
-      it('should show loading indicator while search results are being fetched by backend', () => {
-        const dropdownMenu = document.querySelector('.dropdown-menu');
+  describe('opened and waiting for a remote callback', () => {
+    beforeEach(() => {
+      initDropDown.call(this, true, true);
+      this.dropdownButtonElement.click();
+    });
 
-        expect(dropdownMenu.className.indexOf('is-loading') !== -1).toEqual(true);
-        remoteCallback();
-        expect(dropdownMenu.className.indexOf('is-loading') !== -1).toEqual(false);
-      });
+    it('should show loading indicator while search results are being fetched by backend', () => {
+      const dropdownMenu = document.querySelector('.dropdown-menu');
 
-      it('should not focus search input while remote task is not complete', () => {
-        expect($(document.activeElement)).not.toEqual($(SEARCH_INPUT_SELECTOR));
-        remoteCallback();
-        expect($(document.activeElement)).toEqual($(SEARCH_INPUT_SELECTOR));
-      });
+      expect(dropdownMenu.className.indexOf('is-loading') !== -1).toEqual(true);
+      remoteCallback();
+      expect(dropdownMenu.className.indexOf('is-loading') !== -1).toEqual(false);
+    });
 
-      it('should focus search input after remote task is complete', () => {
-        remoteCallback();
-        expect($(document.activeElement)).toEqual($(SEARCH_INPUT_SELECTOR));
-      });
+    it('should not focus search input while remote task is not complete', () => {
+      expect($(document.activeElement)).not.toEqual($(SEARCH_INPUT_SELECTOR));
+      remoteCallback();
+      expect($(document.activeElement)).toEqual($(SEARCH_INPUT_SELECTOR));
+    });
 
-      it('should focus on input when opening for the second time', () => {
-        remoteCallback();
-        this.dropdownContainerElement.trigger({
-          type: 'keyup',
-          which: ARROW_KEYS.ESC,
-          keyCode: ARROW_KEYS.ESC
-        });
-        this.dropdownButtonElement.click();
-        expect($(document.activeElement)).toEqual($(SEARCH_INPUT_SELECTOR));
-      });
+    it('should focus search input after remote task is complete', () => {
+      remoteCallback();
+      expect($(document.activeElement)).toEqual($(SEARCH_INPUT_SELECTOR));
     });
 
-    describe('input focus with array data', () => {
-      it('should focus input when passing array data to drop down', () => {
-        initDropDown.call(this, false, true);
-        this.dropdownButtonElement.click();
-        expect($(document.activeElement)).toEqual($(SEARCH_INPUT_SELECTOR));
+    it('should focus on input when opening for the second time', () => {
+      remoteCallback();
+      this.dropdownContainerElement.trigger({
+        type: 'keyup',
+        which: ARROW_KEYS.ESC,
+        keyCode: ARROW_KEYS.ESC
       });
+      this.dropdownButtonElement.click();
+      expect($(document.activeElement)).toEqual($(SEARCH_INPUT_SELECTOR));
     });
+  });
 
-    it('should still have input value on close and restore', () => {
-      const $searchInput = $(SEARCH_INPUT_SELECTOR);
+  describe('input focus with array data', () => {
+    it('should focus input when passing array data to drop down', () => {
       initDropDown.call(this, false, true);
-      $searchInput
-        .trigger('focus')
-        .val('g')
-        .trigger('input');
-      expect($searchInput.val()).toEqual('g');
-      this.dropdownButtonElement.trigger('hidden.bs.dropdown');
-      $searchInput
-        .trigger('blur')
-        .trigger('focus');
-      expect($searchInput.val()).toEqual('g');
+      this.dropdownButtonElement.click();
+      expect($(document.activeElement)).toEqual($(SEARCH_INPUT_SELECTOR));
     });
   });
-})();
+
+  it('should still have input value on close and restore', () => {
+    const $searchInput = $(SEARCH_INPUT_SELECTOR);
+    initDropDown.call(this, false, true);
+    $searchInput
+      .trigger('focus')
+      .val('g')
+      .trigger('input');
+    expect($searchInput.val()).toEqual('g');
+    this.dropdownButtonElement.trigger('hidden.bs.dropdown');
+    $searchInput
+      .trigger('blur')
+      .trigger('focus');
+    expect($searchInput.val()).toEqual('g');
+  });
+});
diff --git a/spec/javascripts/gl_field_errors_spec.js b/spec/javascripts/gl_field_errors_spec.js
index 733023481f5..099c1f56b28 100644
--- a/spec/javascripts/gl_field_errors_spec.js
+++ b/spec/javascripts/gl_field_errors_spec.js
@@ -2,109 +2,109 @@
 
 require('~/gl_field_errors');
 
-((global) => {
-  preloadFixtures('static/gl_field_errors.html.raw');
-
-  describe('GL Style Field Errors', function() {
-    beforeEach(function() {
-      loadFixtures('static/gl_field_errors.html.raw');
-      const $form = this.$form = $('form.gl-show-field-errors');
-      this.fieldErrors = new global.GlFieldErrors($form);
-    });
+const global = window.gl || (window.gl = {});
 
-    it('should select the correct input elements', function() {
-      expect(this.$form).toBeDefined();
-      expect(this.$form.length).toBe(1);
-      expect(this.fieldErrors).toBeDefined();
-      const inputs = this.fieldErrors.state.inputs;
-      expect(inputs.length).toBe(4);
-    });
+preloadFixtures('static/gl_field_errors.html.raw');
 
-    it('should ignore elements with custom error handling', function() {
-      const customErrorFlag = 'gl-field-error-ignore';
-      const customErrorElem = $(`.${customErrorFlag}`);
+describe('GL Style Field Errors', function() {
+  beforeEach(function() {
+    loadFixtures('static/gl_field_errors.html.raw');
+    const $form = this.$form = $('form.gl-show-field-errors');
+    this.fieldErrors = new global.GlFieldErrors($form);
+  });
 
-      expect(customErrorElem.length).toBe(1);
+  it('should select the correct input elements', function() {
+    expect(this.$form).toBeDefined();
+    expect(this.$form.length).toBe(1);
+    expect(this.fieldErrors).toBeDefined();
+    const inputs = this.fieldErrors.state.inputs;
+    expect(inputs.length).toBe(4);
+  });
 
-      const customErrors = this.fieldErrors.state.inputs.filter((input) => {
-        return input.inputElement.hasClass(customErrorFlag);
-      });
-      expect(customErrors.length).toBe(0);
-    });
+  it('should ignore elements with custom error handling', function() {
+    const customErrorFlag = 'gl-field-error-ignore';
+    const customErrorElem = $(`.${customErrorFlag}`);
 
-    it('should not show any errors before submit attempt', function() {
-      this.$form.find('.email').val('not-a-valid-email').keyup();
-      this.$form.find('.text-required').val('').keyup();
-      this.$form.find('.alphanumberic').val('?---*').keyup();
+    expect(customErrorElem.length).toBe(1);
 
-      const errorsShown = this.$form.find('.gl-field-error-outline');
-      expect(errorsShown.length).toBe(0);
+    const customErrors = this.fieldErrors.state.inputs.filter((input) => {
+      return input.inputElement.hasClass(customErrorFlag);
     });
+    expect(customErrors.length).toBe(0);
+  });
+
+  it('should not show any errors before submit attempt', function() {
+    this.$form.find('.email').val('not-a-valid-email').keyup();
+    this.$form.find('.text-required').val('').keyup();
+    this.$form.find('.alphanumberic').val('?---*').keyup();
 
-    it('should show errors when input valid is submitted', function() {
-      this.$form.find('.email').val('not-a-valid-email').keyup();
-      this.$form.find('.text-required').val('').keyup();
-      this.$form.find('.alphanumberic').val('?---*').keyup();
+    const errorsShown = this.$form.find('.gl-field-error-outline');
+    expect(errorsShown.length).toBe(0);
+  });
 
-      this.$form.submit();
+  it('should show errors when input valid is submitted', function() {
+    this.$form.find('.email').val('not-a-valid-email').keyup();
+    this.$form.find('.text-required').val('').keyup();
+    this.$form.find('.alphanumberic').val('?---*').keyup();
 
-      const errorsShown = this.$form.find('.gl-field-error-outline');
-      expect(errorsShown.length).toBe(4);
-    });
+    this.$form.submit();
 
-    it('should properly track validity state on input after invalid submission attempt', function() {
-      this.$form.submit();
-
-      const emailInputModel = this.fieldErrors.state.inputs[1];
-      const fieldState = emailInputModel.state;
-      const emailInputElement = emailInputModel.inputElement;
-
-      // No input
-      expect(emailInputElement).toHaveClass('gl-field-error-outline');
-      expect(fieldState.empty).toBe(true);
-      expect(fieldState.valid).toBe(false);
-
-      // Then invalid input
-      emailInputElement.val('not-a-valid-email').keyup();
-      expect(emailInputElement).toHaveClass('gl-field-error-outline');
-      expect(fieldState.empty).toBe(false);
-      expect(fieldState.valid).toBe(false);
-
-      // Then valid input
-      emailInputElement.val('email@gitlab.com').keyup();
-      expect(emailInputElement).not.toHaveClass('gl-field-error-outline');
-      expect(fieldState.empty).toBe(false);
-      expect(fieldState.valid).toBe(true);
-
-      // Then invalid input
-      emailInputElement.val('not-a-valid-email').keyup();
-      expect(emailInputElement).toHaveClass('gl-field-error-outline');
-      expect(fieldState.empty).toBe(false);
-      expect(fieldState.valid).toBe(false);
-
-      // Then empty input
-      emailInputElement.val('').keyup();
-      expect(emailInputElement).toHaveClass('gl-field-error-outline');
-      expect(fieldState.empty).toBe(true);
-      expect(fieldState.valid).toBe(false);
-
-      // Then valid input
-      emailInputElement.val('email@gitlab.com').keyup();
-      expect(emailInputElement).not.toHaveClass('gl-field-error-outline');
-      expect(fieldState.empty).toBe(false);
-      expect(fieldState.valid).toBe(true);
-    });
+    const errorsShown = this.$form.find('.gl-field-error-outline');
+    expect(errorsShown.length).toBe(4);
+  });
 
-    it('should properly infer error messages', function() {
-      this.$form.submit();
-      const trackedInputs = this.fieldErrors.state.inputs;
-      const inputHasTitle = trackedInputs[1];
-      const hasTitleErrorElem = inputHasTitle.inputElement.siblings('.gl-field-error');
-      const inputNoTitle = trackedInputs[2];
-      const noTitleErrorElem = inputNoTitle.inputElement.siblings('.gl-field-error');
+  it('should properly track validity state on input after invalid submission attempt', function() {
+    this.$form.submit();
+
+    const emailInputModel = this.fieldErrors.state.inputs[1];
+    const fieldState = emailInputModel.state;
+    const emailInputElement = emailInputModel.inputElement;
+
+    // No input
+    expect(emailInputElement).toHaveClass('gl-field-error-outline');
+    expect(fieldState.empty).toBe(true);
+    expect(fieldState.valid).toBe(false);
+
+    // Then invalid input
+    emailInputElement.val('not-a-valid-email').keyup();
+    expect(emailInputElement).toHaveClass('gl-field-error-outline');
+    expect(fieldState.empty).toBe(false);
+    expect(fieldState.valid).toBe(false);
+
+    // Then valid input
+    emailInputElement.val('email@gitlab.com').keyup();
+    expect(emailInputElement).not.toHaveClass('gl-field-error-outline');
+    expect(fieldState.empty).toBe(false);
+    expect(fieldState.valid).toBe(true);
+
+    // Then invalid input
+    emailInputElement.val('not-a-valid-email').keyup();
+    expect(emailInputElement).toHaveClass('gl-field-error-outline');
+    expect(fieldState.empty).toBe(false);
+    expect(fieldState.valid).toBe(false);
+
+    // Then empty input
+    emailInputElement.val('').keyup();
+    expect(emailInputElement).toHaveClass('gl-field-error-outline');
+    expect(fieldState.empty).toBe(true);
+    expect(fieldState.valid).toBe(false);
+
+    // Then valid input
+    emailInputElement.val('email@gitlab.com').keyup();
+    expect(emailInputElement).not.toHaveClass('gl-field-error-outline');
+    expect(fieldState.empty).toBe(false);
+    expect(fieldState.valid).toBe(true);
+  });
 
-      expect(noTitleErrorElem.text()).toBe('This field is required.');
-      expect(hasTitleErrorElem.text()).toBe('Please provide a valid email address.');
-    });
+  it('should properly infer error messages', function() {
+    this.$form.submit();
+    const trackedInputs = this.fieldErrors.state.inputs;
+    const inputHasTitle = trackedInputs[1];
+    const hasTitleErrorElem = inputHasTitle.inputElement.siblings('.gl-field-error');
+    const inputNoTitle = trackedInputs[2];
+    const noTitleErrorElem = inputNoTitle.inputElement.siblings('.gl-field-error');
+
+    expect(noTitleErrorElem.text()).toBe('This field is required.');
+    expect(hasTitleErrorElem.text()).toBe('Please provide a valid email address.');
   });
-})(window.gl || (window.gl = {}));
+});