comparison core/misc/tabledrag.es6.js @ 17:129ea1e6d783

Update, including to Drupal core 8.6.10

  * Triggers when weights columns are toggled.
  *
  * @event columnschange
  */
 
-(function ($, Drupal, drupalSettings) {
+(function($, Drupal, drupalSettings) {
   /**
    * Store the state of weight columns display for all tables.
    *
    * Default value is to hide weight columns.
    */
-  let showWeight = JSON.parse(localStorage.getItem('Drupal.tableDrag.showWeight'));
+  let showWeight = JSON.parse(
+    localStorage.getItem('Drupal.tableDrag.showWeight'),
+  );
 
   /**
    * Drag and drop table rows with field manipulation.
    *
    * Using the drupal_attach_tabledrag() function, any table with weights or

     attach(context, settings) {
       function initTableDrag(table, base) {
         if (table.length) {
           // Create the new tableDrag instance. Save in the Drupal variable
           // to allow other scripts access to the object.
-          Drupal.tableDrag[base] = new Drupal.tableDrag(table[0], settings.tableDrag[base]);
-        }
-      }
-
-      Object.keys(settings.tableDrag || {}).forEach((base) => {
-        initTableDrag($(context).find(`#${base}`).once('tabledrag'), base);
+          Drupal.tableDrag[base] = new Drupal.tableDrag(
+            table[0],
+            settings.tableDrag[base],
+          );
+        }
+      }
+
+      Object.keys(settings.tableDrag || {}).forEach(base => {
+        initTableDrag(
+          $(context)
+            .find(`#${base}`)
+            .once('tabledrag'),
+          base,
+        );
       });
     },
   };
 
   /**

    * @param {HTMLElement} table
    *   DOM object for the table to be made draggable.
    * @param {object} tableSettings
    *   Settings for the table added via drupal_add_dragtable().
    */
-  Drupal.tableDrag = function (table, tableSettings) {
+  Drupal.tableDrag = function(table, tableSettings) {
     const self = this;
     const $table = $(table);
 
     /**
      * @type {jQuery}

      * track horizontal movement and indentations.
      *
      * @type {bool}
      */
     this.indentEnabled = false;
-    Object.keys(tableSettings || {}).forEach((group) => {
-      Object.keys(tableSettings[group] || {}).forEach((n) => {
+    Object.keys(tableSettings || {}).forEach(group => {
+      Object.keys(tableSettings[group] || {}).forEach(n => {
         if (tableSettings[group][n].relationship === 'parent') {
           this.indentEnabled = true;
         }
         if (tableSettings[group][n].limit > 0) {
           this.maxDepth = tableSettings[group][n].limit;

       // Find the width of indentations to measure mouse movements against.
       // Because the table doesn't need to start with any indentations, we
       // manually append 2 indentations in the first draggable row, measure
       // the offset, then remove.
       const indent = Drupal.theme('tableDragIndentation');
-      const testRow = $('<tr/>').addClass('draggable').appendTo(table);
-      const testCell = $('<td/>').appendTo(testRow).prepend(indent).prepend(indent);
+      const testRow = $('<tr/>')
+        .addClass('draggable')
+        .appendTo(table);
+      const testCell = $('<td/>')
+        .appendTo(testRow)
+        .prepend(indent)
+        .prepend(indent);
       const $indentation = testCell.find('.js-indentation');
 
       /**
        *
        * @type {number}
        */
-      this.indentAmount = $indentation.get(1).offsetLeft - $indentation.get(0).offsetLeft;
+      this.indentAmount =
+        $indentation.get(1).offsetLeft - $indentation.get(0).offsetLeft;
       testRow.remove();
     }
 
     // Make each applicable row draggable.
     // Match immediate children of the parent element to allow nesting.
-    $table.find('> tr.draggable, > tbody > tr.draggable').each(function () {
+    $table.find('> tr.draggable, > tbody > tr.draggable').each(function() {
       self.makeDraggable(this);
     });
 
     // Add a link before the table for users to show or hide weight columns.
-    $table.before($('<button type="button" class="link tabledrag-toggle-weight"></button>')
-      .attr('title', Drupal.t('Re-order rows by numerical weight instead of dragging.'))
-      .on('click', $.proxy(function (e) {
-        e.preventDefault();
-        this.toggleColumns();
-      }, this))
-      .wrap('<div class="tabledrag-toggle-weight-wrapper"></div>')
-      .parent(),
+    $table.before(
+      $('<button type="button" class="link tabledrag-toggle-weight"></button>')
+        .attr(
+          'title',
+          Drupal.t('Re-order rows by numerical weight instead of dragging.'),
+        )
+        .on(
+          'click',
+          $.proxy(function(e) {
+            e.preventDefault();
+            this.toggleColumns();
+          }, this),
+        )
+        .wrap('<div class="tabledrag-toggle-weight-wrapper"></div>')
+        .parent(),
     );
 
     // Initialize the specified columns (for example, weight or parent columns)
     // to show or hide according to user preference. This aids accessibility
     // so that, e.g., screen reader users can choose to enter weight values and
     // manipulate form elements directly, rather than using drag-and-drop..
     self.initColumns();
 
     // Add event bindings to the document. The self variable is passed along
     // as event handlers do not have direct access to the tableDrag object.
-    $(document).on('touchmove', event => self.dragRow(event.originalEvent.touches[0], self));
-    $(document).on('touchend', event => self.dropRow(event.originalEvent.touches[0], self));
+    $(document).on('touchmove', event =>
+      self.dragRow(event.originalEvent.touches[0], self),
+    );
+    $(document).on('touchend', event =>
+      self.dropRow(event.originalEvent.touches[0], self),
+    );
     $(document).on('mousemove pointermove', event => self.dragRow(event, self));
     $(document).on('mouseup pointerup', event => self.dropRow(event, self));
 
     // React to localStorage event showing or hiding weight columns.
-    $(window).on('storage', $.proxy(function (e) {
-      // Only react to 'Drupal.tableDrag.showWeight' value change.
-      if (e.originalEvent.key === 'Drupal.tableDrag.showWeight') {
-        // This was changed in another window, get the new value for this
-        // window.
-        showWeight = JSON.parse(e.originalEvent.newValue);
-        this.displayColumns(showWeight);
-      }
-    }, this));
+    $(window).on(
+      'storage',
+      $.proxy(function(e) {
+        // Only react to 'Drupal.tableDrag.showWeight' value change.
+        if (e.originalEvent.key === 'Drupal.tableDrag.showWeight') {
+          // This was changed in another window, get the new value for this
+          // window.
+          showWeight = JSON.parse(e.originalEvent.newValue);
+          this.displayColumns(showWeight);
+        }
+      }, this),
+    );
   };
 
   /**
    * Initialize columns containing form elements to be hidden by default.
    *
    * Identify and mark each cell with a CSS class so we can easily toggle
    * show/hide it. Finally, hide columns if user does not have a
    * 'Drupal.tableDrag.showWeight' localStorage value.
    */
-  Drupal.tableDrag.prototype.initColumns = function () {
+  Drupal.tableDrag.prototype.initColumns = function() {
     const $table = this.$table;
     let hidden;
     let cell;
     let columnIndex;
-    Object.keys(this.tableSettings || {}).forEach((group) => {
+    Object.keys(this.tableSettings || {}).forEach(group => {
       // Find the first field in this group.
-      // eslint-disable-next-line no-restricted-syntax
-      for (const d in this.tableSettings[group]) {
-        if (this.tableSettings[group].hasOwnProperty(d)) {
-          const field = $table.find(`.${this.tableSettings[group][d].target}`).eq(0);
-          if (field.length && this.tableSettings[group][d].hidden) {
-            hidden = this.tableSettings[group][d].hidden;
-            cell = field.closest('td');
-            break;
-          }
-        }
-      }
+      Object.keys(this.tableSettings[group]).some(tableSetting => {
+        const field = $table
+          .find(`.${this.tableSettings[group][tableSetting].target}`)
+          .eq(0);
+        if (field.length && this.tableSettings[group][tableSetting].hidden) {
+          hidden = this.tableSettings[group][tableSetting].hidden;
+          cell = field.closest('td');
+          return true;
+        }
+        return false;
+      });
 
       // Mark the column containing this field so it can be hidden.
       if (hidden && cell[0]) {
         // Add 1 to our indexes. The nth-child selector is 1 based, not 0
         // based. Match immediate children of the parent element to allow
         // nesting.
-        columnIndex = cell.parent().find('> td').index(cell.get(0)) + 1;
-        $table.find('> thead > tr, > tbody > tr, > tr').each(this.addColspanClass(columnIndex));
+        columnIndex =
+          cell
+            .parent()
+            .find('> td')
+            .index(cell.get(0)) + 1;
+        $table
+          .find('> thead > tr, > tbody > tr, > tr')
+          .each(this.addColspanClass(columnIndex));
       }
     });
     this.displayColumns(showWeight);
   };
 

    *   The column index to add colspan class to.
    *
    * @return {function}
    *   Function to add colspan class.
    */
-  Drupal.tableDrag.prototype.addColspanClass = function (columnIndex) {
-    return function () {
+  Drupal.tableDrag.prototype.addColspanClass = function(columnIndex) {
+    return function() {
       // Get the columnIndex and adjust for any colspans in this row.
       const $row = $(this);
       let index = columnIndex;
       const cells = $row.children();
       let cell;
-      cells.each(function (n) {
+      cells.each(function(n) {
         if (n < index && this.colSpan && this.colSpan > 1) {
           index -= this.colSpan - 1;
         }
       });
       if (index > 0) {
         cell = cells.filter(`:nth-child(${index})`);
         if (cell[0].colSpan && cell[0].colSpan > 1) {
           // If this cell has a colspan, mark it so we can reduce the colspan.
           cell.addClass('tabledrag-has-colspan');
-        }
-        else {
+        } else {
           // Mark this cell so we can hide it.
           cell.addClass('tabledrag-hide');
         }
       }
     };

    * @fires event:columnschange
    *
    * @param {bool} displayWeight
    *   'true' will show weight columns.
    */
-  Drupal.tableDrag.prototype.displayColumns = function (displayWeight) {
+  Drupal.tableDrag.prototype.displayColumns = function(displayWeight) {
     if (displayWeight) {
       this.showColumns();
     }
     // Default action is to hide columns.
     else {
       this.hideColumns();
     }
     // Trigger an event to allow other scripts to react to this display change.
     // Force the extra parameter as a bool.
-    $('table').findOnce('tabledrag').trigger('columnschange', !!displayWeight);
+    $('table')
+      .findOnce('tabledrag')
+      .trigger('columnschange', !!displayWeight);
   };
 
   /**
    * Toggle the weight column depending on 'showWeight' value.
    *
    * Store only default override.
    */
-  Drupal.tableDrag.prototype.toggleColumns = function () {
+  Drupal.tableDrag.prototype.toggleColumns = function() {
     showWeight = !showWeight;
     this.displayColumns(showWeight);
     if (showWeight) {
       // Save default override.
       localStorage.setItem('Drupal.tableDrag.showWeight', showWeight);
-    }
-    else {
+    } else {
       // Reset the value to its default.
       localStorage.removeItem('Drupal.tableDrag.showWeight');
     }
   };
 
   /**
    * Hide the columns containing weight/parent form elements.
    *
    * Undo showColumns().
    */
-  Drupal.tableDrag.prototype.hideColumns = function () {
+  Drupal.tableDrag.prototype.hideColumns = function() {
     const $tables = $('table').findOnce('tabledrag');
     // Hide weight/parent cells and headers.
     $tables.find('.tabledrag-hide').css('display', 'none');
     // Show TableDrag handles.
     $tables.find('.tabledrag-handle').css('display', '');
     // Reduce the colspan of any effected multi-span columns.
-    $tables.find('.tabledrag-has-colspan').each(function () {
+    $tables.find('.tabledrag-has-colspan').each(function() {
       this.colSpan = this.colSpan - 1;
     });
     // Change link text.
     $('.tabledrag-toggle-weight').text(Drupal.t('Show row weights'));
   };

   /**
    * Show the columns containing weight/parent form elements.
    *
    * Undo hideColumns().
    */
-  Drupal.tableDrag.prototype.showColumns = function () {
+  Drupal.tableDrag.prototype.showColumns = function() {
     const $tables = $('table').findOnce('tabledrag');
     // Show weight/parent cells and headers.
     $tables.find('.tabledrag-hide').css('display', '');
     // Hide TableDrag handles.
     $tables.find('.tabledrag-handle').css('display', 'none');
     // Increase the colspan for any columns where it was previously reduced.
-    $tables.find('.tabledrag-has-colspan').each(function () {
+    $tables.find('.tabledrag-has-colspan').each(function() {
       this.colSpan = this.colSpan + 1;
     });
     // Change link text.
     $('.tabledrag-toggle-weight').text(Drupal.t('Hide row weights'));
   };

    *   The row HTML element.
    *
    * @return {object}
    *   The table row settings.
    */
-  Drupal.tableDrag.prototype.rowSettings = function (group, row) {
+  Drupal.tableDrag.prototype.rowSettings = function(group, row) {
     const field = $(row).find(`.${group}`);
     const tableSettingsGroup = this.tableSettings[group];
-    // eslint-disable-next-line no-restricted-syntax
-    for (const delta in tableSettingsGroup) {
-      if (tableSettingsGroup.hasOwnProperty(delta)) {
+    return Object.keys(tableSettingsGroup)
+      .map(delta => {
         const targetClass = tableSettingsGroup[delta].target;
+        let rowSettings;
         if (field.is(`.${targetClass}`)) {
           // Return a copy of the row settings.
-          const rowSettings = {};
-          // eslint-disable-next-line no-restricted-syntax
-          for (const n in tableSettingsGroup[delta]) {
-            if (tableSettingsGroup[delta].hasOwnProperty(n)) {
-              rowSettings[n] = tableSettingsGroup[delta][n];
-            }
-          }
-          return rowSettings;
-        }
-      }
-    }
+          rowSettings = {};
+          Object.keys(tableSettingsGroup[delta]).forEach(n => {
+            rowSettings[n] = tableSettingsGroup[delta][n];
+          });
+        }
+        return rowSettings;
+      })
+      .filter(rowSetting => rowSetting)[0];
   };
 
   /**
    * Take an item and add event handlers to make it become draggable.
    *
    * @param {HTMLElement} item
    *   The item to add event handlers to.
    */
-  Drupal.tableDrag.prototype.makeDraggable = function (item) {
+  Drupal.tableDrag.prototype.makeDraggable = function(item) {
     const self = this;
     const $item = $(item);
     // Add a class to the title link.
-    $item.find('td:first-of-type').find('a').addClass('menu-item__link');
+    $item
+      .find('td:first-of-type')
+      .find('a')
+      .addClass('menu-item__link');
     // Create the handle.
-    const handle = $('<a href="#" class="tabledrag-handle"><div class="handle">&nbsp;</div></a>').attr('title', Drupal.t('Drag to re-order'));
+    const handle = $(
+      '<a href="#" class="tabledrag-handle"><div class="handle">&nbsp;</div></a>',
+    ).attr('title', Drupal.t('Drag to re-order'));
     // Insert the handle after indentations (if any).
-    const $indentationLast = $item.find('td:first-of-type').find('.js-indentation').eq(-1);
+    const $indentationLast = $item
+      .find('td:first-of-type')
+      .find('.js-indentation')
+      .eq(-1);
     if ($indentationLast.length) {
       $indentationLast.after(handle);
       // Update the total width of indentation in this entire table.
-      self.indentCount = Math.max($item.find('.js-indentation').length, self.indentCount);
-    }
-    else {
-      $item.find('td').eq(0).prepend(handle);
-    }
-
-    handle.on('mousedown touchstart pointerdown', (event) => {
+      self.indentCount = Math.max(
+        $item.find('.js-indentation').length,
+        self.indentCount,
+      );
+    } else {
+      $item
+        .find('td')
+        .eq(0)
+        .prepend(handle);
+    }
+
+    handle.on('mousedown touchstart pointerdown', event => {
       event.preventDefault();
       if (event.originalEvent.type === 'touchstart') {
         event = event.originalEvent.touches[0];
       }
       self.dragStart(event, self, item);
     });
 
     // Prevent the anchor tag from jumping us to the top of the page.
-    handle.on('click', (e) => {
+    handle.on('click', e => {
       e.preventDefault();
     });
 
     // Set blur cleanup when a handle is focused.
     handle.on('focus', () => {
       self.safeBlur = true;
     });
 
     // On blur, fire the same function as a touchend/mouseup. This is used to
     // update values after a row has been moved through the keyboard support.
-    handle.on('blur', (event) => {
+    handle.on('blur', event => {
       if (self.rowObject && self.safeBlur) {
         self.dropRow(event, self);
       }
     });
 
     // Add arrow-key support to the handle.
-    handle.on('keydown', (event) => {
+    handle.on('keydown', event => {
       // If a rowObject doesn't yet exist and this isn't the tab key.
       if (event.keyCode !== 9 && !self.rowObject) {
-        self.rowObject = new self.row(item, 'keyboard', self.indentEnabled, self.maxDepth, true);
+        self.rowObject = new self.row(
+          item,
+          'keyboard',
+          self.indentEnabled,
+          self.maxDepth,
+          true,
+        );
       }
 
       let keyChange = false;
       let groupHeight;
 

 
         // Up arrow.
         case 38:
         // Safari up arrow.
         case 63232: {
-          let $previousRow = $(self.rowObject.element).prev('tr:first-of-type');
+          let $previousRow = $(self.rowObject.element)
+            .prev('tr')
+            .eq(0);
           let previousRow = $previousRow.get(0);
           while (previousRow && $previousRow.is(':hidden')) {
-            $previousRow = $(previousRow).prev('tr:first-of-type');
+            $previousRow = $(previousRow)
+              .prev('tr')
+              .eq(0);
             previousRow = $previousRow.get(0);
           }
           if (previousRow) {
             // Do not allow the onBlur cleanup.
             self.safeBlur = false;

             keyChange = true;
 
             if ($(item).is('.tabledrag-root')) {
               // Swap with the previous top-level row.
               groupHeight = 0;
-              while (previousRow && $previousRow.find('.js-indentation').length) {
-                $previousRow = $(previousRow).prev('tr:first-of-type');
+              while (
+                previousRow &&
+                $previousRow.find('.js-indentation').length
+              ) {
+                $previousRow = $(previousRow)
+                  .prev('tr')
+                  .eq(0);
                 previousRow = $previousRow.get(0);
-                groupHeight += $previousRow.is(':hidden') ? 0 : previousRow.offsetHeight;
+                groupHeight += $previousRow.is(':hidden')
+                  ? 0
+                  : previousRow.offsetHeight;
               }
               if (previousRow) {
                 self.rowObject.swap('before', previousRow);
                 // No need to check for indentation, 0 is the only valid one.
                 window.scrollBy(0, -groupHeight);
               }
-            }
-            else if (self.table.tBodies[0].rows[0] !== previousRow || $previousRow.is('.draggable')) {
+            } else if (
+              self.table.tBodies[0].rows[0] !== previousRow ||
+              $previousRow.is('.draggable')
+            ) {
               // Swap with the previous row (unless previous row is the first
               // one and undraggable).
               self.rowObject.swap('before', previousRow);
               self.rowObject.interval = null;
               self.rowObject.indent(0);

 
         // Down arrow.
         case 40:
         // Safari down arrow.
         case 63233: {
-          let $nextRow = $(self.rowObject.group).eq(-1).next('tr:first-of-type');
+          let $nextRow = $(self.rowObject.group)
+            .eq(-1)
+            .next('tr')
+            .eq(0);
           let nextRow = $nextRow.get(0);
           while (nextRow && $nextRow.is(':hidden')) {
-            $nextRow = $(nextRow).next('tr:first-of-type');
+            $nextRow = $(nextRow)
+              .next('tr')
+              .eq(0);
             nextRow = $nextRow.get(0);
           }
           if (nextRow) {
             // Do not allow the onBlur cleanup.
             self.safeBlur = false;

             keyChange = true;
 
             if ($(item).is('.tabledrag-root')) {
               // Swap with the next group (necessarily a top-level one).
               groupHeight = 0;
-              const nextGroup = new self.row(nextRow, 'keyboard', self.indentEnabled, self.maxDepth, false);
+              const nextGroup = new self.row(
+                nextRow,
+                'keyboard',
+                self.indentEnabled,
+                self.maxDepth,
+                false,
+              );
               if (nextGroup) {
-                $(nextGroup.group).each(function () {
+                $(nextGroup.group).each(function() {
                   groupHeight += $(this).is(':hidden') ? 0 : this.offsetHeight;
                 });
-                const nextGroupRow = $(nextGroup.group).eq(-1).get(0);
+                const nextGroupRow = $(nextGroup.group)
+                  .eq(-1)
+                  .get(0);
                 self.rowObject.swap('after', nextGroupRow);
                 // No need to check for indentation, 0 is the only valid one.
                 window.scrollBy(0, parseInt(groupHeight, 10));
               }
-            }
-            else {
+            } else {
               // Swap with the next row.
               self.rowObject.swap('after', nextRow);
               self.rowObject.interval = null;
               self.rowObject.indent(0);
               window.scrollBy(0, parseInt(item.offsetHeight, 10));

 
     // Compatibility addition, return false on keypress to prevent unwanted
     // scrolling. IE and Safari will suppress scrolling on keydown, but all
     // other browsers need to return false on keypress.
     // http://www.quirksmode.org/js/keys.html
-    handle.on('keypress', (event) => {
+    handle.on('keypress', event => {
       /* eslint-disable no-fallthrough */
 
       switch (event.keyCode) {
         // Left arrow.
         case 37:

    * @param {Drupal.tableDrag} self
    *   The drag handle.
    * @param {HTMLElement} item
    *   The item that that is being dragged.
    */
-  Drupal.tableDrag.prototype.dragStart = function (event, self, item) {
+  Drupal.tableDrag.prototype.dragStart = function(event, self, item) {
     // Create a new dragObject recording the pointer information.
     self.dragObject = {};
     self.dragObject.initOffset = self.getPointerOffset(item, event);
     self.dragObject.initPointerCoords = self.pointerCoords(event);
     if (self.indentEnabled) {
       self.dragObject.indentPointerPos = self.dragObject.initPointerCoords;
     }
 
     // If there's a lingering row object from the keyboard, remove its focus.
     if (self.rowObject) {
-      $(self.rowObject.element).find('a.tabledrag-handle').trigger('blur');
+      $(self.rowObject.element)
+        .find('a.tabledrag-handle')
+        .trigger('blur');
     }
 
     // Create a new rowObject for manipulation of this row.
-    self.rowObject = new self.row(item, 'pointer', self.indentEnabled, self.maxDepth, true);
+    self.rowObject = new self.row(
+      item,
+      'pointer',
+      self.indentEnabled,
+      self.maxDepth,
+      true,
+    );
 
     // Save the position of the table.
     self.table.topY = $(self.table).offset().top;
     self.table.bottomY = self.table.topY + self.table.offsetHeight;
 

    *   The tableDrag instance.
    *
    * @return {bool|undefined}
    *   Undefined if no dragObject is defined, false otherwise.
    */
-  Drupal.tableDrag.prototype.dragRow = function (event, self) {
+  Drupal.tableDrag.prototype.dragRow = function(event, self) {
     if (self.dragObject) {
       self.currentPointerCoords = self.pointerCoords(event);
       const y = self.currentPointerCoords.y - self.dragObject.initOffset.y;
       const x = self.currentPointerCoords.x - self.dragObject.initOffset.x;
 

         // Check if the window should be scrolled (and how fast).
         const scrollAmount = self.checkScroll(self.currentPointerCoords.y);
         // Stop any current scrolling.
         clearInterval(self.scrollInterval);
         // Continue scrolling if the mouse has moved in the scroll direction.
-        if ((scrollAmount > 0 && self.rowObject.direction === 'down')
-          || (scrollAmount < 0 && self.rowObject.direction === 'up')) {
+        if (
+          (scrollAmount > 0 && self.rowObject.direction === 'down') ||
+          (scrollAmount < 0 && self.rowObject.direction === 'up')
+        ) {
           self.setScroll(scrollAmount);
         }
 
         // If we have a valid target, perform the swap and restripe the table.
         const currentRow = self.findDropTargetRow(x, y);
         if (currentRow) {
           if (self.rowObject.direction === 'down') {
             self.rowObject.swap('after', currentRow, self);
-          }
-          else {
+          } else {
             self.rowObject.swap('before', currentRow, self);
           }
           if (self.striping === true) {
             self.restripeTable();
           }
         }
       }
 
       // Similar to row swapping, handle indentations.
       if (self.indentEnabled) {
-        const xDiff = self.currentPointerCoords.x - self.dragObject.indentPointerPos.x;
+        const xDiff =
+          self.currentPointerCoords.x - self.dragObject.indentPointerPos.x;
         // Set the number of indentations the pointer has been moved left or
         // right.
         const indentDiff = Math.round(xDiff / self.indentAmount);
         // Indent the row with our estimated diff, which may be further
         // restricted according to the rows around this row.
         const indentChange = self.rowObject.indent(indentDiff);
         // Update table and pointer indentations.
-        self.dragObject.indentPointerPos.x += self.indentAmount * indentChange * self.rtl;
+        self.dragObject.indentPointerPos.x +=
+          self.indentAmount * indentChange * self.rtl;
         self.indentCount = Math.max(self.indentCount, self.rowObject.indents);
       }
 
       return false;
     }

    * @param {jQuery.Event} event
    *   The pointer event.
    * @param {Drupal.tableDrag} self
    *   The tableDrag instance.
    */
-  Drupal.tableDrag.prototype.dropRow = function (event, self) {
+  Drupal.tableDrag.prototype.dropRow = function(event, self) {
     let droppedRow;
     let $droppedRow;
 
     // Drop row functionality.
     if (self.rowObject !== null) {

         // Update the fields in the dropped row.
         self.updateFields(droppedRow);
 
         // If a setting exists for affecting the entire group, update all the
         // fields in the entire dragged group.
-        Object.keys(self.tableSettings || {}).forEach((group) => {
+        Object.keys(self.tableSettings || {}).forEach(group => {
           const rowSettings = self.rowSettings(group, droppedRow);
           if (rowSettings.relationship === 'group') {
-            Object.keys(self.rowObject.children || {}).forEach((n) => {
+            Object.keys(self.rowObject.children || {}).forEach(n => {
               self.updateField(self.rowObject.children[n], group);
             });
           }
         });
 
         self.rowObject.markChanged();
         if (self.changed === false) {
-          $(Drupal.theme('tableDragChangedWarning')).insertBefore(self.table).hide().fadeIn('slow');
+          $(Drupal.theme('tableDragChangedWarning'))
+            .insertBefore(self.table)
+            .hide()
+            .fadeIn('slow');
           self.changed = true;
         }
       }
 
       if (self.indentEnabled) {

    *   The pointer event.
    *
    * @return {object}
    *   An object with `x` and `y` keys indicating the position.
    */
-  Drupal.tableDrag.prototype.pointerCoords = function (event) {
+  Drupal.tableDrag.prototype.pointerCoords = function(event) {
     if (event.pageX || event.pageY) {
       return { x: event.pageX, y: event.pageY };
     }
     return {
-      x: (event.clientX + document.body.scrollLeft) - document.body.clientLeft,
-      y: (event.clientY + document.body.scrollTop) - document.body.clientTop,
+      x: event.clientX + document.body.scrollLeft - document.body.clientLeft,
+      y: event.clientY + document.body.scrollTop - document.body.clientTop,
     };
   };
 
   /**
    * Get the event offset from the target element.

    *   The pointer event.
    *
    * @return {object}
    *   An object with `x` and `y` keys indicating the position.
    */
-  Drupal.tableDrag.prototype.getPointerOffset = function (target, event) {
+  Drupal.tableDrag.prototype.getPointerOffset = function(target, event) {
     const docPos = $(target).offset();
     const pointerPos = this.pointerCoords(event);
     return { x: pointerPos.x - docPos.left, y: pointerPos.y - docPos.top };
   };
 

    *   The y coordinate of the mouse on the page (not the screen).
    *
    * @return {*}
    *   The drop target row, if found.
    */
-  Drupal.tableDrag.prototype.findDropTargetRow = function (x, y) {
+  Drupal.tableDrag.prototype.findDropTargetRow = function(x, y) {
     const rows = $(this.table.tBodies[0].rows).not(':hidden');
     for (let n = 0; n < rows.length; n++) {
       let row = rows[n];
       let $row = $(row);
       const rowY = $row.offset().top;

       else {
         rowHeight = parseInt(row.offsetHeight, 10) / 2;
       }
 
       // Because we always insert before, we need to offset the height a bit.
-      if ((y > (rowY - rowHeight)) && (y < (rowY + rowHeight))) {
+      if (y > rowY - rowHeight && y < rowY + rowHeight) {
         if (this.indentEnabled) {
           // Check that this row is not a child of the row being dragged.
-          // eslint-disable-next-line no-restricted-syntax
-          for (n in this.rowObject.group) {
-            if (this.rowObject.group[n] === row) {
-              return null;
-            }
+          if (
+            Object.keys(this.rowObject.group).some(
+              o => this.rowObject.group[o] === row,
+            )
+          ) {
+            return null;
           }
         }
         // Do not allow a row to be swapped with itself.
         else if (row === this.rowObject.element) {
           return null;

    * After the row is dropped, update the table fields.
    *
    * @param {HTMLElement} changedRow
    *   DOM object for the row that was just dropped.
    */
-  Drupal.tableDrag.prototype.updateFields = function (changedRow) {
-    Object.keys(this.tableSettings || {}).forEach((group) => {
+  Drupal.tableDrag.prototype.updateFields = function(changedRow) {
+    Object.keys(this.tableSettings || {}).forEach(group => {
       // Each group may have a different setting for relationship, so we find
       // the source rows for each separately.
       this.updateField(changedRow, group);
     });
   };

    * @param {HTMLElement} changedRow
    *   DOM object for the row that was just dropped.
    * @param {string} group
    *   The settings group on which field updates will occur.
    */
-  Drupal.tableDrag.prototype.updateField = function (changedRow, group) {
+  Drupal.tableDrag.prototype.updateField = function(changedRow, group) {
     let rowSettings = this.rowSettings(group, changedRow);
     const $changedRow = $(changedRow);
     let sourceRow;
     let $previousRow;
     let previousRow;
     let useSibling;
     // Set the row as its own target.
-    if (rowSettings.relationship === 'self' || rowSettings.relationship === 'group') {
+    if (
+      rowSettings.relationship === 'self' ||
+      rowSettings.relationship === 'group'
+    ) {
       sourceRow = changedRow;
     }
     // Siblings are easy, check previous and next rows.
     else if (rowSettings.relationship === 'sibling') {
       $previousRow = $changedRow.prev('tr:first-of-type');
       previousRow = $previousRow.get(0);
       const $nextRow = $changedRow.next('tr:first-of-type');
       const nextRow = $nextRow.get(0);
       sourceRow = changedRow;
-      if ($previousRow.is('.draggable') && $previousRow.find(`.${group}`).length) {
+      if (
+        $previousRow.is('.draggable') &&
+        $previousRow.find(`.${group}`).length
+      ) {
         if (this.indentEnabled) {
-          if ($previousRow.find('.js-indentations').length === $changedRow.find('.js-indentations').length) {
+          if (
+            $previousRow.find('.js-indentations').length ===
+            $changedRow.find('.js-indentations').length
+          ) {
             sourceRow = previousRow;
           }
-        }
-        else {
+        } else {
           sourceRow = previousRow;
         }
-      }
-      else if ($nextRow.is('.draggable') && $nextRow.find(`.${group}`).length) {
+      } else if (
+        $nextRow.is('.draggable') &&
+        $nextRow.find(`.${group}`).length
+      ) {
         if (this.indentEnabled) {
-          if ($nextRow.find('.js-indentations').length === $changedRow.find('.js-indentations').length) {
+          if (
+            $nextRow.find('.js-indentations').length ===
+            $changedRow.find('.js-indentations').length
+          ) {
             sourceRow = nextRow;
           }
-        }
-        else {
+        } else {
           sourceRow = nextRow;
         }
       }
     }
     // Parents, look up the tree until we find a field not in this group.
     // Go up as many parents as indentations in the changed row.
     else if (rowSettings.relationship === 'parent') {
       $previousRow = $changedRow.prev('tr');
       previousRow = $previousRow;
-      while ($previousRow.length && $previousRow.find('.js-indentation').length >= this.rowObject.indents) {
+      while (
+        $previousRow.length &&
+        $previousRow.find('.js-indentation').length >= this.rowObject.indents
+      ) {
         $previousRow = $previousRow.prev('tr');
         previousRow = $previousRow;
       }
       // If we found a row.
       if ($previousRow.length) {

       // a parent, meaning this item has been placed at the root level.
       else {
         // Use the first row in the table as source, because it's guaranteed to
         // be at the root level. Find the first item, then compare this row
         // against it as a sibling.
-        sourceRow = $(this.table).find('tr.draggable:first-of-type').get(0);
+        sourceRow = $(this.table)
+          .find('tr.draggable:first-of-type')
+          .get(0);
         if (sourceRow === this.rowObject.element) {
-          sourceRow = $(this.rowObject.group[this.rowObject.group.length - 1]).next('tr.draggable').get(0);
+          sourceRow = $(this.rowObject.group[this.rowObject.group.length - 1])
+            .next('tr.draggable')
+            .get(0);
         }
         useSibling = true;
       }
     }
 

       const sourceClass = `.${rowSettings.source}`;
       const sourceElement = $(sourceClass, sourceRow).get(0);
       switch (rowSettings.action) {
         case 'depth':
           // Get the depth of the target row.
-          targetElement.value = $(sourceElement).closest('tr').find('.js-indentation').length;
+          targetElement.value = $(sourceElement)
+            .closest('tr')
+            .find('.js-indentation').length;
           break;
 
         case 'match':
           // Update the value.
           targetElement.value = sourceElement.value;

         case 'order': {
           const siblings = this.rowObject.findSiblings(rowSettings);
           if ($(targetElement).is('select')) {
             // Get a list of acceptable values.
             const values = [];
-            $(targetElement).find('option').each(function () {
-              values.push(this.value);
-            });
+            $(targetElement)
+              .find('option')
+              .each(function() {
+                values.push(this.value);
+              });
             const maxVal = values[values.length - 1];
             // Populate the values in the siblings.
-            $(siblings).find(targetClass).each(function () {
-              // If there are more items than possible values, assign the
-              // maximum value to the row.
-              if (values.length > 0) {
-                this.value = values.shift();
-              }
-              else {
-                this.value = maxVal;
-              }
-            });
-          }
-          else {
+            $(siblings)
+              .find(targetClass)
+              .each(function() {
+                // If there are more items than possible values, assign the
+                // maximum value to the row.
+                if (values.length > 0) {
+                  this.value = values.shift();
+                } else {
+                  this.value = maxVal;
+                }
+              });
+          } else {
             // Assume a numeric input field.
-            let weight = parseInt($(siblings[0]).find(targetClass).val(), 10) || 0;
-            $(siblings).find(targetClass).each(function () {
-              this.value = weight;
-              weight++;
-            });
+            let weight =
+              parseInt(
+                $(siblings[0])
+                  .find(targetClass)
+                  .val(),
+                10,
+              ) || 0;
+            $(siblings)
+              .find(targetClass)
+              .each(function() {
+                this.value = weight;
+                weight++;
+              });
           }
           break;
         }
       }
     }

    * @param {HTMLElement} targetRow
    *   The element for the target row.
    * @param {string} group
    *   The group selector.
    */
-  Drupal.tableDrag.prototype.copyDragClasses = function (sourceRow, targetRow, group) {
+  Drupal.tableDrag.prototype.copyDragClasses = function(
+    sourceRow,
+    targetRow,
+    group,
+  ) {
     const sourceElement = $(sourceRow).find(`.${group}`);
     const targetElement = $(targetRow).find(`.${group}`);
     if (sourceElement.length && targetElement.length) {
       targetElement[0].className = sourceElement[0].className;
     }

    *   The Y position of the cursor.
    *
    * @return {number}
    *   The suggested scroll.
    */
-  Drupal.tableDrag.prototype.checkScroll = function (cursorY) {
+  Drupal.tableDrag.prototype.checkScroll = function(cursorY) {
     const de = document.documentElement;
     const b = document.body;
 
-    const windowHeight = window.innerHeight || (de.clientHeight && de.clientWidth !== 0 ? de.clientHeight : b.offsetHeight);
+    const windowHeight =
+      window.innerHeight ||
+      (de.clientHeight && de.clientWidth !== 0
+        ? de.clientHeight
+        : b.offsetHeight);
     this.windowHeight = windowHeight;
     let scrollY;
     if (document.all) {
       scrollY = !de.scrollTop ? b.scrollTop : de.scrollTop;
-    }
-    else {
+    } else {
       scrollY = window.pageYOffset ? window.pageYOffset : window.scrollY;
     }
     this.scrollY = scrollY;
     const trigger = this.scrollSettings.trigger;
     let delta = 0;
 
     // Return a scroll speed relative to the edge of the screen.
     if (cursorY - scrollY > windowHeight - trigger) {
-      delta = trigger / ((windowHeight + scrollY) - cursorY);
-      delta = (delta > 0 && delta < trigger) ? delta : trigger;
+      delta = trigger / (windowHeight + scrollY - cursorY);
+      delta = delta > 0 && delta < trigger ? delta : trigger;
       return delta * this.scrollSettings.amount;
     }
-    else if (cursorY - scrollY < trigger) {
+    if (cursorY - scrollY < trigger) {
       delta = trigger / (cursorY - scrollY);
-      delta = (delta > 0 && delta < trigger) ? delta : trigger;
+      delta = delta > 0 && delta < trigger ? delta : trigger;
       return -delta * this.scrollSettings.amount;
     }
   };
 
   /**
    * Set the scroll for the table.
    *
    * @param {number} scrollAmount
    *   The amount of scroll to apply to the window.
    */
-  Drupal.tableDrag.prototype.setScroll = function (scrollAmount) {
+  Drupal.tableDrag.prototype.setScroll = function(scrollAmount) {
     const self = this;
 
     this.scrollInterval = setInterval(() => {
       // Update the scroll values stored in the object.
       self.checkScroll(self.currentPointerCoords.y);
       const aboveTable = self.scrollY > self.table.topY;
       const belowTable = self.scrollY + self.windowHeight < self.table.bottomY;
-      if ((scrollAmount > 0 && belowTable)
-        || (scrollAmount < 0 && aboveTable)) {
+      if (
+        (scrollAmount > 0 && belowTable) ||
+        (scrollAmount < 0 && aboveTable)
+      ) {
         window.scrollBy(0, scrollAmount);
       }
     }, this.scrollSettings.interval);
   };
 
   /**
    * Command to restripe table properly.
    */
-  Drupal.tableDrag.prototype.restripeTable = function () {
+  Drupal.tableDrag.prototype.restripeTable = function() {
     // :even and :odd are reversed because jQuery counts from 0 and
     // we count from 1, so we're out of sync.
     // Match immediate children of the parent element to allow nesting.
     $(this.table)
       .find('> tbody > tr.draggable, > tr.draggable')

    * Stub function. Allows a custom handler when a row begins dragging.
    *
    * @return {null}
    *   Returns null when the stub function is used.
    */
-  Drupal.tableDrag.prototype.onDrag = function () {
+  Drupal.tableDrag.prototype.onDrag = function() {
     return null;
   };
 
   /**
    * Stub function. Allows a custom handler when a row is dropped.
    *
    * @return {null}
    *   Returns null when the stub function is used.
    */
-  Drupal.tableDrag.prototype.onDrop = function () {
+  Drupal.tableDrag.prototype.onDrop = function() {
     return null;
   };
 
   /**
    * Constructor to make a new object to manipulate a table row.

    *   The maximum amount of indentations this row may contain.
    * @param {bool} addClasses
    *   Whether we want to add classes to this row to indicate child
    *   relationships.
    */
-  Drupal.tableDrag.prototype.row = function (tableRow, method, indentEnabled, maxDepth, addClasses) {
+  Drupal.tableDrag.prototype.row = function(
+    tableRow,
+    method,
+    indentEnabled,
+    maxDepth,
+    addClasses,
+  ) {
     const $tableRow = $(tableRow);
 
     this.element = tableRow;
     this.method = method;
     this.group = [tableRow];

       this.indents = $tableRow.find('.js-indentation').length;
       this.children = this.findChildren(addClasses);
       this.group = $.merge(this.group, this.children);
       // Find the depth of this entire group.
       for (let n = 0; n < this.group.length; n++) {
-        this.groupDepth = Math.max($(this.group[n]).find('.js-indentation').length, this.groupDepth);
+        this.groupDepth = Math.max(
+          $(this.group[n]).find('.js-indentation').length,
+          this.groupDepth,
+        );
       }
     }
   };
 
   /**

    *   relationships.
    *
    * @return {Array}
    *   An array of children of the row.
    */
-  Drupal.tableDrag.prototype.row.prototype.findChildren = function (addClasses) {
+  Drupal.tableDrag.prototype.row.prototype.findChildren = function(addClasses) {
     const parentIndentation = this.indents;
     let currentRow = $(this.element, this.table).next('tr.draggable');
     const rows = [];
     let child = 0;
 
     function rowIndentation(indentNum, el) {
       const self = $(el);
-      if (child === 1 && (indentNum === parentIndentation)) {
+      if (child === 1 && indentNum === parentIndentation) {
         self.addClass('tree-child-first');
       }
       if (indentNum === parentIndentation) {
         self.addClass('tree-child');
-      }
-      else if (indentNum > parentIndentation) {
+      } else if (indentNum > parentIndentation) {
         self.addClass('tree-child-horizontal');
       }
     }
 
     while (currentRow.length) {

         child++;
         rows.push(currentRow[0]);
         if (addClasses) {
           currentRow.find('.js-indentation').each(rowIndentation);
         }
-      }
-      else {
+      } else {
         break;
       }
       currentRow = currentRow.next('tr.draggable');
     }
     if (addClasses && rows.length) {
-      $(rows[rows.length - 1]).find(`.js-indentation:nth-child(${parentIndentation + 1})`).addClass('tree-child-last');
+      $(rows[rows.length - 1])
+        .find(`.js-indentation:nth-child(${parentIndentation + 1})`)
+        .addClass('tree-child-last');
     }
     return rows;
   };
 
   /**

    *   DOM object for the row being considered for swapping.
    *
    * @return {bool}
    *   Whether the swap is a valid swap or not.
    */
-  Drupal.tableDrag.prototype.row.prototype.isValidSwap = function (row) {
+  Drupal.tableDrag.prototype.row.prototype.isValidSwap = function(row) {
     const $row = $(row);
     if (this.indentEnabled) {
       let prevRow;
       let nextRow;
       if (this.direction === 'down') {
         prevRow = row;
         nextRow = $row.next('tr').get(0);
-      }
-      else {
+      } else {
         prevRow = $row.prev('tr').get(0);
         nextRow = row;
       }
       this.interval = this.validIndentInterval(prevRow, nextRow);
 

    * @param {string} position
    *   Whether the swap will occur 'before' or 'after' the given row.
    * @param {HTMLElement} row
    *   DOM element what will be swapped with the row group.
    */
-  Drupal.tableDrag.prototype.row.prototype.swap = function (position, row) {
+  Drupal.tableDrag.prototype.row.prototype.swap = function(position, row) {
     // Makes sure only DOM object are passed to Drupal.detachBehaviors().
-    this.group.forEach((row) => {
+    this.group.forEach(row => {
       Drupal.detachBehaviors(row, drupalSettings, 'move');
     });
     $(row)[position](this.group);
     // Makes sure only DOM object are passed to Drupal.attachBehaviors()s.
-    this.group.forEach((row) => {
+    this.group.forEach(row => {
       Drupal.attachBehaviors(row, drupalSettings);
     });
     this.changed = true;
     this.onSwap(row);
   };

    *
    * @return {object}
    *   An object with the keys `min` and `max` to indicate the valid indent
    *   interval.
    */
-  Drupal.tableDrag.prototype.row.prototype.validIndentInterval = function (prevRow, nextRow) {
+  Drupal.tableDrag.prototype.row.prototype.validIndentInterval = function(
+    prevRow,
+    nextRow,
+  ) {
     const $prevRow = $(prevRow);
     let maxIndent;
 
     // Minimum indentation:
     // Do not orphan the next row.
     const minIndent = nextRow ? $(nextRow).find('.js-indentation').length : 0;
 
     // Maximum indentation:
-    if (!prevRow || $prevRow.is(':not(.draggable)') || $(this.element).is('.tabledrag-root')) {
+    if (
+      !prevRow ||
+      $prevRow.is(':not(.draggable)') ||
+      $(this.element).is('.tabledrag-root')
+    ) {
       // Do not indent:
       // - the first row in the table,
       // - rows dragged below a non-draggable row,
       // - 'root' rows.
       maxIndent = 0;
-    }
-    else {
+    } else {
       // Do not go deeper than as a child of the previous row.
-      maxIndent = $prevRow.find('.js-indentation').length + ($prevRow.is('.tabledrag-leaf') ? 0 : 1);
+      maxIndent =
+        $prevRow.find('.js-indentation').length +
+        ($prevRow.is('.tabledrag-leaf') ? 0 : 1);
       // Limit by the maximum allowed depth for the table.
       if (this.maxDepth) {
-        maxIndent = Math.min(maxIndent, this.maxDepth - (this.groupDepth - this.indents));
+        maxIndent = Math.min(
+          maxIndent,
+          this.maxDepth - (this.groupDepth - this.indents),
+        );
       }
     }
 
     return { min: minIndent, max: maxIndent };
   };

    *   indentation level for the row.
    *
    * @return {number}
    *   The number of indentations applied.
    */
-  Drupal.tableDrag.prototype.row.prototype.indent = function (indentDiff) {
+  Drupal.tableDrag.prototype.row.prototype.indent = function(indentDiff) {
     const $group = $(this.group);
     // Determine the valid indentations interval if not available yet.
     if (!this.interval) {
-      const prevRow = $(this.element).prev('tr').get(0);
-      const nextRow = $group.eq(-1).next('tr').get(0);
+      const prevRow = $(this.element)
+        .prev('tr')
+        .get(0);
+      const nextRow = $group
+        .eq(-1)
+        .next('tr')
+        .get(0);
       this.interval = this.validIndentInterval(prevRow, nextRow);
     }
 
     // Adjust to the nearest valid indentation.
     let indent = this.indents + indentDiff;

     for (let n = 1; n <= Math.abs(indentDiff); n++) {
       // Add or remove indentations.
       if (indentDiff < 0) {
         $group.find('.js-indentation:first-of-type').remove();
         this.indents--;
-      }
-      else {
-        $group.find('td:first-of-type').prepend(Drupal.theme('tableDragIndentation'));
+      } else {
+        $group
+          .find('td:first-of-type')
+          .prepend(Drupal.theme('tableDragIndentation'));
         this.indents++;
       }
     }
     if (indentDiff) {
       // Update indentation for this row.

    *   The field settings we're using to identify what constitutes a sibling.
    *
    * @return {Array}
    *   An array of siblings.
    */
-  Drupal.tableDrag.prototype.row.prototype.findSiblings = function (rowSettings) {
+  Drupal.tableDrag.prototype.row.prototype.findSiblings = function(
+    rowSettings,
+  ) {
     const siblings = [];
     const directions = ['prev', 'next'];
     const rowIndentation = this.indents;
     let checkRowIndentation;
     for (let d = 0; d < directions.length; d++) {

           // that this row has the same level of indentation.
           if (this.indentEnabled) {
             checkRowIndentation = checkRow.find('.js-indentation').length;
           }
 
-          if (!(this.indentEnabled) || (checkRowIndentation === rowIndentation)) {
+          if (!this.indentEnabled || checkRowIndentation === rowIndentation) {
             siblings.push(checkRow[0]);
-          }
-          else if (checkRowIndentation < rowIndentation) {
+          } else if (checkRowIndentation < rowIndentation) {
             // No need to keep looking for siblings when we get to a parent.
             break;
           }
-        }
-        else {
+        } else {
           break;
         }
         checkRow = checkRow[directions[d]]();
       }
       // Since siblings are added in reverse order for previous, reverse the

   };
 
   /**
    * Remove indentation helper classes from the current row group.
    */
-  Drupal.tableDrag.prototype.row.prototype.removeIndentClasses = function () {
-    Object.keys(this.children || {}).forEach((n) => {
-      $(this.children[n]).find('.js-indentation')
+  Drupal.tableDrag.prototype.row.prototype.removeIndentClasses = function() {
+    Object.keys(this.children || {}).forEach(n => {
+      $(this.children[n])
+        .find('.js-indentation')
         .removeClass('tree-child')
         .removeClass('tree-child-first')
         .removeClass('tree-child-last')
         .removeClass('tree-child-horizontal');
     });
   };
 
   /**
    * Add an asterisk or other marker to the changed row.
    */
-  Drupal.tableDrag.prototype.row.prototype.markChanged = function () {
+  Drupal.tableDrag.prototype.row.prototype.markChanged = function() {
     const marker = Drupal.theme('tableDragChangedMarker');
     const cell = $(this.element).find('td:first-of-type');
     if (cell.find('abbr.tabledrag-changed').length === 0) {
       cell.append(marker);
     }

    * Stub function. Allows a custom handler when a row is indented.
    *
    * @return {null}
    *   Returns null when the stub function is used.
    */
-  Drupal.tableDrag.prototype.row.prototype.onIndent = function () {
+  Drupal.tableDrag.prototype.row.prototype.onIndent = function() {
     return null;
   };
 
   /**
    * Stub function. Allows a custom handler when a row is swapped.

    *   The element for the swapped row.
    *
    * @return {null}
    *   Returns null when the stub function is used.
    */
-  Drupal.tableDrag.prototype.row.prototype.onSwap = function (swappedRow) {
+  Drupal.tableDrag.prototype.row.prototype.onSwap = function(swappedRow) {
     return null;
   };
 
-  $.extend(Drupal.theme, /** @lends Drupal.theme */{
-
-    /**
-     * @return {string}
-     *  Markup for the marker.
-     */
-    tableDragChangedMarker() {
-      return `<abbr class="warning tabledrag-changed" title="${Drupal.t('Changed')}">*</abbr>`;
+  $.extend(
+    Drupal.theme,
+    /** @lends Drupal.theme */ {
+      /**
+       * @return {string}
+       *  Markup for the marker.
+       */
+      tableDragChangedMarker() {
+        return `<abbr class="warning tabledrag-changed" title="${Drupal.t(
+          'Changed',
+        )}">*</abbr>`;
+      },
+
+      /**
+       * @return {string}
+       *   Markup for the indentation.
+       */
+      tableDragIndentation() {
+        return '<div class="js-indentation indentation">&nbsp;</div>';
+      },
+
+      /**
+       * @return {string}
+       *   Markup for the warning.
+       */
+      tableDragChangedWarning() {
+        return `<div class="tabledrag-changed-warning messages messages--warning" role="alert">${Drupal.theme(
+          'tableDragChangedMarker',
+        )} ${Drupal.t('You have unsaved changes.')}</div>`;
+      },
     },
-
-    /**
-     * @return {string}
-     *   Markup for the indentation.
-     */
-    tableDragIndentation() {
-      return '<div class="js-indentation indentation">&nbsp;</div>';
-    },
-
-    /**
-     * @return {string}
-     *   Markup for the warning.
-     */
-    tableDragChangedWarning() {
-      return `<div class="tabledrag-changed-warning messages messages--warning" role="alert">${Drupal.theme('tableDragChangedMarker')} ${Drupal.t('You have unsaved changes.')}</div>`;
-    },
-  });
-}(jQuery, Drupal, drupalSettings));
+  );
+})(jQuery, Drupal, drupalSettings);