@tanstack/table-core 8.0.0-alpha.64 → 8.0.0-alpha.68

package/build/cjs/features/Headers.js

@@ -15,16 +15,16 @@ Object.defineProperty(exports, '__esModule', { value: true });
 var utils = require('../utils.js');
 
 //
-var Headers = {
-  createInstance: function createInstance(instance) {
+const Headers = {
+  createInstance: instance => {
     return {
-      createHeader: function createHeader(column, options) {
+      createHeader: (column, options) => {
         var _options$id;
 
-        var id = (_options$id = options.id) != null ? _options$id : column.id;
-        var header = {
-          id: id,
-          column: column,
+        const id = (_options$id = options.id) != null ? _options$id : column.id;
+        let header = {
+          id,
+          column,
           index: options.index,
           isPlaceholder: options.isPlaceholder,
           placeholderId: options.placeholderId,
@@ -33,34 +33,10 @@ var Headers = {
           colSpan: 0,
           rowSpan: 0,
           headerGroup: null,
-          getSize: function getSize() {
-            var sum = 0;
+          getLeafHeaders: () => {
+            const leafHeaders = [];
 
-            var recurse = function recurse(header) {
-              if (header.subHeaders.length) {
-                header.subHeaders.forEach(recurse);
-              } else {
-                var _header$column$getSiz;
-
-                sum += (_header$column$getSiz = header.column.getSize()) != null ? _header$column$getSiz : 0;
-              }
-            };
-
-            recurse(header);
-            return sum;
-          },
-          getStart: function getStart() {
-            if (header.index > 0) {
-              var prevSiblingHeader = header.headerGroup.headers[header.index - 1];
-              return prevSiblingHeader.getStart() + prevSiblingHeader.getSize();
-            }
-
-            return 0;
-          },
-          getLeafHeaders: function getLeafHeaders() {
-            var leafHeaders = [];
-
-            var recurseHeader = function recurseHeader(h) {
+            const recurseHeader = h => {
               if (h.subHeaders && h.subHeaders.length) {
                 h.subHeaders.map(recurseHeader);
               }
@@ -71,271 +47,221 @@ var Headers = {
             recurseHeader(header);
             return leafHeaders;
           },
-          renderHeader: function renderHeader() {
-            return column.header ? instance.render(column.header, {
-              instance: instance,
-              header: header,
-              column: column
-            }) : null;
-          },
-          renderFooter: function renderFooter() {
-            return column.footer ? instance.render(column.footer, {
-              instance: instance,
-              header: header,
-              column: column
-            }) : null;
-          }
+          renderHeader: () => column.header ? instance.render(column.header, {
+            instance,
+            header: header,
+            column
+          }) : null,
+          renderFooter: () => column.footer ? instance.render(column.footer, {
+            instance,
+            header: header,
+            column
+          }) : null
         };
 
-        instance._features.forEach(function (feature) {
+        instance._features.forEach(feature => {
           Object.assign(header, feature.createHeader == null ? void 0 : feature.createHeader(header, instance));
         });
 
         return header;
       },
       // Header Groups
-      getHeaderGroups: utils.memo(function () {
-        return [instance.getAllColumns(), instance.getVisibleLeafColumns(), instance.getState().columnPinning.left, instance.getState().columnPinning.right];
-      }, function (allColumns, leafColumns, left, right) {
-        var leftColumns = leafColumns.filter(function (column) {
-          return left == null ? void 0 : left.includes(column.id);
-        });
-        var rightColumns = leafColumns.filter(function (column) {
-          return right == null ? void 0 : right.includes(column.id);
-        });
-        var centerColumns = leafColumns.filter(function (column) {
-          return !(left != null && left.includes(column.id)) && !(right != null && right.includes(column.id));
-        });
-        var headerGroups = buildHeaderGroups(allColumns, [].concat(leftColumns, centerColumns, rightColumns), instance);
+      getHeaderGroups: utils.memo(() => [instance.getAllColumns(), instance.getVisibleLeafColumns(), instance.getState().columnPinning.left, instance.getState().columnPinning.right], (allColumns, leafColumns, left, right) => {
+        const leftColumns = leafColumns.filter(column => left == null ? void 0 : left.includes(column.id));
+        const rightColumns = leafColumns.filter(column => right == null ? void 0 : right.includes(column.id));
+        const centerColumns = leafColumns.filter(column => !(left != null && left.includes(column.id)) && !(right != null && right.includes(column.id)));
+        const headerGroups = buildHeaderGroups(allColumns, [...leftColumns, ...centerColumns, ...rightColumns], instance);
         return headerGroups;
       }, {
-        key: 'getHeaderGroups',
-        debug: function debug() {
+        key: process.env.NODE_ENV === 'development' && 'getHeaderGroups',
+        debug: () => {
           var _instance$options$deb;
 
           return (_instance$options$deb = instance.options.debugAll) != null ? _instance$options$deb : instance.options.debugHeaders;
         }
       }),
-      getCenterHeaderGroups: utils.memo(function () {
-        return [instance.getAllColumns(), instance.getVisibleLeafColumns(), instance.getState().columnPinning.left, instance.getState().columnPinning.right];
-      }, function (allColumns, leafColumns, left, right) {
-        leafColumns = leafColumns.filter(function (column) {
-          return !(left != null && left.includes(column.id)) && !(right != null && right.includes(column.id));
-        });
+      getCenterHeaderGroups: utils.memo(() => [instance.getAllColumns(), instance.getVisibleLeafColumns(), instance.getState().columnPinning.left, instance.getState().columnPinning.right], (allColumns, leafColumns, left, right) => {
+        leafColumns = leafColumns.filter(column => !(left != null && left.includes(column.id)) && !(right != null && right.includes(column.id)));
         return buildHeaderGroups(allColumns, leafColumns, instance, 'center');
       }, {
-        key: 'getCenterHeaderGroups',
-        debug: function debug() {
+        key: process.env.NODE_ENV === 'development' && 'getCenterHeaderGroups',
+        debug: () => {
           var _instance$options$deb2;
 
           return (_instance$options$deb2 = instance.options.debugAll) != null ? _instance$options$deb2 : instance.options.debugHeaders;
         }
       }),
-      getLeftHeaderGroups: utils.memo(function () {
-        return [instance.getAllColumns(), instance.getVisibleLeafColumns(), instance.getState().columnPinning.left];
-      }, function (allColumns, leafColumns, left) {
-        leafColumns = leafColumns.filter(function (column) {
-          return left == null ? void 0 : left.includes(column.id);
-        });
+      getLeftHeaderGroups: utils.memo(() => [instance.getAllColumns(), instance.getVisibleLeafColumns(), instance.getState().columnPinning.left], (allColumns, leafColumns, left) => {
+        leafColumns = leafColumns.filter(column => left == null ? void 0 : left.includes(column.id));
         return buildHeaderGroups(allColumns, leafColumns, instance, 'left');
       }, {
-        key: 'getLeftHeaderGroups',
-        debug: function debug() {
+        key: process.env.NODE_ENV === 'development' && 'getLeftHeaderGroups',
+        debug: () => {
           var _instance$options$deb3;
 
           return (_instance$options$deb3 = instance.options.debugAll) != null ? _instance$options$deb3 : instance.options.debugHeaders;
         }
       }),
-      getRightHeaderGroups: utils.memo(function () {
-        return [instance.getAllColumns(), instance.getVisibleLeafColumns(), instance.getState().columnPinning.right];
-      }, function (allColumns, leafColumns, right) {
-        leafColumns = leafColumns.filter(function (column) {
-          return right == null ? void 0 : right.includes(column.id);
-        });
+      getRightHeaderGroups: utils.memo(() => [instance.getAllColumns(), instance.getVisibleLeafColumns(), instance.getState().columnPinning.right], (allColumns, leafColumns, right) => {
+        leafColumns = leafColumns.filter(column => right == null ? void 0 : right.includes(column.id));
         return buildHeaderGroups(allColumns, leafColumns, instance, 'right');
       }, {
-        key: 'getRightHeaderGroups',
-        debug: function debug() {
+        key: process.env.NODE_ENV === 'development' && 'getRightHeaderGroups',
+        debug: () => {
           var _instance$options$deb4;
 
           return (_instance$options$deb4 = instance.options.debugAll) != null ? _instance$options$deb4 : instance.options.debugHeaders;
         }
       }),
       // Footer Groups
-      getFooterGroups: utils.memo(function () {
-        return [instance.getHeaderGroups()];
-      }, function (headerGroups) {
-        return [].concat(headerGroups).reverse();
+      getFooterGroups: utils.memo(() => [instance.getHeaderGroups()], headerGroups => {
+        return [...headerGroups].reverse();
       }, {
-        key: 'getFooterGroups',
-        debug: function debug() {
+        key: process.env.NODE_ENV === 'development' && 'getFooterGroups',
+        debug: () => {
           var _instance$options$deb5;
 
           return (_instance$options$deb5 = instance.options.debugAll) != null ? _instance$options$deb5 : instance.options.debugHeaders;
         }
       }),
-      getLeftFooterGroups: utils.memo(function () {
-        return [instance.getLeftHeaderGroups()];
-      }, function (headerGroups) {
-        return [].concat(headerGroups).reverse();
+      getLeftFooterGroups: utils.memo(() => [instance.getLeftHeaderGroups()], headerGroups => {
+        return [...headerGroups].reverse();
       }, {
-        key: 'getLeftFooterGroups',
-        debug: function debug() {
+        key: process.env.NODE_ENV === 'development' && 'getLeftFooterGroups',
+        debug: () => {
           var _instance$options$deb6;
 
           return (_instance$options$deb6 = instance.options.debugAll) != null ? _instance$options$deb6 : instance.options.debugHeaders;
         }
       }),
-      getCenterFooterGroups: utils.memo(function () {
-        return [instance.getCenterHeaderGroups()];
-      }, function (headerGroups) {
-        return [].concat(headerGroups).reverse();
+      getCenterFooterGroups: utils.memo(() => [instance.getCenterHeaderGroups()], headerGroups => {
+        return [...headerGroups].reverse();
       }, {
-        key: 'getCenterFooterGroups',
-        debug: function debug() {
+        key: process.env.NODE_ENV === 'development' && 'getCenterFooterGroups',
+        debug: () => {
           var _instance$options$deb7;
 
           return (_instance$options$deb7 = instance.options.debugAll) != null ? _instance$options$deb7 : instance.options.debugHeaders;
         }
       }),
-      getRightFooterGroups: utils.memo(function () {
-        return [instance.getRightHeaderGroups()];
-      }, function (headerGroups) {
-        return [].concat(headerGroups).reverse();
+      getRightFooterGroups: utils.memo(() => [instance.getRightHeaderGroups()], headerGroups => {
+        return [...headerGroups].reverse();
       }, {
-        key: 'getRightFooterGroups',
-        debug: function debug() {
+        key: process.env.NODE_ENV === 'development' && 'getRightFooterGroups',
+        debug: () => {
           var _instance$options$deb8;
 
           return (_instance$options$deb8 = instance.options.debugAll) != null ? _instance$options$deb8 : instance.options.debugHeaders;
         }
       }),
       // Flat Headers
-      getFlatHeaders: utils.memo(function () {
-        return [instance.getHeaderGroups()];
-      }, function (headerGroups) {
-        return headerGroups.map(function (headerGroup) {
+      getFlatHeaders: utils.memo(() => [instance.getHeaderGroups()], headerGroups => {
+        return headerGroups.map(headerGroup => {
           return headerGroup.headers;
         }).flat();
       }, {
-        key: 'getFlatHeaders',
-        debug: function debug() {
+        key: process.env.NODE_ENV === 'development' && 'getFlatHeaders',
+        debug: () => {
           var _instance$options$deb9;
 
           return (_instance$options$deb9 = instance.options.debugAll) != null ? _instance$options$deb9 : instance.options.debugHeaders;
         }
       }),
-      getLeftFlatHeaders: utils.memo(function () {
-        return [instance.getLeftHeaderGroups()];
-      }, function (left) {
-        return left.map(function (headerGroup) {
+      getLeftFlatHeaders: utils.memo(() => [instance.getLeftHeaderGroups()], left => {
+        return left.map(headerGroup => {
           return headerGroup.headers;
         }).flat();
       }, {
-        key: 'getLeftFlatHeaders',
-        debug: function debug() {
+        key: process.env.NODE_ENV === 'development' && 'getLeftFlatHeaders',
+        debug: () => {
           var _instance$options$deb10;
 
           return (_instance$options$deb10 = instance.options.debugAll) != null ? _instance$options$deb10 : instance.options.debugHeaders;
         }
       }),
-      getCenterFlatHeaders: utils.memo(function () {
-        return [instance.getCenterHeaderGroups()];
-      }, function (left) {
-        return left.map(function (headerGroup) {
+      getCenterFlatHeaders: utils.memo(() => [instance.getCenterHeaderGroups()], left => {
+        return left.map(headerGroup => {
           return headerGroup.headers;
         }).flat();
       }, {
-        key: 'getCenterFlatHeaders',
-        debug: function debug() {
+        key: process.env.NODE_ENV === 'development' && 'getCenterFlatHeaders',
+        debug: () => {
           var _instance$options$deb11;
 
           return (_instance$options$deb11 = instance.options.debugAll) != null ? _instance$options$deb11 : instance.options.debugHeaders;
         }
       }),
-      getRightFlatHeaders: utils.memo(function () {
-        return [instance.getRightHeaderGroups()];
-      }, function (left) {
-        return left.map(function (headerGroup) {
+      getRightFlatHeaders: utils.memo(() => [instance.getRightHeaderGroups()], left => {
+        return left.map(headerGroup => {
           return headerGroup.headers;
         }).flat();
       }, {
-        key: 'getRightFlatHeaders',
-        debug: function debug() {
+        key: process.env.NODE_ENV === 'development' && 'getRightFlatHeaders',
+        debug: () => {
           var _instance$options$deb12;
 
           return (_instance$options$deb12 = instance.options.debugAll) != null ? _instance$options$deb12 : instance.options.debugHeaders;
         }
       }),
       // Leaf Headers
-      getCenterLeafHeaders: utils.memo(function () {
-        return [instance.getCenterFlatHeaders()];
-      }, function (flatHeaders) {
-        return flatHeaders.filter(function (header) {
+      getCenterLeafHeaders: utils.memo(() => [instance.getCenterFlatHeaders()], flatHeaders => {
+        return flatHeaders.filter(header => {
           var _header$subHeaders;
 
           return !((_header$subHeaders = header.subHeaders) != null && _header$subHeaders.length);
         });
       }, {
-        key: 'getCenterLeafHeaders',
-        debug: function debug() {
+        key: process.env.NODE_ENV === 'development' && 'getCenterLeafHeaders',
+        debug: () => {
           var _instance$options$deb13;
 
           return (_instance$options$deb13 = instance.options.debugAll) != null ? _instance$options$deb13 : instance.options.debugHeaders;
         }
       }),
-      getLeftLeafHeaders: utils.memo(function () {
-        return [instance.getLeftFlatHeaders()];
-      }, function (flatHeaders) {
-        return flatHeaders.filter(function (header) {
+      getLeftLeafHeaders: utils.memo(() => [instance.getLeftFlatHeaders()], flatHeaders => {
+        return flatHeaders.filter(header => {
           var _header$subHeaders2;
 
           return !((_header$subHeaders2 = header.subHeaders) != null && _header$subHeaders2.length);
         });
       }, {
-        key: 'getLeftLeafHeaders',
-        debug: function debug() {
+        key: process.env.NODE_ENV === 'development' && 'getLeftLeafHeaders',
+        debug: () => {
           var _instance$options$deb14;
 
           return (_instance$options$deb14 = instance.options.debugAll) != null ? _instance$options$deb14 : instance.options.debugHeaders;
         }
       }),
-      getRightLeafHeaders: utils.memo(function () {
-        return [instance.getRightFlatHeaders()];
-      }, function (flatHeaders) {
-        return flatHeaders.filter(function (header) {
+      getRightLeafHeaders: utils.memo(() => [instance.getRightFlatHeaders()], flatHeaders => {
+        return flatHeaders.filter(header => {
           var _header$subHeaders3;
 
           return !((_header$subHeaders3 = header.subHeaders) != null && _header$subHeaders3.length);
         });
       }, {
-        key: 'getRightLeafHeaders',
-        debug: function debug() {
+        key: process.env.NODE_ENV === 'development' && 'getRightLeafHeaders',
+        debug: () => {
           var _instance$options$deb15;
 
           return (_instance$options$deb15 = instance.options.debugAll) != null ? _instance$options$deb15 : instance.options.debugHeaders;
         }
       }),
-      getLeafHeaders: utils.memo(function () {
-        return [instance.getLeftHeaderGroups(), instance.getCenterHeaderGroups(), instance.getRightHeaderGroups()];
-      }, function (left, center, right) {
+      getLeafHeaders: utils.memo(() => [instance.getLeftHeaderGroups(), instance.getCenterHeaderGroups(), instance.getRightHeaderGroups()], (left, center, right) => {
         var _left$0$headers, _left$, _center$0$headers, _center$, _right$0$headers, _right$;
 
-        return [].concat((_left$0$headers = (_left$ = left[0]) == null ? void 0 : _left$.headers) != null ? _left$0$headers : [], (_center$0$headers = (_center$ = center[0]) == null ? void 0 : _center$.headers) != null ? _center$0$headers : [], (_right$0$headers = (_right$ = right[0]) == null ? void 0 : _right$.headers) != null ? _right$0$headers : []).map(function (header) {
+        return [...((_left$0$headers = (_left$ = left[0]) == null ? void 0 : _left$.headers) != null ? _left$0$headers : []), ...((_center$0$headers = (_center$ = center[0]) == null ? void 0 : _center$.headers) != null ? _center$0$headers : []), ...((_right$0$headers = (_right$ = right[0]) == null ? void 0 : _right$.headers) != null ? _right$0$headers : [])].map(header => {
           return header.getLeafHeaders();
         }).flat();
       }, {
-        key: 'getLeafHeaders',
-        debug: function debug() {
+        key: process.env.NODE_ENV === 'development' && 'getLeafHeaders',
+        debug: () => {
           var _instance$options$deb16;
 
           return (_instance$options$deb16 = instance.options.debugAll) != null ? _instance$options$deb16 : instance.options.debugHeaders;
         }
       }),
-      getHeader: function getHeader(id) {
-        var header = [].concat(instance.getFlatHeaders(), instance.getCenterFlatHeaders(), instance.getLeftFlatHeaders(), instance.getRightFlatHeaders()).find(function (d) {
-          return d.id === id;
-        });
+      getHeader: id => {
+        const header = [...instance.getFlatHeaders(), ...instance.getCenterFlatHeaders(), ...instance.getLeftFlatHeaders(), ...instance.getRightFlatHeaders()].find(d => d.id === id);
 
         if (!header) {
           if (process.env.NODE_ENV !== 'production') {
@@ -358,17 +284,15 @@ function buildHeaderGroups(allColumns, columnsToGroup, instance, headerFamily) {
   // build each buffer row going up
   //    placeholder for non-existent level
   //    real column for existing level
-  var maxDepth = 0;
+  let maxDepth = 0;
 
-  var findMaxDepth = function findMaxDepth(columns, depth) {
+  const findMaxDepth = function (columns, depth) {
     if (depth === void 0) {
       depth = 1;
     }
 
     maxDepth = Math.max(maxDepth, depth);
-    columns.filter(function (column) {
-      return column.getIsVisible();
-    }).forEach(function (column) {
+    columns.filter(column => column.getIsVisible()).forEach(column => {
       var _column$columns;
 
       if ((_column$columns = column.columns) != null && _column$columns.length) {
@@ -378,24 +302,24 @@ function buildHeaderGroups(allColumns, columnsToGroup, instance, headerFamily) {
   };
 
   findMaxDepth(allColumns);
-  var headerGroups = [];
+  let headerGroups = [];
 
-  var createHeaderGroup = function createHeaderGroup(headersToGroup, depth) {
+  const createHeaderGroup = (headersToGroup, depth) => {
     // The header group we are creating
-    var headerGroup = {
-      depth: depth,
+    const headerGroup = {
+      depth,
       id: [headerFamily, "" + depth].filter(Boolean).join('_'),
       headers: []
     }; // The parent columns we're going to scan next
 
-    var pendingParentHeaders = []; // Scan each column for parents
+    const pendingParentHeaders = []; // Scan each column for parents
 
-    headersToGroup.forEach(function (headerToGroup) {
+    headersToGroup.forEach(headerToGroup => {
       // What is the latest (last) parent column?
-      var latestPendingParentHeader = [].concat(pendingParentHeaders).reverse()[0];
-      var isLeafHeader = headerToGroup.column.depth === headerGroup.depth;
-      var column;
-      var isPlaceholder = false;
+      const latestPendingParentHeader = [...pendingParentHeaders].reverse()[0];
+      const isLeafHeader = headerToGroup.column.depth === headerGroup.depth;
+      let column;
+      let isPlaceholder = false;
 
       if (isLeafHeader && headerToGroup.column.parent) {
         // The parent header is new
@@ -411,13 +335,11 @@ function buildHeaderGroups(allColumns, columnsToGroup, instance, headerFamily) {
         latestPendingParentHeader.subHeaders.push(headerToGroup);
       } else {
         // This is a new header. Let's create it
-        var header = instance.createHeader(column, {
+        const header = instance.createHeader(column, {
           id: [headerFamily, depth, column.id, headerToGroup == null ? void 0 : headerToGroup.id].filter(Boolean).join('_'),
-          isPlaceholder: isPlaceholder,
-          placeholderId: isPlaceholder ? "" + pendingParentHeaders.filter(function (d) {
-            return d.column === column;
-          }).length : undefined,
-          depth: depth,
+          isPlaceholder,
+          placeholderId: isPlaceholder ? "" + pendingParentHeaders.filter(d => d.column === column).length : undefined,
+          depth,
           index: pendingParentHeaders.length
         }); // Add the headerToGroup as a subHeader of the new header
 
@@ -437,31 +359,29 @@ function buildHeaderGroups(allColumns, columnsToGroup, instance, headerFamily) {
     }
   };
 
-  var bottomHeaders = columnsToGroup.map(function (column, index) {
-    return instance.createHeader(column, {
-      depth: maxDepth,
-      index: index
-    });
-  });
+  const bottomHeaders = columnsToGroup.map((column, index) => instance.createHeader(column, {
+    depth: maxDepth,
+    index
+  }));
   createHeaderGroup(bottomHeaders, maxDepth - 1);
   headerGroups.reverse(); // headerGroups = headerGroups.filter(headerGroup => {
   //   return !headerGroup.headers.every(header => header.isPlaceholder)
   // })
 
-  var recurseHeadersForSpans = function recurseHeadersForSpans(headers) {
-    var filteredHeaders = headers.filter(function (header) {
-      return header.column.getIsVisible();
-    });
-    return filteredHeaders.map(function (header) {
-      var colSpan = 0;
-      var rowSpan = 0;
-      var childRowSpans = [0];
+  const recurseHeadersForSpans = headers => {
+    const filteredHeaders = headers.filter(header => header.column.getIsVisible());
+    return filteredHeaders.map(header => {
+      let colSpan = 0;
+      let rowSpan = 0;
+      let childRowSpans = [0];
 
       if (header.subHeaders && header.subHeaders.length) {
         childRowSpans = [];
-        recurseHeadersForSpans(header.subHeaders).forEach(function (_ref) {
-          var childColSpan = _ref.colSpan,
-              childRowSpan = _ref.rowSpan;
+        recurseHeadersForSpans(header.subHeaders).forEach(_ref => {
+          let {
+            colSpan: childColSpan,
+            rowSpan: childRowSpan
+          } = _ref;
           colSpan += childColSpan;
           childRowSpans.push(childRowSpan);
         });
@@ -469,13 +389,13 @@ function buildHeaderGroups(allColumns, columnsToGroup, instance, headerFamily) {
         colSpan = 1;
       }
 
-      var minChildRowSpan = Math.min.apply(Math, childRowSpans);
+      const minChildRowSpan = Math.min(...childRowSpans);
       rowSpan = rowSpan + minChildRowSpan;
       header.colSpan = colSpan > 0 ? colSpan : undefined;
       header.rowSpan = rowSpan > 0 ? rowSpan : undefined;
       return {
-        colSpan: colSpan,
-        rowSpan: rowSpan
+        colSpan,
+        rowSpan
       };
     });
   };