jquery.dgtable 0.5.52 → 0.5.55

package/README.md

@@ -129,6 +129,12 @@ To create a new table, just use `var myTable = new DGTable(INIT_OPTIONS)`.
   * 2nd argument: Row's index in the data set
   * 3nd argument: Row's DOM element
   * 4th argument: Row's data
+* `rowclick`: A row has just been created
+  * 1st argument: Native `MouseEvent`
+  * 2nd argument: Row's index in the currently filtered data set
+  * 3rd argument: Row's index in the data set
+  * 4th argument: Row's DOM element
+  * 5th argument: Row's data
 * `rowdestroy`: Called just before removing a physical row element from the table
   * 1st argument: Row's DOM element
 * `addrows`: Data rows have been added to the table
@@ -154,8 +160,9 @@ To create a new table, just use `var myTable = new DGTable(INIT_OPTIONS)`.
   * 1st argument: The options passed to the filter method
 * `filterclear`: A filter was cleared
 * `sort`: The data was sorted
-  * 1st argument: Array of sort constructs `[{ "column": "column's name", "descending": true/false }, ...]`
-  * 2nd argument: Boolean that determines whether this is a direct sort or indirect (sort() vs resort(), addRows(), etc.). If `false`, this is an indirect sort.
+  * 1st argument: `Array` of sort constructs `[{ "column": "column's name", "descending": true/false }, ...]`
+  * 2nd argument: `Boolean` that determines whether this is a primary sort or a resort (sort()/header click, vs resort(), addRows(), etc.). If `true`, this is a resort.
+  * 3rd argument: `Function` - the comparator that was used to sort.
 * `headercontextmenu`: A context menu should be shown for a header cell
   * 1st argument: The column's name
   * 2nd argument: pageX of the pointer event

package/dist/jquery.dgtable.cjs.js

@@ -1,5 +1,5 @@
 /*!
- * jquery.dgtable 0.5.52
+ * jquery.dgtable 0.5.55
  * git://github.com/danielgindi/jquery.dgtable.git
  */
 'use strict';
@@ -1348,13 +1348,15 @@ function getDefaultComparator(column, descending) {
 
 /**
  * @param {Boolean=false} silent
- * @returns {RowCollection} self
+ * @returns {Function|undefined} the comparator that was used
  */
 RowCollection.prototype.sort = function (silent) {
+  let comparator;
+
   if (this.sortColumn.length) {
-    let comparators = [],i,comparator;
+    let comparators = [];
 
-    for (i = 0; i < this.sortColumn.length; i++) {
+    for (let i = 0; i < this.sortColumn.length; i++) {
       comparator = null;
       const defaultComparator = getDefaultComparator(this.sortColumn[i], this.sortColumn[i].descending);
       if (this.onComparatorRequired) {
@@ -1367,13 +1369,14 @@ RowCollection.prototype.sort = function (silent) {
     }
 
     if (comparators.length === 1) {
-      nativeSort.call(this, comparators[0]);
+      comparator = comparators[0];
+      nativeSort.call(this, comparator);
     } else {
       let len = comparators.length,
       value;
 
       comparator = function (leftRow, rightRow) {
-        for (i = 0; i < len; i++) {
+        for (let i = 0; i < len; i++) {
           value = comparators[i](leftRow, rightRow);
           if (value !== 0) {
             return value;
@@ -1387,11 +1390,12 @@ RowCollection.prototype.sort = function (silent) {
 
     if (!silent) {
       if (this.onSort) {
-        this.onSort();
+        this.onSort(comparator);
       }
     }
   }
-  return this;
+
+  return comparator;
 };
 
 function ColumnCollection() {
@@ -2475,6 +2479,7 @@ DGTable.prototype.renderRows = function (first, last) {
 
   let tableClassName = o.tableClassName,
   rowClassName = tableClassName + '-row',
+  altRowClassName = tableClassName + '-row-alt',
   cellClassName = tableClassName + '-cell',
   rows = p.filteredRows || p.rows,
   isDataFiltered = !!p.filteredRows,
@@ -2483,8 +2488,7 @@ DGTable.prototype.renderRows = function (first, last) {
   isVirtual = o.virtualTable,
   virtualRowHeightFirst = p.virtualRowHeightFirst,
   virtualRowHeight = p.virtualRowHeight,
-  top,
-  physicalRowIndex;
+  top;
 
   let colCount = visibleColumns.length;
   for (let colIndex = 0, column; colIndex < colCount; colIndex++) {
@@ -2504,10 +2508,13 @@ DGTable.prototype.renderRows = function (first, last) {
   i++) {
 
     let rowData = rows[i];
-    physicalRowIndex = isDataFiltered ? rowData['__i'] : i;
+    let physicalRowIndex = isDataFiltered ? rowData['__i'] : i;
 
     let row = createElement('div');
     row.className = rowClassName;
+    if (i % 2 === 1)
+    row.className += ' ' + altRowClassName;
+
     row['rowIndex'] = i;
     row['physicalRowIndex'] = physicalRowIndex;
 
@@ -2545,6 +2552,11 @@ DGTable.prototype.renderRows = function (first, last) {
     bodyFragment.appendChild(row);
 
     this.trigger('rowcreate', i, physicalRowIndex, row, rowData);
+
+    let rowIndex = i;
+    row.addEventListener('click', (event) => {
+      this.trigger('rowclick', event, rowIndex, physicalRowIndex, row, rowData);
+    });
   }
 
   return bodyFragment;
@@ -3045,8 +3057,9 @@ DGTable.prototype.sort = function (column, descending, add) {
 
   p.rows.sortColumn = currentSort;
 
+  let comparator;
   if (currentSort.length) {
-    p.rows.sort(!!p.filteredRows);
+    comparator = p.rows.sort(!!p.filteredRows);
     if (p.filteredRows) {
       p.filteredRows.sort(!!p.filteredRows);
     }
@@ -3057,7 +3070,7 @@ DGTable.prototype.sort = function (column, descending, add) {
   for (let i = 0; i < currentSort.length; i++) {
     sorts.push({ 'column': currentSort[i].column, 'descending': currentSort[i].descending });
   }
-  this.trigger('sort', sorts, true /* direct sort */);
+  this.trigger('sort', sorts, true /* direct sort */, comparator);
 
   return this;
 };
@@ -3081,9 +3094,10 @@ DGTable.prototype.resort = function () {
       }
     }
 
+    let comparator;
     p.rows.sortColumn = currentSort;
     if (currentSort.length) {
-      p.rows.sort(!!p.filteredRows);
+      comparator = p.rows.sort(!!p.filteredRows);
       if (p.filteredRows) {
         p.filteredRows.sort(!!p.filteredRows);
       }
@@ -3094,10 +3108,9 @@ DGTable.prototype.resort = function () {
     for (let i = 0; i < currentSort.length; i++) {
       sorts.push({ 'column': currentSort[i].column, 'descending': currentSort[i].descending });
     }
-    this.trigger('sort', sorts, false /* indirect sort */);
+    this.trigger('sort', sorts, false /* indirect sort */, comparator);
   }
 
-
   return this;
 };