autofix eslint errors under airbnb

src/js/bootstrap-switch.js

@@ -1,331 +1,330 @@
-import jquery from 'jquery'
+import jquery from 'jquery';
 
-const $ = jquery || window.jQuery || window.$
+const $ = jquery || window.jQuery || window.$;
 
 class BootstrapSwitch {
-  constructor (element, options = {}) {
-    this.$element = $(element)
+  constructor(element, options = {}) {
+    this.$element = $(element);
     this.options = $.extend(
       {},
       $.fn.bootstrapSwitch.defaults,
       this._getElementOptions(),
-      options
-    )
-    this.prevOptions = {}
+      options,
+    );
+    this.prevOptions = {};
     this.$wrapper = $('<div>', {
       class: () => {
-        const classes = []
-        classes.push(this.options.state ? 'on' : 'off')
+        const classes = [];
+        classes.push(this.options.state ? 'on' : 'off');
         if (this.options.size) {
-          classes.push(this.options.size)
+          classes.push(this.options.size);
         }
         if (this.options.disabled) {
-          classes.push('disabled')
+          classes.push('disabled');
         }
         if (this.options.readonly) {
-          classes.push('readonly')
+          classes.push('readonly');
         }
         if (this.options.indeterminate) {
-          classes.push('indeterminate')
+          classes.push('indeterminate');
         }
         if (this.options.inverse) {
-          classes.push('inverse')
+          classes.push('inverse');
         }
         if (this.$element.attr('id')) {
-          classes.push(`id-${this.$element.attr('id')}`)
+          classes.push(`id-${this.$element.attr('id')}`);
         }
         return classes
           .map(this._getClass.bind(this))
           .concat([this.options.baseClass], this._getClasses(this.options.wrapperClass))
-          .join(' ')
-      }
-    })
-    this.$container = $('<div>', { class: this._getClass('container') })
+          .join(' ');
+      },
+    });
+    this.$container = $('<div>', { class: this._getClass('container') });
     this.$on = $('<span>', {
       html: this.options.onText,
-      class: `${this._getClass('handle-on')} ${this._getClass(this.options.onColor)}`
-    })
+      class: `${this._getClass('handle-on')} ${this._getClass(this.options.onColor)}`,
+    });
     this.$off = $('<span>', {
       html: this.options.offText,
-      class: `${this._getClass('handle-off')} ${this._getClass(this.options.offColor)}`
-    })
+      class: `${this._getClass('handle-off')} ${this._getClass(this.options.offColor)}`,
+    });
     this.$label = $('<span>', {
       html: this.options.labelText,
-      class: this._getClass('label')
-    })
+      class: this._getClass('label'),
+    });
 
-    this.$element.on('init.bootstrapSwitch', this.options.onInit.bind(this, element))
+    this.$element.on('init.bootstrapSwitch', this.options.onInit.bind(this, element));
     this.$element.on('switchChange.bootstrapSwitch', (...args) => {
       if (this.options.onSwitchChange.apply(element, args) === false) {
         if (this.$element.is(':radio')) {
-          $(`[name="${this.$element.attr('name')}"]`).trigger('previousState.bootstrapSwitch', true)
+          $(`[name="${this.$element.attr('name')}"]`).trigger('previousState.bootstrapSwitch', true);
         } else {
-          this.$element.trigger('previousState.bootstrapSwitch', true)
+          this.$element.trigger('previousState.bootstrapSwitch', true);
         }
       }
-    })
+    });
 
-    this.$container = this.$element.wrap(this.$container).parent()
-    this.$wrapper = this.$container.wrap(this.$wrapper).parent()
+    this.$container = this.$element.wrap(this.$container).parent();
+    this.$wrapper = this.$container.wrap(this.$wrapper).parent();
     this.$element
       .before(this.options.inverse ? this.$off : this.$on)
       .before(this.$label)
-      .before(this.options.inverse ? this.$on : this.$off)
+      .before(this.options.inverse ? this.$on : this.$off);
 
     if (this.options.indeterminate) {
-      this.$element.prop('indeterminate', true)
+      this.$element.prop('indeterminate', true);
     }
 
-    this._init()
-    this._elementHandlers()
-    this._handleHandlers()
-    this._labelHandlers()
-    this._formHandler()
-    this._externalLabelHandler()
-    this.$element.trigger('init.bootstrapSwitch', this.options.state)
+    this._init();
+    this._elementHandlers();
+    this._handleHandlers();
+    this._labelHandlers();
+    this._formHandler();
+    this._externalLabelHandler();
+    this.$element.trigger('init.bootstrapSwitch', this.options.state);
   }
 
-  setPrevOptions () {
-    this.prevOptions = { ...this.options }
+  setPrevOptions() {
+    this.prevOptions = { ...this.options };
   }
 
-  state (value, skip) {
-    if (typeof value === 'undefined') { return this.options.state }
+  state(value, skip) {
+    if (typeof value === 'undefined') { return this.options.state; }
     if (
       (this.options.disabled || this.options.readonly) ||
       (this.options.state && !this.options.radioAllOff && this.$element.is(':radio'))
-    ) { return this.$element }
+    ) { return this.$element; }
     if (this.$element.is(':radio')) {
-      $(`[name="${this.$element.attr('name')}"]`).trigger('setPreviousOptions.bootstrapSwitch')
+      $(`[name="${this.$element.attr('name')}"]`).trigger('setPreviousOptions.bootstrapSwitch');
     } else {
-      this.$element.trigger('setPreviousOptions.bootstrapSwitch')
+      this.$element.trigger('setPreviousOptions.bootstrapSwitch');
     }
     if (this.options.indeterminate) {
-      this.indeterminate(false)
+      this.indeterminate(false);
     }
     this.$element
       .prop('checked', Boolean(value))
-      .trigger('change.bootstrapSwitch', skip)
-    return this.$element
+      .trigger('change.bootstrapSwitch', skip);
+    return this.$element;
   }
 
-  toggleState (skip) {
-    if (this.options.disabled || this.options.readonly) { return this.$element }
+  toggleState(skip) {
+    if (this.options.disabled || this.options.readonly) { return this.$element; }
     if (this.options.indeterminate) {
-      this.indeterminate(false)
-      return this.state(true)
-    } else {
-      return this.$element.prop('checked', !this.options.state).trigger('change.bootstrapSwitch', skip)
+      this.indeterminate(false);
+      return this.state(true);
     }
+    return this.$element.prop('checked', !this.options.state).trigger('change.bootstrapSwitch', skip);
   }
 
-  size (value) {
-    if (typeof value === 'undefined') { return this.options.size }
+  size(value) {
+    if (typeof value === 'undefined') { return this.options.size; }
     if (this.options.size != null) {
-      this.$wrapper.removeClass(this._getClass(this.options.size))
+      this.$wrapper.removeClass(this._getClass(this.options.size));
     }
     if (value) {
-      this.$wrapper.addClass(this._getClass(value))
+      this.$wrapper.addClass(this._getClass(value));
     }
-    this._width()
-    this._containerPosition()
-    this.options.size = value
-    return this.$element
+    this._width();
+    this._containerPosition();
+    this.options.size = value;
+    return this.$element;
   }
 
-  animate (value) {
-    if (typeof value === 'undefined') { return this.options.animate }
-    if (this.options.animate === Boolean(value)) { return this.$element }
-    return this.toggleAnimate()
+  animate(value) {
+    if (typeof value === 'undefined') { return this.options.animate; }
+    if (this.options.animate === Boolean(value)) { return this.$element; }
+    return this.toggleAnimate();
   }
 
-  toggleAnimate () {
-    this.options.animate = !this.options.animate
-    this.$wrapper.toggleClass(this._getClass('animate'))
-    return this.$element
+  toggleAnimate() {
+    this.options.animate = !this.options.animate;
+    this.$wrapper.toggleClass(this._getClass('animate'));
+    return this.$element;
   }
 
-  disabled (value) {
-    if (typeof value === 'undefined') { return this.options.disabled }
-    if (this.options.disabled === Boolean(value)) { return this.$element }
-    return this.toggleDisabled()
+  disabled(value) {
+    if (typeof value === 'undefined') { return this.options.disabled; }
+    if (this.options.disabled === Boolean(value)) { return this.$element; }
+    return this.toggleDisabled();
   }
 
-  toggleDisabled () {
-    this.options.disabled = !this.options.disabled
-    this.$element.prop('disabled', this.options.disabled)
-    this.$wrapper.toggleClass(this._getClass('disabled'))
-    return this.$element
+  toggleDisabled() {
+    this.options.disabled = !this.options.disabled;
+    this.$element.prop('disabled', this.options.disabled);
+    this.$wrapper.toggleClass(this._getClass('disabled'));
+    return this.$element;
   }
 
-  readonly (value) {
-    if (typeof value === 'undefined') { return this.options.readonly }
-    if (this.options.readonly === Boolean(value)) { return this.$element }
-    return this.toggleReadonly()
+  readonly(value) {
+    if (typeof value === 'undefined') { return this.options.readonly; }
+    if (this.options.readonly === Boolean(value)) { return this.$element; }
+    return this.toggleReadonly();
   }
 
-  toggleReadonly () {
-    this.options.readonly = !this.options.readonly
-    this.$element.prop('readonly', this.options.readonly)
-    this.$wrapper.toggleClass(this._getClass('readonly'))
-    return this.$element
+  toggleReadonly() {
+    this.options.readonly = !this.options.readonly;
+    this.$element.prop('readonly', this.options.readonly);
+    this.$wrapper.toggleClass(this._getClass('readonly'));
+    return this.$element;
   }
 
-  indeterminate (value) {
-    if (typeof value === 'undefined') { return this.options.indeterminate }
-    if (this.options.indeterminate === Boolean(value)) { return this.$element }
-    return this.toggleIndeterminate()
+  indeterminate(value) {
+    if (typeof value === 'undefined') { return this.options.indeterminate; }
+    if (this.options.indeterminate === Boolean(value)) { return this.$element; }
+    return this.toggleIndeterminate();
   }
 
-  toggleIndeterminate () {
-    this.options.indeterminate = !this.options.indeterminate
-    this.$element.prop('indeterminate', this.options.indeterminate)
-    this.$wrapper.toggleClass(this._getClass('indeterminate'))
-    this._containerPosition()
-    return this.$element
+  toggleIndeterminate() {
+    this.options.indeterminate = !this.options.indeterminate;
+    this.$element.prop('indeterminate', this.options.indeterminate);
+    this.$wrapper.toggleClass(this._getClass('indeterminate'));
+    this._containerPosition();
+    return this.$element;
   }
 
-  inverse (value) {
-    if (typeof value === 'undefined') { return this.options.inverse }
-    if (this.options.inverse === Boolean(value)) { return this.$element }
-    return this.toggleInverse()
+  inverse(value) {
+    if (typeof value === 'undefined') { return this.options.inverse; }
+    if (this.options.inverse === Boolean(value)) { return this.$element; }
+    return this.toggleInverse();
   }
 
-  toggleInverse () {
-    this.$wrapper.toggleClass(this._getClass('inverse'))
-    const $on = this.$on.clone(true)
-    const $off = this.$off.clone(true)
-    this.$on.replaceWith($off)
-    this.$off.replaceWith($on)
-    this.$on = $off
-    this.$off = $on
-    this.options.inverse = !this.options.inverse
-    return this.$element
+  toggleInverse() {
+    this.$wrapper.toggleClass(this._getClass('inverse'));
+    const $on = this.$on.clone(true);
+    const $off = this.$off.clone(true);
+    this.$on.replaceWith($off);
+    this.$off.replaceWith($on);
+    this.$on = $off;
+    this.$off = $on;
+    this.options.inverse = !this.options.inverse;
+    return this.$element;
   }
 
-  onColor (value) {
-    if (typeof value === 'undefined') { return this.options.onColor }
+  onColor(value) {
+    if (typeof value === 'undefined') { return this.options.onColor; }
     if (this.options.onColor) {
-      this.$on.removeClass(this._getClass(this.options.onColor))
+      this.$on.removeClass(this._getClass(this.options.onColor));
     }
-    this.$on.addClass(this._getClass(value))
-    this.options.onColor = value
-    return this.$element
+    this.$on.addClass(this._getClass(value));
+    this.options.onColor = value;
+    return this.$element;
   }
 
-  offColor (value) {
-    if (typeof value === 'undefined') { return this.options.offColor }
+  offColor(value) {
+    if (typeof value === 'undefined') { return this.options.offColor; }
     if (this.options.offColor) {
-      this.$off.removeClass(this._getClass(this.options.offColor))
+      this.$off.removeClass(this._getClass(this.options.offColor));
     }
-    this.$off.addClass(this._getClass(value))
-    this.options.offColor = value
-    return this.$element
+    this.$off.addClass(this._getClass(value));
+    this.options.offColor = value;
+    return this.$element;
   }
 
-  onText (value) {
-    if (typeof value === 'undefined') { return this.options.onText }
-    this.$on.html(value)
-    this._width()
-    this._containerPosition()
-    this.options.onText = value
-    return this.$element
+  onText(value) {
+    if (typeof value === 'undefined') { return this.options.onText; }
+    this.$on.html(value);
+    this._width();
+    this._containerPosition();
+    this.options.onText = value;
+    return this.$element;
   }
 
-  offText (value) {
-    if (typeof value === 'undefined') { return this.options.offText }
-    this.$off.html(value)
-    this._width()
-    this._containerPosition()
-    this.options.offText = value
-    return this.$element
+  offText(value) {
+    if (typeof value === 'undefined') { return this.options.offText; }
+    this.$off.html(value);
+    this._width();
+    this._containerPosition();
+    this.options.offText = value;
+    return this.$element;
   }
 
-  labelText (value) {
-    if (typeof value === 'undefined') { return this.options.labelText }
-    this.$label.html(value)
-    this._width()
-    this.options.labelText = value
-    return this.$element
+  labelText(value) {
+    if (typeof value === 'undefined') { return this.options.labelText; }
+    this.$label.html(value);
+    this._width();
+    this.options.labelText = value;
+    return this.$element;
   }
 
-  handleWidth (value) {
-    if (typeof value === 'undefined') { return this.options.handleWidth }
-    this.options.handleWidth = value
-    this._width()
-    this._containerPosition()
-    return this.$element
+  handleWidth(value) {
+    if (typeof value === 'undefined') { return this.options.handleWidth; }
+    this.options.handleWidth = value;
+    this._width();
+    this._containerPosition();
+    return this.$element;
   }
 
-  labelWidth (value) {
-    if (typeof value === 'undefined') { return this.options.labelWidth }
-    this.options.labelWidth = value
-    this._width()
-    this._containerPosition()
-    return this.$element
+  labelWidth(value) {
+    if (typeof value === 'undefined') { return this.options.labelWidth; }
+    this.options.labelWidth = value;
+    this._width();
+    this._containerPosition();
+    return this.$element;
   }
 
-  baseClass (value) {
-    return this.options.baseClass
+  baseClass(value) {
+    return this.options.baseClass;
   }
 
-  wrapperClass (value) {
-    if (typeof value === 'undefined') { return this.options.wrapperClass }
+  wrapperClass(value) {
+    if (typeof value === 'undefined') { return this.options.wrapperClass; }
     if (!value) {
-      value = $.fn.bootstrapSwitch.defaults.wrapperClass
+      value = $.fn.bootstrapSwitch.defaults.wrapperClass;
     }
-    this.$wrapper.removeClass(this._getClasses(this.options.wrapperClass).join(' '))
-    this.$wrapper.addClass(this._getClasses(value).join(' '))
-    this.options.wrapperClass = value
-    return this.$element
+    this.$wrapper.removeClass(this._getClasses(this.options.wrapperClass).join(' '));
+    this.$wrapper.addClass(this._getClasses(value).join(' '));
+    this.options.wrapperClass = value;
+    return this.$element;
   }
 
-  radioAllOff (value) {
-    if (typeof value === 'undefined') { return this.options.radioAllOff }
-    const val = Boolean(value)
-    if (this.options.radioAllOff === val) { return this.$element }
-    this.options.radioAllOff = val
-    return this.$element
+  radioAllOff(value) {
+    if (typeof value === 'undefined') { return this.options.radioAllOff; }
+    const val = Boolean(value);
+    if (this.options.radioAllOff === val) { return this.$element; }
+    this.options.radioAllOff = val;
+    return this.$element;
   }
 
-  onInit (value) {
-    if (typeof value === 'undefined') { return this.options.onInit }
+  onInit(value) {
+    if (typeof value === 'undefined') { return this.options.onInit; }
     if (!value) {
-      value = $.fn.bootstrapSwitch.defaults.onInit
+      value = $.fn.bootstrapSwitch.defaults.onInit;
     }
-    this.options.onInit = value
-    return this.$element
+    this.options.onInit = value;
+    return this.$element;
   }
 
-  onSwitchChange (value) {
+  onSwitchChange(value) {
     if (typeof value === 'undefined') {
-      return this.options.onSwitchChange
+      return this.options.onSwitchChange;
     }
     if (!value) {
-      value = $.fn.bootstrapSwitch.defaults.onSwitchChange
+      value = $.fn.bootstrapSwitch.defaults.onSwitchChange;
     }
-    this.options.onSwitchChange = value
-    return this.$element
+    this.options.onSwitchChange = value;
+    return this.$element;
   }
 
-  destroy () {
-    const $form = this.$element.closest('form')
+  destroy() {
+    const $form = this.$element.closest('form');
     if ($form.length) {
-      $form.off('reset.bootstrapSwitch').removeData('bootstrap-switch')
+      $form.off('reset.bootstrapSwitch').removeData('bootstrap-switch');
     }
     this.$container
       .children()
       .not(this.$element)
-      .remove()
+      .remove();
     this.$element
       .unwrap()
       .unwrap()
       .off('.bootstrapSwitch')
-      .removeData('bootstrap-switch')
-    return this.$element
+      .removeData('bootstrap-switch');
+    return this.$element;
   }
 
-  _getElementOptions () {
+  _getElementOptions() {
     return {
       state: this.$element.is(':checked'),
       size: this.$element.data('size'),
@@ -343,254 +342,251 @@ class BootstrapSwitch {
       handleWidth: this.$element.data('handle-width'),
       labelWidth: this.$element.data('label-width'),
       baseClass: this.$element.data('base-class'),
-      wrapperClass: this.$element.data('wrapper-class')
-    }
+      wrapperClass: this.$element.data('wrapper-class'),
+    };
   }
 
-  _width () {
+  _width() {
     const $handles = this.$on
       .add(this.$off)
       .add(this.$label)
-      .css('width', '')
+      .css('width', '');
     const handleWidth = this.options.handleWidth === 'auto'
       ? Math.round(Math.max(this.$on.width(), this.$off.width()))
-      : this.options.handleWidth
-    $handles.width(handleWidth)
+      : this.options.handleWidth;
+    $handles.width(handleWidth);
     this.$label.width((index, width) => {
-      if (this.options.labelWidth !== 'auto') { return this.options.labelWidth }
-      if (width < handleWidth) { return handleWidth }
-      return width
-    })
-    this._handleWidth = this.$on.outerWidth()
-    this._labelWidth = this.$label.outerWidth()
-    this.$container.width((this._handleWidth * 2) + this._labelWidth)
-    return this.$wrapper.width(this._handleWidth + this._labelWidth)
+      if (this.options.labelWidth !== 'auto') { return this.options.labelWidth; }
+      if (width < handleWidth) { return handleWidth; }
+      return width;
+    });
+    this._handleWidth = this.$on.outerWidth();
+    this._labelWidth = this.$label.outerWidth();
+    this.$container.width((this._handleWidth * 2) + this._labelWidth);
+    return this.$wrapper.width(this._handleWidth + this._labelWidth);
   }
 
-  _containerPosition (state = this.options.state, callback) {
+  _containerPosition(state = this.options.state, callback) {
     this.$container.css('margin-left', () => {
-      const values = [0, `-${this._handleWidth}px`]
+      const values = [0, `-${this._handleWidth}px`];
       if (this.options.indeterminate) {
-        return `-${this._handleWidth / 2}px`
+        return `-${this._handleWidth / 2}px`;
       }
       if (state) {
         if (this.options.inverse) {
-          return values[1]
-        } else {
-          return values[0]
-        }
-      } else {
-        if (this.options.inverse) {
-          return values[0]
-        } else {
-          return values[1]
+          return values[1];
         }
+        return values[0];
+      }
+      if (this.options.inverse) {
+        return values[0];
       }
-    })
+      return values[1];
+    });
   }
 
-  _init () {
+  _init() {
     const init = () => {
-      this.setPrevOptions()
-      this._width()
-      this._containerPosition()
+      this.setPrevOptions();
+      this._width();
+      this._containerPosition();
       setTimeout(() => {
         if (this.options.animate) {
-          return this.$wrapper.addClass(this._getClass('animate'))
+          return this.$wrapper.addClass(this._getClass('animate'));
         }
-      }, 50)
-    }
+      }, 50);
+    };
     if (this.$wrapper.is(':visible')) {
-      init()
-      return
+      init();
+      return;
     }
     const initInterval = window.setInterval(() => {
       if (this.$wrapper.is(':visible')) {
-        init()
-        return window.clearInterval(initInterval)
+        init();
+        return window.clearInterval(initInterval);
       }
-    }, 50)
+    }, 50);
   }
 
-  _elementHandlers () {
+  _elementHandlers() {
     return this.$element.on({
       'setPreviousOptions.bootstrapSwitch': this.setPrevOptions.bind(this),
 
       'previousState.bootstrapSwitch': () => {
-        this.options = this.prevOptions
+        this.options = this.prevOptions;
         if (this.options.indeterminate) {
-          this.$wrapper.addClass(this._getClass('indeterminate'))
+          this.$wrapper.addClass(this._getClass('indeterminate'));
         }
         this.$element
           .prop('checked', this.options.state)
-          .trigger('change.bootstrapSwitch', true)
+          .trigger('change.bootstrapSwitch', true);
       },
 
       'change.bootstrapSwitch': (event, skip) => {
-        event.preventDefault()
-        event.stopImmediatePropagation()
-        const state = this.$element.is(':checked')
-        this._containerPosition(state)
+        event.preventDefault();
+        event.stopImmediatePropagation();
+        const state = this.$element.is(':checked');
+        this._containerPosition(state);
         if (state === this.options.state) {
-          return
+          return;
         }
-        this.options.state = state
+        this.options.state = state;
         this.$wrapper
           .toggleClass(this._getClass('off'))
-          .toggleClass(this._getClass('on'))
+          .toggleClass(this._getClass('on'));
         if (!skip) {
           if (this.$element.is(':radio')) {
             $(`[name="${this.$element.attr('name')}"]`)
               .not(this.$element)
               .prop('checked', false)
-              .trigger('change.bootstrapSwitch', true)
+              .trigger('change.bootstrapSwitch', true);
           }
-          this.$element.trigger('switchChange.bootstrapSwitch', [state])
+          this.$element.trigger('switchChange.bootstrapSwitch', [state]);
         }
       },
 
-      'focus.bootstrapSwitch': event => {
-        event.preventDefault()
-        this.$wrapper.addClass(this._getClass('focused'))
+      'focus.bootstrapSwitch': (event) => {
+        event.preventDefault();
+        this.$wrapper.addClass(this._getClass('focused'));
       },
 
-      'blur.bootstrapSwitch': event => {
-        event.preventDefault()
-        this.$wrapper.removeClass(this._getClass('focused'))
+      'blur.bootstrapSwitch': (event) => {
+        event.preventDefault();
+        this.$wrapper.removeClass(this._getClass('focused'));
       },
 
-      'keydown.bootstrapSwitch': event => {
+      'keydown.bootstrapSwitch': (event) => {
         if (!event.which || this.options.disabled || this.options.readonly) {
-          return
+          return;
         }
         if (event.which === 37 || event.which === 39) {
-          event.preventDefault()
-          event.stopImmediatePropagation()
-          this.state(event.which === 39)
+          event.preventDefault();
+          event.stopImmediatePropagation();
+          this.state(event.which === 39);
         }
-      }
-    })
+      },
+    });
   }
 
-  _handleHandlers () {
-    this.$on.on('click.bootstrapSwitch', event => {
-      event.preventDefault()
-      event.stopPropagation()
-      this.state(false)
-      return this.$element.trigger('focus.bootstrapSwitch')
-    })
-    return this.$off.on('click.bootstrapSwitch', event => {
-      event.preventDefault()
-      event.stopPropagation()
-      this.state(true)
-      return this.$element.trigger('focus.bootstrapSwitch')
-    })
+  _handleHandlers() {
+    this.$on.on('click.bootstrapSwitch', (event) => {
+      event.preventDefault();
+      event.stopPropagation();
+      this.state(false);
+      return this.$element.trigger('focus.bootstrapSwitch');
+    });
+    return this.$off.on('click.bootstrapSwitch', (event) => {
+      event.preventDefault();
+      event.stopPropagation();
+      this.state(true);
+      return this.$element.trigger('focus.bootstrapSwitch');
+    });
   }
 
-  _labelHandlers () {
+  _labelHandlers() {
     const handlers = {
-      click (event) { event.stopPropagation() },
+      click(event) { event.stopPropagation(); },
 
-      'mousedown.bootstrapSwitch touchstart.bootstrapSwitch': event => {
+      'mousedown.bootstrapSwitch touchstart.bootstrapSwitch': (event) => {
         if (this._dragStart || this.options.disabled || this.options.readonly) {
-          return
+          return;
         }
-        event.preventDefault()
-        event.stopPropagation()
-        this._dragStart = (event.pageX || event.originalEvent.touches[0].pageX) - parseInt(this.$container.css('margin-left'), 10)
+        event.preventDefault();
+        event.stopPropagation();
+        this._dragStart = (event.pageX || event.originalEvent.touches[0].pageX) - parseInt(this.$container.css('margin-left'), 10);
         if (this.options.animate) {
-          this.$wrapper.removeClass(this._getClass('animate'))
+          this.$wrapper.removeClass(this._getClass('animate'));
         }
-        this.$element.trigger('focus.bootstrapSwitch')
+        this.$element.trigger('focus.bootstrapSwitch');
       },
 
-      'mousemove.bootstrapSwitch touchmove.bootstrapSwitch': event => {
-        if (this._dragStart == null) { return }
-        const difference = (event.pageX || event.originalEvent.touches[0].pageX) - this._dragStart
-        event.preventDefault()
-        if (difference < -this._handleWidth || difference > 0) { return }
-        this._dragEnd = difference
-        this.$container.css('margin-left', `${this._dragEnd}px`)
+      'mousemove.bootstrapSwitch touchmove.bootstrapSwitch': (event) => {
+        if (this._dragStart == null) { return; }
+        const difference = (event.pageX || event.originalEvent.touches[0].pageX) - this._dragStart;
+        event.preventDefault();
+        if (difference < -this._handleWidth || difference > 0) { return; }
+        this._dragEnd = difference;
+        this.$container.css('margin-left', `${this._dragEnd}px`);
       },
 
-      'mouseup.bootstrapSwitch touchend.bootstrapSwitch': event => {
-        if (!this._dragStart) { return }
-        event.preventDefault()
+      'mouseup.bootstrapSwitch touchend.bootstrapSwitch': (event) => {
+        if (!this._dragStart) { return; }
+        event.preventDefault();
         if (this.options.animate) {
-          this.$wrapper.addClass(this._getClass('animate'))
+          this.$wrapper.addClass(this._getClass('animate'));
         }
         if (this._dragEnd) {
-          const state = this._dragEnd > -(this._handleWidth / 2)
-          this._dragEnd = false
-          this.state(this.options.inverse ? !state : state)
+          const state = this._dragEnd > -(this._handleWidth / 2);
+          this._dragEnd = false;
+          this.state(this.options.inverse ? !state : state);
         } else {
-          this.state(!this.options.state)
+          this.state(!this.options.state);
         }
-        this._dragStart = false
+        this._dragStart = false;
       },
 
       'mouseleave.bootstrapSwitch': () => {
-        this.$label.trigger('mouseup.bootstrapSwitch')
-      }
-    }
-    this.$label.on(handlers)
+        this.$label.trigger('mouseup.bootstrapSwitch');
+      },
+    };
+    this.$label.on(handlers);
   }
 
-  _externalLabelHandler () {
-    const $externalLabel = this.$element.closest('label')
-    $externalLabel.on('click', event => {
-      event.preventDefault()
-      event.stopImmediatePropagation()
+  _externalLabelHandler() {
+    const $externalLabel = this.$element.closest('label');
+    $externalLabel.on('click', (event) => {
+      event.preventDefault();
+      event.stopImmediatePropagation();
       if (event.target === $externalLabel[0]) {
-        this.toggleState()
+        this.toggleState();
       }
-    })
+    });
   }
 
-  _formHandler () {
-    const $form = this.$element.closest('form')
+  _formHandler() {
+    const $form = this.$element.closest('form');
     if ($form.data('bootstrap-switch')) {
-      return
+      return;
     }
     $form
       .on('reset.bootstrapSwitch', () => {
         window.setTimeout(() => {
           $form.find('input')
-            .filter(function () { return $(this).data('bootstrap-switch') })
-            .each(function () { return $(this).bootstrapSwitch('state', this.checked) })
-        }, 1)
+            .filter(function () { return $(this).data('bootstrap-switch'); })
+            .each(function () { return $(this).bootstrapSwitch('state', this.checked); });
+        }, 1);
       })
-      .data('bootstrap-switch', true)
+      .data('bootstrap-switch', true);
   }
 
-  _getClass (name) {
-    return `${this.options.baseClass}-${name}`
+  _getClass(name) {
+    return `${this.options.baseClass}-${name}`;
   }
 
-  _getClasses (classes) {
+  _getClasses(classes) {
     if (!$.isArray(classes)) {
-      return [this._getClass(classes)]
+      return [this._getClass(classes)];
     }
-    return classes.map(this._getClass.bind(this))
+    return classes.map(this._getClass.bind(this));
   }
 }
 
 $.fn.bootstrapSwitch = function (option, ...args) {
-  function reducer (ret, next) {
-    const $this = $(next)
-    const existingData = $this.data('bootstrap-switch')
-    const data = existingData || new BootstrapSwitch(next, option)
+  function reducer(ret, next) {
+    const $this = $(next);
+    const existingData = $this.data('bootstrap-switch');
+    const data = existingData || new BootstrapSwitch(next, option);
     if (!existingData) {
-      $this.data('bootstrap-switch', data)
+      $this.data('bootstrap-switch', data);
     }
     if (typeof option === 'string') {
-      return data[option].apply(data, args)
+      return data[option](...args);
     }
-    return ret
+    return ret;
   }
-  return Array.prototype.reduce.call(this, reducer, this)
-}
-$.fn.bootstrapSwitch.Constructor = BootstrapSwitch
+  return Array.prototype.reduce.call(this, reducer, this);
+};
+$.fn.bootstrapSwitch.Constructor = BootstrapSwitch;
 $.fn.bootstrapSwitch.defaults = {
   state: true,
   size: null,
@@ -610,5 +606,5 @@ $.fn.bootstrapSwitch.defaults = {
   baseClass: 'bootstrap-switch',
   wrapperClass: 'wrapper',
   onInit: () => {},
-  onSwitchChange: () => {}
-}
+  onSwitchChange: () => {},
+};

src/js/bootstrap-switch.test.js

@@ -1,117 +1,117 @@
-const { $, describe, beforeEach, afterEach, it, expect } = window
+const { $, describe, beforeEach, afterEach, it, expect } = window;
 
-describe('Bootstrap Switch:', function () {
-  beforeEach(function () {
-    $.support.transition = false
-    $.fx.off = true
-  })
-  afterEach(function () {
-    $(`.${$.fn.bootstrapSwitch.defaults.baseClass}`).bootstrapSwitch('destroy')
-  })
+describe('Bootstrap Switch:', () => {
+  beforeEach(() => {
+    $.support.transition = false;
+    $.fx.off = true;
+  });
+  afterEach(() => {
+    $(`.${$.fn.bootstrapSwitch.defaults.baseClass}`).bootstrapSwitch('destroy');
+  });
 
-  function createCheckbox () {
+  function createCheckbox() {
     return $('<input>', {
       type: 'checkbox',
-      class: 'switch'
-    }).appendTo('body')
+      class: 'switch',
+    }).appendTo('body');
   }
 
-  function createRadio () {
+  function createRadio() {
     return $('<input>', {
       type: 'radio',
       name: 'name',
-      class: 'switch'
-    }).appendTo('body')
+      class: 'switch',
+    }).appendTo('body');
   }
 
-  function getOptions ($element) {
-    return $element.data('bootstrap-switch').options
+  function getOptions($element) {
+    return $element.data('bootstrap-switch').options;
   }
 
-  it('should set the default options as element options, except state', function () {
-    const $switch = createCheckbox().prop('checked', true).bootstrapSwitch()
-    expect(getOptions($switch)).toEqual($.fn.bootstrapSwitch.defaults)
-  })
+  it('should set the default options as element options, except state', () => {
+    const $switch = createCheckbox().prop('checked', true).bootstrapSwitch();
+    expect(getOptions($switch)).toEqual($.fn.bootstrapSwitch.defaults);
+  });
 
-  it('should override default options with initialization ones', function () {
-    const $switch = createCheckbox().prop('checked', false).bootstrapSwitch()
-    const $switch2 = createCheckbox().bootstrapSwitch({ state: false })
-    expect(getOptions($switch).state).toBe(false)
-    expect(getOptions($switch2).state).toBe(false)
-  })
+  it('should override default options with initialization ones', () => {
+    const $switch = createCheckbox().prop('checked', false).bootstrapSwitch();
+    const $switch2 = createCheckbox().bootstrapSwitch({ state: false });
+    expect(getOptions($switch).state).toBe(false);
+    expect(getOptions($switch2).state).toBe(false);
+  });
 
-  it('should something', function () {
-    const $switch = createCheckbox().bootstrapSwitch()
-    let eventDoc = 0
-    let eventElement = 0
-    $(document).on('switchChange.bootstrapSwitch', ':checkbox', function (event, state) { eventDoc++ })
-    $(':checkbox').on('switchChange.bootstrapSwitch', function (event, state) { eventElement++ })
-    $switch.click()
-    expect(eventElement).toEqual(eventDoc)
-    expect(eventElement).toEqual(1)
-  })
+  it('should something', () => {
+    const $switch = createCheckbox().bootstrapSwitch();
+    let eventDoc = 0;
+    let eventElement = 0;
+    $(document).on('switchChange.bootstrapSwitch', ':checkbox', (event, state) => { eventDoc++; });
+    $(':checkbox').on('switchChange.bootstrapSwitch', (event, state) => { eventElement++; });
+    $switch.click();
+    expect(eventElement).toEqual(eventDoc);
+    expect(eventElement).toEqual(1);
+  });
 
-  describe('The Checkbox Bootstrap Switch', function () {
-    it('should conserve its state if onSwitchChange returns false', function () {
+  describe('The Checkbox Bootstrap Switch', () => {
+    it('should conserve its state if onSwitchChange returns false', () => {
       const $switch = createCheckbox().bootstrapSwitch({
-        onSwitchChange: function (event, state) {
-          expect(state).toEqual(true)
-          return false
-        }
-      })
+        onSwitchChange(event, state) {
+          expect(state).toEqual(true);
+          return false;
+        },
+      });
       const $indeterminateSwitch = createCheckbox().data('indeterminate', true).bootstrapSwitch({
-        onSwitchChange: function (event, state) {
-          expect(state).toEqual(true)
-          return false
-        }
-      })
-      $switch.click()
-      $indeterminateSwitch.click()
-      expect($switch.bootstrapSwitch('state')).toEqual(false)
-      expect($indeterminateSwitch.bootstrapSwitch('state')).toEqual(false)
-    })
+        onSwitchChange(event, state) {
+          expect(state).toEqual(true);
+          return false;
+        },
+      });
+      $switch.click();
+      $indeterminateSwitch.click();
+      expect($switch.bootstrapSwitch('state')).toEqual(false);
+      expect($indeterminateSwitch.bootstrapSwitch('state')).toEqual(false);
+    });
 
-    it('should change its state if onSwitchChange does not return false', function () {
+    it('should change its state if onSwitchChange does not return false', () => {
       const $switch = createCheckbox().bootstrapSwitch({
-        onSwitchChange: function (event, state) {
-          expect(state).toEqual(true)
-        }
-      })
-      $switch.click()
-      expect($switch.bootstrapSwitch('state')).toEqual(true)
-    })
-  })
+        onSwitchChange(event, state) {
+          expect(state).toEqual(true);
+        },
+      });
+      $switch.click();
+      expect($switch.bootstrapSwitch('state')).toEqual(true);
+    });
+  });
 
-  describe('The Radio Bootstrap Switch', function () {
-    it('should conserve its state if onSwitchChange returns false', function () {
-      const $radio1 = createRadio().prop('checked', true)
-      const $radio2 = createRadio().prop('checked', false)
-      const $radio3 = createRadio().prop('checked', false)
+  describe('The Radio Bootstrap Switch', () => {
+    it('should conserve its state if onSwitchChange returns false', () => {
+      const $radio1 = createRadio().prop('checked', true);
+      const $radio2 = createRadio().prop('checked', false);
+      const $radio3 = createRadio().prop('checked', false);
       $('[name="name"]').bootstrapSwitch({
-        onSwitchChange: function (e, s) {
-          expect(s).toEqual(true)
-          return false
-        }
-      })
-      $radio2.click()
-      expect($radio1.bootstrapSwitch('state')).toEqual(true)
-      expect($radio2.bootstrapSwitch('state')).toEqual(false)
-      expect($radio3.bootstrapSwitch('state')).toEqual(false)
-    })
+        onSwitchChange(e, s) {
+          expect(s).toEqual(true);
+          return false;
+        },
+      });
+      $radio2.click();
+      expect($radio1.bootstrapSwitch('state')).toEqual(true);
+      expect($radio2.bootstrapSwitch('state')).toEqual(false);
+      expect($radio3.bootstrapSwitch('state')).toEqual(false);
+    });
 
-    it('should change its state if onSwitchChange not returns false', function () {
-      const $radio1 = createRadio().prop('checked', true)
-      const $radio2 = createRadio().prop('checked', false)
-      const $radio3 = createRadio().prop('checked', false)
+    it('should change its state if onSwitchChange not returns false', () => {
+      const $radio1 = createRadio().prop('checked', true);
+      const $radio2 = createRadio().prop('checked', false);
+      const $radio3 = createRadio().prop('checked', false);
       $('[name="name"]').bootstrapSwitch({
-        onSwitchChange: function (e, s) {
-          expect(s).toEqual(true)
-        }
-      })
-      $radio2.click()
-      expect($radio1.bootstrapSwitch('state')).toEqual(false)
-      expect($radio2.bootstrapSwitch('state')).toEqual(true)
-      expect($radio3.bootstrapSwitch('state')).toEqual(false)
-    })
-  })
-})
+        onSwitchChange(e, s) {
+          expect(s).toEqual(true);
+        },
+      });
+      $radio2.click();
+      expect($radio1.bootstrapSwitch('state')).toEqual(false);
+      expect($radio2.bootstrapSwitch('state')).toEqual(true);
+      expect($radio3.bootstrapSwitch('state')).toEqual(false);
+    });
+  });
+});