primereact 7.0.0-rc.1 → 7.1.0

package/treetable/treetable.esm.js

@@ -1,10 +1,12 @@
 import React, { Component } from 'react';
-import { FilterService } from 'primereact/api';
-import { DomHandler, classNames, OverlayService, ObjectUtils, Ripple } from 'primereact/core';
+import { localeOption, FilterService } from 'primereact/api';
+import { DomHandler as DomHandler$1, classNames, ObjectUtils } from 'primereact/utils';
 import { Paginator } from 'primereact/paginator';
 import { InputText } from 'primereact/inputtext';
+import { OverlayService } from 'primereact/overlayservice';
+import { Ripple } from 'primereact/ripple';
 
-function _arrayLikeToArray$3(arr, len) {
+function _arrayLikeToArray$5(arr, len) {
   if (len == null || len > arr.length) len = arr.length;
 
   for (var i = 0, arr2 = new Array(len); i < len; i++) {
@@ -15,20 +17,20 @@ function _arrayLikeToArray$3(arr, len) {
 }
 
 function _arrayWithoutHoles(arr) {
-  if (Array.isArray(arr)) return _arrayLikeToArray$3(arr);
+  if (Array.isArray(arr)) return _arrayLikeToArray$5(arr);
 }
 
 function _iterableToArray(iter) {
   if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
 }
 
-function _unsupportedIterableToArray$3(o, minLen) {
+function _unsupportedIterableToArray$5(o, minLen) {
   if (!o) return;
-  if (typeof o === "string") return _arrayLikeToArray$3(o, minLen);
+  if (typeof o === "string") return _arrayLikeToArray$5(o, minLen);
   var n = Object.prototype.toString.call(o).slice(8, -1);
   if (n === "Object" && o.constructor) n = o.constructor.name;
   if (n === "Map" || n === "Set") return Array.from(o);
-  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$3(o, minLen);
+  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$5(o, minLen);
 }
 
 function _nonIterableSpread() {
@@ -36,7 +38,7 @@ function _nonIterableSpread() {
 }
 
 function _toConsumableArray(arr) {
-  return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray$3(arr) || _nonIterableSpread();
+  return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray$5(arr) || _nonIterableSpread();
 }
 
 function _classCallCheck(instance, Constructor) {
@@ -141,11 +143,11 @@ function _defineProperty(obj, key, value) {
   return obj;
 }
 
-function _createForOfIteratorHelper$2(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray$2(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+function _createForOfIteratorHelper$4(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray$4(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
 
-function _unsupportedIterableToArray$2(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$2(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$2(o, minLen); }
+function _unsupportedIterableToArray$4(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$4(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$4(o, minLen); }
 
-function _arrayLikeToArray$2(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+function _arrayLikeToArray$4(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
 
 function _createSuper$6(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$6(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
 
@@ -174,14 +176,14 @@ var TreeTableHeader = /*#__PURE__*/function (_Component) {
       if (column.props.sortable) {
         var targetNode = event.target;
 
-        if (DomHandler.hasClass(targetNode, 'p-sortable-column') || DomHandler.hasClass(targetNode, 'p-column-title') || DomHandler.hasClass(targetNode, 'p-sortable-column-icon') || DomHandler.hasClass(targetNode.parentElement, 'p-sortable-column-icon')) {
+        if (DomHandler$1.hasClass(targetNode, 'p-sortable-column') || DomHandler$1.hasClass(targetNode, 'p-column-title') || DomHandler$1.hasClass(targetNode, 'p-sortable-column-icon') || DomHandler$1.hasClass(targetNode.parentElement, 'p-sortable-column-icon')) {
           this.props.onSort({
             originalEvent: event,
             sortField: column.props.sortField || column.props.field,
             sortFunction: column.props.sortFunction,
             sortable: column.props.sortable
           });
-          DomHandler.clearSelection();
+          DomHandler$1.clearSelection();
         }
       }
     }
@@ -290,7 +292,7 @@ var TreeTableHeader = /*#__PURE__*/function (_Component) {
     key: "hasColumnFilter",
     value: function hasColumnFilter(columns) {
       if (columns) {
-        var _iterator = _createForOfIteratorHelper$2(columns),
+        var _iterator = _createForOfIteratorHelper$4(columns),
             _step;
 
         try {
@@ -467,57 +469,1024 @@ var TreeTableHeader = /*#__PURE__*/function (_Component) {
       });
     }
   }, {
-    key: "renderColumns",
-    value: function renderColumns(columns) {
-      var _this7 = this;
+    key: "renderColumns",
+    value: function renderColumns(columns) {
+      var _this7 = this;
+
+      if (columns) {
+        if (this.hasColumnFilter(columns)) {
+          return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement("tr", null, columns.map(function (col, i) {
+            return _this7.renderHeaderCell(col, {
+              index: i,
+              filterOnly: false,
+              renderFilter: false
+            });
+          })), /*#__PURE__*/React.createElement("tr", null, columns.map(function (col, i) {
+            return _this7.renderHeaderCell(col, {
+              index: i,
+              filterOnly: true,
+              renderFilter: true
+            });
+          })));
+        } else {
+          return /*#__PURE__*/React.createElement("tr", null, columns.map(function (col, i) {
+            return _this7.renderHeaderCell(col, {
+              index: i,
+              filterOnly: false,
+              renderFilter: false
+            });
+          }));
+        }
+      } else {
+        return null;
+      }
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var content = this.props.columnGroup ? this.renderColumnGroup() : this.renderColumns(this.props.columns);
+      return /*#__PURE__*/React.createElement("thead", {
+        className: "p-treetable-thead"
+      }, content);
+    }
+  }], [{
+    key: "getDerivedStateFromProps",
+    value: function getDerivedStateFromProps(nextProps, prevState) {
+      return {
+        badgeVisible: nextProps.multiSortMeta && nextProps.multiSortMeta.length > 1
+      };
+    }
+  }]);
+
+  return TreeTableHeader;
+}(Component);
+
+function _createForOfIteratorHelper$3(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray$3(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+
+function _unsupportedIterableToArray$3(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$3(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$3(o, minLen); }
+
+function _arrayLikeToArray$3(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+var DomHandler = /*#__PURE__*/function () {
+  function DomHandler() {
+    _classCallCheck(this, DomHandler);
+  }
+
+  _createClass(DomHandler, null, [{
+    key: "innerWidth",
+    value: function innerWidth(el) {
+      if (el) {
+        var width = el.offsetWidth;
+        var style = getComputedStyle(el);
+        width += parseFloat(style.paddingLeft) + parseFloat(style.paddingRight);
+        return width;
+      }
+
+      return 0;
+    }
+  }, {
+    key: "width",
+    value: function width(el) {
+      if (el) {
+        var width = el.offsetWidth;
+        var style = getComputedStyle(el);
+        width -= parseFloat(style.paddingLeft) + parseFloat(style.paddingRight);
+        return width;
+      }
+
+      return 0;
+    }
+  }, {
+    key: "getWindowScrollTop",
+    value: function getWindowScrollTop() {
+      var doc = document.documentElement;
+      return (window.pageYOffset || doc.scrollTop) - (doc.clientTop || 0);
+    }
+  }, {
+    key: "getWindowScrollLeft",
+    value: function getWindowScrollLeft() {
+      var doc = document.documentElement;
+      return (window.pageXOffset || doc.scrollLeft) - (doc.clientLeft || 0);
+    }
+  }, {
+    key: "getOuterWidth",
+    value: function getOuterWidth(el, margin) {
+      if (el) {
+        var width = el.offsetWidth || el.getBoundingClientRect().width;
+
+        if (margin) {
+          var style = getComputedStyle(el);
+          width += parseFloat(style.marginLeft) + parseFloat(style.marginRight);
+        }
+
+        return width;
+      }
+
+      return 0;
+    }
+  }, {
+    key: "getOuterHeight",
+    value: function getOuterHeight(el, margin) {
+      if (el) {
+        var height = el.offsetHeight || el.getBoundingClientRect().height;
+
+        if (margin) {
+          var style = getComputedStyle(el);
+          height += parseFloat(style.marginTop) + parseFloat(style.marginBottom);
+        }
+
+        return height;
+      }
+
+      return 0;
+    }
+  }, {
+    key: "getClientHeight",
+    value: function getClientHeight(el, margin) {
+      if (el) {
+        var height = el.clientHeight;
+
+        if (margin) {
+          var style = getComputedStyle(el);
+          height += parseFloat(style.marginTop) + parseFloat(style.marginBottom);
+        }
+
+        return height;
+      }
+
+      return 0;
+    }
+  }, {
+    key: "getClientWidth",
+    value: function getClientWidth(el, margin) {
+      if (el) {
+        var width = el.clientWidth;
+
+        if (margin) {
+          var style = getComputedStyle(el);
+          width += parseFloat(style.marginLeft) + parseFloat(style.marginRight);
+        }
+
+        return width;
+      }
+
+      return 0;
+    }
+  }, {
+    key: "getViewport",
+    value: function getViewport() {
+      var win = window,
+          d = document,
+          e = d.documentElement,
+          g = d.getElementsByTagName('body')[0],
+          w = win.innerWidth || e.clientWidth || g.clientWidth,
+          h = win.innerHeight || e.clientHeight || g.clientHeight;
+      return {
+        width: w,
+        height: h
+      };
+    }
+  }, {
+    key: "getOffset",
+    value: function getOffset(el) {
+      if (el) {
+        var rect = el.getBoundingClientRect();
+        return {
+          top: rect.top + (window.pageYOffset || document.documentElement.scrollTop || document.body.scrollTop || 0),
+          left: rect.left + (window.pageXOffset || document.documentElement.scrollLeft || document.body.scrollLeft || 0)
+        };
+      }
+
+      return {
+        top: 'auto',
+        left: 'auto'
+      };
+    }
+  }, {
+    key: "index",
+    value: function index(element) {
+      if (element) {
+        var children = element.parentNode.childNodes;
+        var num = 0;
+
+        for (var i = 0; i < children.length; i++) {
+          if (children[i] === element) return num;
+          if (children[i].nodeType === 1) num++;
+        }
+      }
+
+      return -1;
+    }
+  }, {
+    key: "addMultipleClasses",
+    value: function addMultipleClasses(element, className) {
+      if (element && className) {
+        if (element.classList) {
+          var styles = className.split(' ');
+
+          for (var i = 0; i < styles.length; i++) {
+            element.classList.add(styles[i]);
+          }
+        } else {
+          var _styles = className.split(' ');
+
+          for (var _i = 0; _i < _styles.length; _i++) {
+            element.className += ' ' + _styles[_i];
+          }
+        }
+      }
+    }
+  }, {
+    key: "removeMultipleClasses",
+    value: function removeMultipleClasses(element, className) {
+      if (element && className) {
+        if (element.classList) {
+          var styles = className.split(' ');
+
+          for (var i = 0; i < styles.length; i++) {
+            element.classList.remove(styles[i]);
+          }
+        } else {
+          var _styles2 = className.split(' ');
+
+          for (var _i2 = 0; _i2 < _styles2.length; _i2++) {
+            element.className = element.className.replace(new RegExp('(^|\\b)' + _styles2[_i2].split(' ').join('|') + '(\\b|$)', 'gi'), ' ');
+          }
+        }
+      }
+    }
+  }, {
+    key: "addClass",
+    value: function addClass(element, className) {
+      if (element && className) {
+        if (element.classList) element.classList.add(className);else element.className += ' ' + className;
+      }
+    }
+  }, {
+    key: "removeClass",
+    value: function removeClass(element, className) {
+      if (element && className) {
+        if (element.classList) element.classList.remove(className);else element.className = element.className.replace(new RegExp('(^|\\b)' + className.split(' ').join('|') + '(\\b|$)', 'gi'), ' ');
+      }
+    }
+  }, {
+    key: "hasClass",
+    value: function hasClass(element, className) {
+      if (element) {
+        if (element.classList) return element.classList.contains(className);else return new RegExp('(^| )' + className + '( |$)', 'gi').test(element.className);
+      }
+    }
+  }, {
+    key: "find",
+    value: function find(element, selector) {
+      return element ? Array.from(element.querySelectorAll(selector)) : [];
+    }
+  }, {
+    key: "findSingle",
+    value: function findSingle(element, selector) {
+      if (element) {
+        return element.querySelector(selector);
+      }
+
+      return null;
+    }
+  }, {
+    key: "getHeight",
+    value: function getHeight(el) {
+      if (el) {
+        var height = el.offsetHeight;
+        var style = getComputedStyle(el);
+        height -= parseFloat(style.paddingTop) + parseFloat(style.paddingBottom) + parseFloat(style.borderTopWidth) + parseFloat(style.borderBottomWidth);
+        return height;
+      }
+
+      return 0;
+    }
+  }, {
+    key: "getWidth",
+    value: function getWidth(el) {
+      if (el) {
+        var width = el.offsetWidth;
+        var style = getComputedStyle(el);
+        width -= parseFloat(style.paddingLeft) + parseFloat(style.paddingRight) + parseFloat(style.borderLeftWidth) + parseFloat(style.borderRightWidth);
+        return width;
+      }
+
+      return 0;
+    }
+  }, {
+    key: "alignOverlay",
+    value: function alignOverlay(overlay, target, appendTo) {
+      var calculateMinWidth = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : true;
+
+      if (overlay && target) {
+        if (appendTo === 'self') {
+          this.relativePosition(overlay, target);
+        } else {
+          calculateMinWidth && (overlay.style.minWidth = DomHandler.getOuterWidth(target) + 'px');
+          this.absolutePosition(overlay, target);
+        }
+      }
+    }
+  }, {
+    key: "absolutePosition",
+    value: function absolutePosition(element, target) {
+      if (element) {
+        var elementDimensions = element.offsetParent ? {
+          width: element.offsetWidth,
+          height: element.offsetHeight
+        } : this.getHiddenElementDimensions(element);
+        var elementOuterHeight = elementDimensions.height;
+        var elementOuterWidth = elementDimensions.width;
+        var targetOuterHeight = target.offsetHeight;
+        var targetOuterWidth = target.offsetWidth;
+        var targetOffset = target.getBoundingClientRect();
+        var windowScrollTop = this.getWindowScrollTop();
+        var windowScrollLeft = this.getWindowScrollLeft();
+        var viewport = this.getViewport();
+        var top, left;
+
+        if (targetOffset.top + targetOuterHeight + elementOuterHeight > viewport.height) {
+          top = targetOffset.top + windowScrollTop - elementOuterHeight;
+
+          if (top < 0) {
+            top = windowScrollTop;
+          }
+
+          element.style.transformOrigin = 'bottom';
+        } else {
+          top = targetOuterHeight + targetOffset.top + windowScrollTop;
+          element.style.transformOrigin = 'top';
+        }
+
+        if (targetOffset.left + targetOuterWidth + elementOuterWidth > viewport.width) left = Math.max(0, targetOffset.left + windowScrollLeft + targetOuterWidth - elementOuterWidth);else left = targetOffset.left + windowScrollLeft;
+        element.style.top = top + 'px';
+        element.style.left = left + 'px';
+      }
+    }
+  }, {
+    key: "relativePosition",
+    value: function relativePosition(element, target) {
+      if (element) {
+        var elementDimensions = element.offsetParent ? {
+          width: element.offsetWidth,
+          height: element.offsetHeight
+        } : this.getHiddenElementDimensions(element);
+        var targetHeight = target.offsetHeight;
+        var targetOffset = target.getBoundingClientRect();
+        var viewport = this.getViewport();
+        var top, left;
+
+        if (targetOffset.top + targetHeight + elementDimensions.height > viewport.height) {
+          top = -1 * elementDimensions.height;
+
+          if (targetOffset.top + top < 0) {
+            top = -1 * targetOffset.top;
+          }
+
+          element.style.transformOrigin = 'bottom';
+        } else {
+          top = targetHeight;
+          element.style.transformOrigin = 'top';
+        }
+
+        if (elementDimensions.width > viewport.width) {
+          // element wider then viewport and cannot fit on screen (align at left side of viewport)
+          left = targetOffset.left * -1;
+        } else if (targetOffset.left + elementDimensions.width > viewport.width) {
+          // element wider then viewport but can be fit on screen (align at right side of viewport)
+          left = (targetOffset.left + elementDimensions.width - viewport.width) * -1;
+        } else {
+          // element fits on screen (align with target)
+          left = 0;
+        }
+
+        element.style.top = top + 'px';
+        element.style.left = left + 'px';
+      }
+    }
+  }, {
+    key: "flipfitCollision",
+    value: function flipfitCollision(element, target) {
+      var _this = this;
+
+      var my = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'left top';
+      var at = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 'left bottom';
+      var callback = arguments.length > 4 ? arguments[4] : undefined;
+      var targetOffset = target.getBoundingClientRect();
+      var viewport = this.getViewport();
+      var myArr = my.split(' ');
+      var atArr = at.split(' ');
+
+      var getPositionValue = function getPositionValue(arr, isOffset) {
+        return isOffset ? +arr.substring(arr.search(/(\+|-)/g)) || 0 : arr.substring(0, arr.search(/(\+|-)/g)) || arr;
+      };
+
+      var position = {
+        my: {
+          x: getPositionValue(myArr[0]),
+          y: getPositionValue(myArr[1] || myArr[0]),
+          offsetX: getPositionValue(myArr[0], true),
+          offsetY: getPositionValue(myArr[1] || myArr[0], true)
+        },
+        at: {
+          x: getPositionValue(atArr[0]),
+          y: getPositionValue(atArr[1] || atArr[0]),
+          offsetX: getPositionValue(atArr[0], true),
+          offsetY: getPositionValue(atArr[1] || atArr[0], true)
+        }
+      };
+      var myOffset = {
+        left: function left() {
+          var totalOffset = position.my.offsetX + position.at.offsetX;
+          return totalOffset + targetOffset.left + (position.my.x === 'left' ? 0 : -1 * (position.my.x === 'center' ? _this.getOuterWidth(element) / 2 : _this.getOuterWidth(element)));
+        },
+        top: function top() {
+          var totalOffset = position.my.offsetY + position.at.offsetY;
+          return totalOffset + targetOffset.top + (position.my.y === 'top' ? 0 : -1 * (position.my.y === 'center' ? _this.getOuterHeight(element) / 2 : _this.getOuterHeight(element)));
+        }
+      };
+      var alignWithAt = {
+        count: {
+          x: 0,
+          y: 0
+        },
+        left: function left() {
+          var left = myOffset.left();
+          var scrollLeft = DomHandler.getWindowScrollLeft();
+          element.style.left = left + scrollLeft + 'px';
+
+          if (this.count.x === 2) {
+            element.style.left = scrollLeft + 'px';
+            this.count.x = 0;
+          } else if (left < 0) {
+            this.count.x++;
+            position.my.x = 'left';
+            position.at.x = 'right';
+            position.my.offsetX *= -1;
+            position.at.offsetX *= -1;
+            this.right();
+          }
+        },
+        right: function right() {
+          var left = myOffset.left() + DomHandler.getOuterWidth(target);
+          var scrollLeft = DomHandler.getWindowScrollLeft();
+          element.style.left = left + scrollLeft + 'px';
+
+          if (this.count.x === 2) {
+            element.style.left = viewport.width - DomHandler.getOuterWidth(element) + scrollLeft + 'px';
+            this.count.x = 0;
+          } else if (left + DomHandler.getOuterWidth(element) > viewport.width) {
+            this.count.x++;
+            position.my.x = 'right';
+            position.at.x = 'left';
+            position.my.offsetX *= -1;
+            position.at.offsetX *= -1;
+            this.left();
+          }
+        },
+        top: function top() {
+          var top = myOffset.top();
+          var scrollTop = DomHandler.getWindowScrollTop();
+          element.style.top = top + scrollTop + 'px';
+
+          if (this.count.y === 2) {
+            element.style.left = scrollTop + 'px';
+            this.count.y = 0;
+          } else if (top < 0) {
+            this.count.y++;
+            position.my.y = 'top';
+            position.at.y = 'bottom';
+            position.my.offsetY *= -1;
+            position.at.offsetY *= -1;
+            this.bottom();
+          }
+        },
+        bottom: function bottom() {
+          var top = myOffset.top() + DomHandler.getOuterHeight(target);
+          var scrollTop = DomHandler.getWindowScrollTop();
+          element.style.top = top + scrollTop + 'px';
+
+          if (this.count.y === 2) {
+            element.style.left = viewport.height - DomHandler.getOuterHeight(element) + scrollTop + 'px';
+            this.count.y = 0;
+          } else if (top + DomHandler.getOuterHeight(target) > viewport.height) {
+            this.count.y++;
+            position.my.y = 'bottom';
+            position.at.y = 'top';
+            position.my.offsetY *= -1;
+            position.at.offsetY *= -1;
+            this.top();
+          }
+        },
+        center: function center(axis) {
+          if (axis === 'y') {
+            var top = myOffset.top() + DomHandler.getOuterHeight(target) / 2;
+            element.style.top = top + DomHandler.getWindowScrollTop() + 'px';
+
+            if (top < 0) {
+              this.bottom();
+            } else if (top + DomHandler.getOuterHeight(target) > viewport.height) {
+              this.top();
+            }
+          } else {
+            var left = myOffset.left() + DomHandler.getOuterWidth(target) / 2;
+            element.style.left = left + DomHandler.getWindowScrollLeft() + 'px';
+
+            if (left < 0) {
+              this.left();
+            } else if (left + DomHandler.getOuterWidth(element) > viewport.width) {
+              this.right();
+            }
+          }
+        }
+      };
+      alignWithAt[position.at.x]('x');
+      alignWithAt[position.at.y]('y');
+
+      if (this.isFunction(callback)) {
+        callback(position);
+      }
+    }
+  }, {
+    key: "findCollisionPosition",
+    value: function findCollisionPosition(position) {
+      if (position) {
+        var isAxisY = position === 'top' || position === 'bottom';
+        var myXPosition = position === 'left' ? 'right' : 'left';
+        var myYPosition = position === 'top' ? 'bottom' : 'top';
+
+        if (isAxisY) {
+          return {
+            axis: 'y',
+            my: "center ".concat(myYPosition),
+            at: "center ".concat(position)
+          };
+        }
+
+        return {
+          axis: 'x',
+          my: "".concat(myXPosition, " center"),
+          at: "".concat(position, " center")
+        };
+      }
+    }
+  }, {
+    key: "getParents",
+    value: function getParents(element) {
+      var parents = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+      return element['parentNode'] === null ? parents : this.getParents(element.parentNode, parents.concat([element.parentNode]));
+    }
+  }, {
+    key: "getScrollableParents",
+    value: function getScrollableParents(element) {
+      var scrollableParents = [];
+
+      if (element) {
+        var parents = this.getParents(element);
+        var overflowRegex = /(auto|scroll)/;
+
+        var overflowCheck = function overflowCheck(node) {
+          var styleDeclaration = node ? getComputedStyle(node) : null;
+          return styleDeclaration && (overflowRegex.test(styleDeclaration.getPropertyValue('overflow')) || overflowRegex.test(styleDeclaration.getPropertyValue('overflowX')) || overflowRegex.test(styleDeclaration.getPropertyValue('overflowY')));
+        };
+
+        var _iterator = _createForOfIteratorHelper$3(parents),
+            _step;
+
+        try {
+          for (_iterator.s(); !(_step = _iterator.n()).done;) {
+            var parent = _step.value;
+            var scrollSelectors = parent.nodeType === 1 && parent.dataset['scrollselectors'];
+
+            if (scrollSelectors) {
+              var selectors = scrollSelectors.split(',');
+
+              var _iterator2 = _createForOfIteratorHelper$3(selectors),
+                  _step2;
+
+              try {
+                for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+                  var selector = _step2.value;
+                  var el = this.findSingle(parent, selector);
+
+                  if (el && overflowCheck(el)) {
+                    scrollableParents.push(el);
+                  }
+                }
+              } catch (err) {
+                _iterator2.e(err);
+              } finally {
+                _iterator2.f();
+              }
+            }
+
+            if (parent.nodeType !== 9 && overflowCheck(parent)) {
+              scrollableParents.push(parent);
+            }
+          }
+        } catch (err) {
+          _iterator.e(err);
+        } finally {
+          _iterator.f();
+        }
+      }
+
+      return scrollableParents;
+    }
+  }, {
+    key: "getHiddenElementOuterHeight",
+    value: function getHiddenElementOuterHeight(element) {
+      if (element) {
+        element.style.visibility = 'hidden';
+        element.style.display = 'block';
+        var elementHeight = element.offsetHeight;
+        element.style.display = 'none';
+        element.style.visibility = 'visible';
+        return elementHeight;
+      }
+
+      return 0;
+    }
+  }, {
+    key: "getHiddenElementOuterWidth",
+    value: function getHiddenElementOuterWidth(element) {
+      if (element) {
+        element.style.visibility = 'hidden';
+        element.style.display = 'block';
+        var elementWidth = element.offsetWidth;
+        element.style.display = 'none';
+        element.style.visibility = 'visible';
+        return elementWidth;
+      }
+
+      return 0;
+    }
+  }, {
+    key: "getHiddenElementDimensions",
+    value: function getHiddenElementDimensions(element) {
+      var dimensions = {};
+
+      if (element) {
+        element.style.visibility = 'hidden';
+        element.style.display = 'block';
+        dimensions.width = element.offsetWidth;
+        dimensions.height = element.offsetHeight;
+        element.style.display = 'none';
+        element.style.visibility = 'visible';
+      }
+
+      return dimensions;
+    }
+  }, {
+    key: "fadeIn",
+    value: function fadeIn(element, duration) {
+      if (element) {
+        element.style.opacity = 0;
+        var last = +new Date();
+        var opacity = 0;
+
+        var tick = function tick() {
+          opacity = +element.style.opacity + (new Date().getTime() - last) / duration;
+          element.style.opacity = opacity;
+          last = +new Date();
+
+          if (+opacity < 1) {
+            window.requestAnimationFrame && requestAnimationFrame(tick) || setTimeout(tick, 16);
+          }
+        };
+
+        tick();
+      }
+    }
+  }, {
+    key: "fadeOut",
+    value: function fadeOut(element, duration) {
+      if (element) {
+        var opacity = 1,
+            interval = 50,
+            gap = interval / duration;
+        var fading = setInterval(function () {
+          opacity -= gap;
+
+          if (opacity <= 0) {
+            opacity = 0;
+            clearInterval(fading);
+          }
+
+          element.style.opacity = opacity;
+        }, interval);
+      }
+    }
+  }, {
+    key: "getUserAgent",
+    value: function getUserAgent() {
+      return navigator.userAgent;
+    }
+  }, {
+    key: "isIOS",
+    value: function isIOS() {
+      return /iPad|iPhone|iPod/.test(navigator.userAgent) && !window['MSStream'];
+    }
+  }, {
+    key: "isAndroid",
+    value: function isAndroid() {
+      return /(android)/i.test(navigator.userAgent);
+    }
+  }, {
+    key: "isTouchDevice",
+    value: function isTouchDevice() {
+      return 'ontouchstart' in window || navigator.maxTouchPoints > 0 || navigator.msMaxTouchPoints > 0;
+    }
+  }, {
+    key: "isFunction",
+    value: function isFunction(obj) {
+      return !!(obj && obj.constructor && obj.call && obj.apply);
+    }
+  }, {
+    key: "appendChild",
+    value: function appendChild(element, target) {
+      if (this.isElement(target)) target.appendChild(element);else if (target.el && target.el.nativeElement) target.el.nativeElement.appendChild(element);else throw new Error('Cannot append ' + target + ' to ' + element);
+    }
+  }, {
+    key: "removeChild",
+    value: function removeChild(element, target) {
+      if (this.isElement(target)) target.removeChild(element);else if (target.el && target.el.nativeElement) target.el.nativeElement.removeChild(element);else throw new Error('Cannot remove ' + element + ' from ' + target);
+    }
+  }, {
+    key: "isElement",
+    value: function isElement(obj) {
+      return (typeof HTMLElement === "undefined" ? "undefined" : _typeof(HTMLElement)) === "object" ? obj instanceof HTMLElement : obj && _typeof(obj) === "object" && obj !== null && obj.nodeType === 1 && typeof obj.nodeName === "string";
+    }
+  }, {
+    key: "scrollInView",
+    value: function scrollInView(container, item) {
+      var borderTopValue = getComputedStyle(container).getPropertyValue('borderTopWidth');
+      var borderTop = borderTopValue ? parseFloat(borderTopValue) : 0;
+      var paddingTopValue = getComputedStyle(container).getPropertyValue('paddingTop');
+      var paddingTop = paddingTopValue ? parseFloat(paddingTopValue) : 0;
+      var containerRect = container.getBoundingClientRect();
+      var itemRect = item.getBoundingClientRect();
+      var offset = itemRect.top + document.body.scrollTop - (containerRect.top + document.body.scrollTop) - borderTop - paddingTop;
+      var scroll = container.scrollTop;
+      var elementHeight = container.clientHeight;
+      var itemHeight = this.getOuterHeight(item);
+
+      if (offset < 0) {
+        container.scrollTop = scroll + offset;
+      } else if (offset + itemHeight > elementHeight) {
+        container.scrollTop = scroll + offset - elementHeight + itemHeight;
+      }
+    }
+  }, {
+    key: "clearSelection",
+    value: function clearSelection() {
+      if (window.getSelection) {
+        if (window.getSelection().empty) {
+          window.getSelection().empty();
+        } else if (window.getSelection().removeAllRanges && window.getSelection().rangeCount > 0 && window.getSelection().getRangeAt(0).getClientRects().length > 0) {
+          window.getSelection().removeAllRanges();
+        }
+      } else if (document['selection'] && document['selection'].empty) {
+        try {
+          document['selection'].empty();
+        } catch (error) {//ignore IE bug
+        }
+      }
+    }
+  }, {
+    key: "calculateScrollbarWidth",
+    value: function calculateScrollbarWidth(el) {
+      if (el) {
+        var style = getComputedStyle(el);
+        return el.offsetWidth - el.clientWidth - parseFloat(style.borderLeftWidth) - parseFloat(style.borderRightWidth);
+      } else {
+        if (this.calculatedScrollbarWidth != null) return this.calculatedScrollbarWidth;
+        var scrollDiv = document.createElement("div");
+        scrollDiv.className = "p-scrollbar-measure";
+        document.body.appendChild(scrollDiv);
+        var scrollbarWidth = scrollDiv.offsetWidth - scrollDiv.clientWidth;
+        document.body.removeChild(scrollDiv);
+        this.calculatedScrollbarWidth = scrollbarWidth;
+        return scrollbarWidth;
+      }
+    }
+  }, {
+    key: "getBrowser",
+    value: function getBrowser() {
+      if (!this.browser) {
+        var matched = this.resolveUserAgent();
+        this.browser = {};
+
+        if (matched.browser) {
+          this.browser[matched.browser] = true;
+          this.browser['version'] = matched.version;
+        }
+
+        if (this.browser['chrome']) {
+          this.browser['webkit'] = true;
+        } else if (this.browser['webkit']) {
+          this.browser['safari'] = true;
+        }
+      }
+
+      return this.browser;
+    }
+  }, {
+    key: "resolveUserAgent",
+    value: function resolveUserAgent() {
+      var ua = navigator.userAgent.toLowerCase();
+      var match = /(chrome)[ ]([\w.]+)/.exec(ua) || /(webkit)[ ]([\w.]+)/.exec(ua) || /(opera)(?:.*version|)[ ]([\w.]+)/.exec(ua) || /(msie) ([\w.]+)/.exec(ua) || ua.indexOf("compatible") < 0 && /(mozilla)(?:.*? rv:([\w.]+)|)/.exec(ua) || [];
+      return {
+        browser: match[1] || "",
+        version: match[2] || "0"
+      };
+    }
+  }, {
+    key: "isVisible",
+    value: function isVisible(element) {
+      return element && element.offsetParent != null;
+    }
+  }, {
+    key: "isExist",
+    value: function isExist(element) {
+      return element !== null && typeof element !== 'undefined' && element.nodeName && element.parentNode;
+    }
+  }, {
+    key: "hasDOM",
+    value: function hasDOM() {
+      return !!(typeof window !== 'undefined' && window.document && window.document.createElement);
+    }
+  }, {
+    key: "getFocusableElements",
+    value: function getFocusableElements(element) {
+      var selector = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+      var focusableElements = DomHandler.find(element, "button:not([tabindex = \"-1\"]):not([disabled]):not([style*=\"display:none\"]):not([hidden])".concat(selector, ",\n                [href][clientHeight][clientWidth]:not([tabindex = \"-1\"]):not([disabled]):not([style*=\"display:none\"]):not([hidden])").concat(selector, ",\n                input:not([tabindex = \"-1\"]):not([disabled]):not([style*=\"display:none\"]):not([hidden])").concat(selector, ",\n                select:not([tabindex = \"-1\"]):not([disabled]):not([style*=\"display:none\"]):not([hidden])").concat(selector, ",\n                textarea:not([tabindex = \"-1\"]):not([disabled]):not([style*=\"display:none\"]):not([hidden])").concat(selector, ",\n                [tabIndex]:not([tabIndex = \"-1\"]):not([disabled]):not([style*=\"display:none\"]):not([hidden])").concat(selector, ",\n                [contenteditable]:not([tabIndex = \"-1\"]):not([disabled]):not([style*=\"display:none\"]):not([hidden])").concat(selector));
+      var visibleFocusableElements = [];
+
+      var _iterator3 = _createForOfIteratorHelper$3(focusableElements),
+          _step3;
+
+      try {
+        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+          var focusableElement = _step3.value;
+          if (getComputedStyle(focusableElement).display !== "none" && getComputedStyle(focusableElement).visibility !== "hidden") visibleFocusableElements.push(focusableElement);
+        }
+      } catch (err) {
+        _iterator3.e(err);
+      } finally {
+        _iterator3.f();
+      }
+
+      return visibleFocusableElements;
+    }
+  }, {
+    key: "getFirstFocusableElement",
+    value: function getFirstFocusableElement(element, selector) {
+      var focusableElements = DomHandler.getFocusableElements(element, selector);
+      return focusableElements.length > 0 ? focusableElements[0] : null;
+    }
+  }, {
+    key: "getLastFocusableElement",
+    value: function getLastFocusableElement(element, selector) {
+      var focusableElements = DomHandler.getFocusableElements(element, selector);
+      return focusableElements.length > 0 ? focusableElements[focusableElements.length - 1] : null;
+    }
+  }, {
+    key: "getCursorOffset",
+    value: function getCursorOffset(el, prevText, nextText, currentText) {
+      if (el) {
+        var style = getComputedStyle(el);
+        var ghostDiv = document.createElement('div');
+        ghostDiv.style.position = 'absolute';
+        ghostDiv.style.top = '0px';
+        ghostDiv.style.left = '0px';
+        ghostDiv.style.visibility = 'hidden';
+        ghostDiv.style.pointerEvents = 'none';
+        ghostDiv.style.overflow = style.overflow;
+        ghostDiv.style.width = style.width;
+        ghostDiv.style.height = style.height;
+        ghostDiv.style.padding = style.padding;
+        ghostDiv.style.border = style.border;
+        ghostDiv.style.overflowWrap = style.overflowWrap;
+        ghostDiv.style.whiteSpace = style.whiteSpace;
+        ghostDiv.style.lineHeight = style.lineHeight;
+        ghostDiv.innerHTML = prevText.replace(/\r\n|\r|\n/g, '<br />');
+        var ghostSpan = document.createElement('span');
+        ghostSpan.textContent = currentText;
+        ghostDiv.appendChild(ghostSpan);
+        var text = document.createTextNode(nextText);
+        ghostDiv.appendChild(text);
+        document.body.appendChild(ghostDiv);
+        var offsetLeft = ghostSpan.offsetLeft,
+            offsetTop = ghostSpan.offsetTop,
+            clientHeight = ghostSpan.clientHeight;
+        document.body.removeChild(ghostDiv);
+        return {
+          left: Math.abs(offsetLeft - el.scrollLeft),
+          top: Math.abs(offsetTop - el.scrollTop) + clientHeight
+        };
+      }
+
+      return {
+        top: 'auto',
+        left: 'auto'
+      };
+    }
+  }, {
+    key: "invokeElementMethod",
+    value: function invokeElementMethod(element, methodName, args) {
+      element[methodName].apply(element, args);
+    }
+  }, {
+    key: "isClickable",
+    value: function isClickable(element) {
+      var targetNode = element.nodeName;
+      var parentNode = element.parentElement && element.parentElement.nodeName;
+      return targetNode === 'INPUT' || targetNode === 'TEXTAREA' || targetNode === 'BUTTON' || targetNode === 'A' || parentNode === 'INPUT' || parentNode === 'TEXTAREA' || parentNode === 'BUTTON' || parentNode === 'A' || this.hasClass(element, 'p-button') || this.hasClass(element.parentElement, 'p-button') || this.hasClass(element.parentElement, 'p-checkbox') || this.hasClass(element.parentElement, 'p-radiobutton');
+    }
+  }, {
+    key: "applyStyle",
+    value: function applyStyle(element, style) {
+      if (typeof style === 'string') {
+        element.style.cssText = this.style;
+      } else {
+        for (var prop in this.style) {
+          element.style[prop] = style[prop];
+        }
+      }
+    }
+  }, {
+    key: "exportCSV",
+    value: function exportCSV(csv, filename) {
+      var blob = new Blob([csv], {
+        type: 'application/csv;charset=utf-8;'
+      });
 
-      if (columns) {
-        if (this.hasColumnFilter(columns)) {
-          return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement("tr", null, columns.map(function (col, i) {
-            return _this7.renderHeaderCell(col, {
-              index: i,
-              filterOnly: false,
-              renderFilter: false
-            });
-          })), /*#__PURE__*/React.createElement("tr", null, columns.map(function (col, i) {
-            return _this7.renderHeaderCell(col, {
-              index: i,
-              filterOnly: true,
-              renderFilter: true
-            });
-          })));
+      if (window.navigator.msSaveOrOpenBlob) {
+        navigator.msSaveOrOpenBlob(blob, filename + '.csv');
+      } else {
+        var link = document.createElement("a");
+
+        if (link.download !== undefined) {
+          link.setAttribute('href', URL.createObjectURL(blob));
+          link.setAttribute('download', filename + '.csv');
+          link.style.display = 'none';
+          document.body.appendChild(link);
+          link.click();
+          document.body.removeChild(link);
         } else {
-          return /*#__PURE__*/React.createElement("tr", null, columns.map(function (col, i) {
-            return _this7.renderHeaderCell(col, {
-              index: i,
-              filterOnly: false,
-              renderFilter: false
-            });
-          }));
+          csv = 'data:text/csv;charset=utf-8,' + csv;
+          window.open(encodeURI(csv));
         }
-      } else {
-        return null;
       }
     }
+    /**
+     * Anytime an inline style is created check environment variable 'process.env.REACT_APP_CSS_NONCE'
+     * to set a CSP NONCE.
+     *
+     * @see https://github.com/primefaces/primereact/issues/2423
+     * @return HtmlStyleElement
+     */
+
   }, {
-    key: "render",
-    value: function render() {
-      var content = this.props.columnGroup ? this.renderColumnGroup() : this.renderColumns(this.props.columns);
-      return /*#__PURE__*/React.createElement("thead", {
-        className: "p-treetable-thead"
-      }, content);
+    key: "createInlineStyle",
+    value: function createInlineStyle() {
+      var styleElement = document.createElement('style');
+      var nonce = process.env.REACT_APP_CSS_NONCE;
+
+      if (nonce) {
+        styleElement.setAttribute('nonce', nonce);
+      }
+
+      document.head.appendChild(styleElement);
+      return styleElement;
     }
-  }], [{
-    key: "getDerivedStateFromProps",
-    value: function getDerivedStateFromProps(nextProps, prevState) {
-      return {
-        badgeVisible: nextProps.multiSortMeta && nextProps.multiSortMeta.length > 1
-      };
+    /**
+     * Remove a style element from the head and attempt to prevent DOM Exception on fast refresh.
+     *
+     * @see https://github.com/primefaces/primereact/issues/2469
+     * @param {HtmlStyleElement} styleElement the element to remove from head
+     */
+
+  }, {
+    key: "removeInlineStyle",
+    value: function removeInlineStyle(styleElement) {
+      if (this.isExist(styleElement)) {
+        try {
+          document.head.removeChild(styleElement);
+        } catch (error) {// style element may have already been removed in a fast refresh
+        }
+
+        styleElement = null;
+      }
+
+      return styleElement;
     }
   }]);
 
-  return TreeTableHeader;
-}(Component);
+  return DomHandler;
+}();
 
 function _extends() {
   _extends = Object.assign || function (target) {
@@ -669,7 +1638,7 @@ var TreeTableBodyCell = /*#__PURE__*/function (_Component) {
         clearTimeout(this.tabindexTimeout);
 
         if (this.state && this.state.editing) {
-          var focusable = DomHandler.findSingle(this.container, 'input');
+          var focusable = DomHandler$1.findSingle(this.container, 'input');
 
           if (focusable && document.activeElement !== focusable && !focusable.hasAttribute('data-isCellEditing')) {
             focusable.setAttribute('data-isCellEditing', true);
@@ -752,15 +1721,15 @@ var TreeTableBodyCell = /*#__PURE__*/function (_Component) {
   return TreeTableBodyCell;
 }(Component);
 
-function _createForOfIteratorHelper$1(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray$1(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+function _createForOfIteratorHelper$2(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray$2(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
 
-function _unsupportedIterableToArray$1(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$1(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$1(o, minLen); }
+function _unsupportedIterableToArray$2(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$2(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$2(o, minLen); }
 
-function _arrayLikeToArray$1(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+function _arrayLikeToArray$2(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
 
-function ownKeys$1(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+function ownKeys$2(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
 
-function _objectSpread$1(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys$1(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys$1(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+function _objectSpread$2(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys$2(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys$2(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
 
 function _createSuper$4(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$4(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
 
@@ -803,7 +1772,7 @@ var TreeTableRow = /*#__PURE__*/function (_Component) {
   }, {
     key: "expand",
     value: function expand(event) {
-      var expandedKeys = this.props.expandedKeys ? _objectSpread$1({}, this.props.expandedKeys) : {};
+      var expandedKeys = this.props.expandedKeys ? _objectSpread$2({}, this.props.expandedKeys) : {};
       expandedKeys[this.props.node.key] = true;
       this.props.onToggle({
         originalEvent: event,
@@ -814,7 +1783,7 @@ var TreeTableRow = /*#__PURE__*/function (_Component) {
   }, {
     key: "collapse",
     value: function collapse(event) {
-      var expandedKeys = _objectSpread$1({}, this.props.expandedKeys);
+      var expandedKeys = _objectSpread$2({}, this.props.expandedKeys);
 
       delete expandedKeys[this.props.node.key];
       this.props.onToggle({
@@ -846,107 +1815,7 @@ var TreeTableRow = /*#__PURE__*/function (_Component) {
     key: "onClick",
     value: function onClick(event) {
       if (this.props.onRowClick) {
-        this.props.onRowClick({
-          originalEvent: event,
-          node: this.props.node
-        });
-      }
-
-      var targetNode = event.target.nodeName;
-
-      if (targetNode === 'INPUT' || targetNode === 'BUTTON' || targetNode === 'A' || DomHandler.hasClass(event.target, 'p-clickable') || DomHandler.hasClass(event.target, 'p-treetable-toggler') || DomHandler.hasClass(event.target.parentElement, 'p-treetable-toggler')) {
-        return;
-      }
-
-      if ((this.isSingleSelectionMode() || this.isMultipleSelectionMode()) && this.props.node.selectable !== false) {
-        var selectionKeys;
-        var selected = this.isSelected();
-        var metaSelection = this.nodeTouched ? false : this.props.metaKeySelection;
-
-        if (metaSelection) {
-          var metaKey = event.metaKey || event.ctrlKey;
-
-          if (selected && metaKey) {
-            if (this.isSingleSelectionMode()) {
-              selectionKeys = null;
-            } else {
-              selectionKeys = _objectSpread$1({}, this.props.selectionKeys);
-              delete selectionKeys[this.props.node.key];
-            }
-
-            if (this.props.onUnselect) {
-              this.props.onUnselect({
-                originalEvent: event,
-                node: this.props.node
-              });
-            }
-          } else {
-            if (this.isSingleSelectionMode()) {
-              selectionKeys = this.props.node.key;
-            } else if (this.isMultipleSelectionMode()) {
-              selectionKeys = !metaKey ? {} : this.props.selectionKeys ? _objectSpread$1({}, this.props.selectionKeys) : {};
-              selectionKeys[this.props.node.key] = true;
-            }
-
-            if (this.props.onSelect) {
-              this.props.onSelect({
-                originalEvent: event,
-                node: this.props.node
-              });
-            }
-          }
-        } else {
-          if (this.isSingleSelectionMode()) {
-            if (selected) {
-              selectionKeys = null;
-
-              if (this.props.onUnselect) {
-                this.props.onUnselect({
-                  originalEvent: event,
-                  node: this.props.node
-                });
-              }
-            } else {
-              selectionKeys = this.props.node.key;
-
-              if (this.props.onSelect) {
-                this.props.onSelect({
-                  originalEvent: event,
-                  node: this.props.node
-                });
-              }
-            }
-          } else {
-            if (selected) {
-              selectionKeys = _objectSpread$1({}, this.props.selectionKeys);
-              delete selectionKeys[this.props.node.key];
-
-              if (this.props.onUnselect) {
-                this.props.onUnselect({
-                  originalEvent: event,
-                  node: this.props.node
-                });
-              }
-            } else {
-              selectionKeys = this.props.selectionKeys ? _objectSpread$1({}, this.props.selectionKeys) : {};
-              selectionKeys[this.props.node.key] = true;
-
-              if (this.props.onSelect) {
-                this.props.onSelect({
-                  originalEvent: event,
-                  node: this.props.node
-                });
-              }
-            }
-          }
-        }
-
-        if (this.props.onSelectionChange) {
-          this.props.onSelectionChange({
-            originalEvent: event,
-            value: selectionKeys
-          });
-        }
+        this.props.onRowClick(event, this.props.node);
       }
 
       this.nodeTouched = false;
@@ -960,7 +1829,7 @@ var TreeTableRow = /*#__PURE__*/function (_Component) {
     key: "onCheckboxChange",
     value: function onCheckboxChange(event) {
       var checked = this.isChecked();
-      var selectionKeys = this.props.selectionKeys ? _objectSpread$1({}, this.props.selectionKeys) : {};
+      var selectionKeys = this.props.selectionKeys ? _objectSpread$2({}, this.props.selectionKeys) : {};
 
       if (checked) {
         if (this.props.propagateSelectionDown) this.propagateDown(this.props.node, false, selectionKeys);else delete selectionKeys[this.props.node.key];
@@ -1007,17 +1876,17 @@ var TreeTableRow = /*#__PURE__*/function (_Component) {
         });
       }
 
-      DomHandler.clearSelection();
+      DomHandler$1.clearSelection();
     }
   }, {
     key: "onCheckboxFocus",
     value: function onCheckboxFocus() {
-      DomHandler.addClass(this.checkboxBox, 'p-focus');
+      DomHandler$1.addClass(this.checkboxBox, 'p-focus');
     }
   }, {
     key: "onCheckboxBlur",
     value: function onCheckboxBlur() {
-      DomHandler.removeClass(this.checkboxBox, 'p-focus');
+      DomHandler$1.removeClass(this.checkboxBox, 'p-focus');
     }
   }, {
     key: "propagateUp",
@@ -1027,7 +1896,7 @@ var TreeTableRow = /*#__PURE__*/function (_Component) {
       var checkedChildCount = 0;
       var childPartialSelected = false;
 
-      var _iterator = _createForOfIteratorHelper$1(this.props.node.children),
+      var _iterator = _createForOfIteratorHelper$2(this.props.node.children),
           _step;
 
       try {
@@ -1081,7 +1950,7 @@ var TreeTableRow = /*#__PURE__*/function (_Component) {
   }, {
     key: "onRightClick",
     value: function onRightClick(event) {
-      DomHandler.clearSelection();
+      DomHandler$1.clearSelection();
 
       if (this.props.onContextMenuSelectionChange) {
         this.props.onContextMenuSelectionChange({
@@ -1152,16 +2021,6 @@ var TreeTableRow = /*#__PURE__*/function (_Component) {
         }
       }
     }
-  }, {
-    key: "isSingleSelectionMode",
-    value: function isSingleSelectionMode() {
-      return this.props.selectionMode && this.props.selectionMode === 'single';
-    }
-  }, {
-    key: "isMultipleSelectionMode",
-    value: function isMultipleSelectionMode() {
-      return this.props.selectionMode && this.props.selectionMode === 'multiple';
-    }
   }, {
     key: "isExpanded",
     value: function isExpanded() {
@@ -1316,7 +2175,7 @@ var TreeTableRow = /*#__PURE__*/function (_Component) {
 
       if (this.props.rowClassName) {
         var rowClassName = this.props.rowClassName(this.props.node);
-        className = _objectSpread$1(_objectSpread$1({}, className), rowClassName);
+        className = _objectSpread$2(_objectSpread$2({}, className), rowClassName);
       }
 
       className = classNames(className, this.props.node.className);
@@ -1362,6 +2221,16 @@ _defineProperty(TreeTableRow, "defaultProps", {
   onContextMenu: null
 });
 
+function ownKeys$1(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread$1(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys$1(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys$1(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _createForOfIteratorHelper$1(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray$1(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+
+function _unsupportedIterableToArray$1(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$1(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$1(o, minLen); }
+
+function _arrayLikeToArray$1(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
 function _createSuper$3(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$3(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
 
 function _isNativeReflectConstruct$3() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
@@ -1370,10 +2239,14 @@ var TreeTableBody = /*#__PURE__*/function (_Component) {
 
   var _super = _createSuper$3(TreeTableBody);
 
-  function TreeTableBody() {
+  function TreeTableBody(props) {
+    var _this;
+
     _classCallCheck(this, TreeTableBody);
 
-    return _super.apply(this, arguments);
+    _this = _super.call(this, props);
+    _this.onRowClick = _this.onRowClick.bind(_assertThisInitialized(_this));
+    return _this;
   }
 
   _createClass(TreeTableBody, [{
@@ -1394,7 +2267,7 @@ var TreeTableBody = /*#__PURE__*/function (_Component) {
         selectionKeys: this.props.selectionKeys,
         onSelectionChange: this.props.onSelectionChange,
         metaKeySelection: this.props.metaKeySelection,
-        onRowClick: this.props.onRowClick,
+        onRowClick: this.onRowClick,
         onSelect: this.props.onSelect,
         onUnselect: this.props.onUnselect,
         propagateSelectionUp: this.props.propagateSelectionUp,
@@ -1405,10 +2278,187 @@ var TreeTableBody = /*#__PURE__*/function (_Component) {
         onContextMenu: this.props.onContextMenu
       });
     }
+  }, {
+    key: "flattenizeTree",
+    value: function flattenizeTree(nodes) {
+      var rows = [];
+      nodes = nodes || this.props.value;
+
+      var _iterator = _createForOfIteratorHelper$1(nodes),
+          _step;
+
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var node = _step.value;
+          rows.push(node.key);
+
+          if (this.isExpandedKey(node.key)) {
+            rows = rows.concat(this.flattenizeTree(node.children));
+          }
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+
+      return rows;
+    }
+  }, {
+    key: "isExpandedKey",
+    value: function isExpandedKey(key) {
+      return this.props.expandedKeys && !!this.props.expandedKeys[key];
+    }
+  }, {
+    key: "onRowClick",
+    value: function onRowClick(event, node) {
+      var _this2 = this;
+
+      if (this.props.onRowClick) {
+        this.props.onRowClick({
+          originalEvent: event,
+          node: node
+        });
+      }
+
+      var targetNode = event.target.nodeName;
+
+      if (targetNode === 'INPUT' || targetNode === 'BUTTON' || targetNode === 'A' || DomHandler.hasClass(event.target, 'p-clickable') || DomHandler.hasClass(event.target, 'p-treetable-toggler') || DomHandler.hasClass(event.target.parentElement, 'p-treetable-toggler')) {
+        return;
+      }
+
+      if ((this.isSingleSelectionMode() || this.isMultipleSelectionMode()) && node.selectable !== false) {
+        var selectionKeys;
+        var selected = this.isSelected(node);
+        var metaSelection = this.nodeTouched ? false : this.props.metaKeySelection;
+        var flatKeys = this.flattenizeTree();
+        var rowIndex = flatKeys.findIndex(function (key) {
+          return key === node.key;
+        });
+
+        if (this.isMultipleSelectionMode() && event.shiftKey) {
+          DomHandler.clearSelection(); // find first selected row
+
+          var anchorRowIndex = flatKeys.findIndex(function (key) {
+            return _this2.props.selectionKeys[key];
+          });
+          var rangeStart = Math.min(rowIndex, anchorRowIndex);
+          var rangeEnd = Math.max(rowIndex, anchorRowIndex);
+          selectionKeys = _objectSpread$1({}, this.props.selectionKeys);
+
+          for (var i = rangeStart; i <= rangeEnd; i++) {
+            var rowKey = flatKeys[i];
+            selectionKeys[rowKey] = true;
+          }
+        } else {
+          this.anchorRowIndex = rowIndex;
+
+          if (metaSelection) {
+            var metaKey = event.metaKey || event.ctrlKey;
+
+            if (selected && metaKey) {
+              if (this.isSingleSelectionMode()) {
+                selectionKeys = null;
+              } else {
+                selectionKeys = _objectSpread$1({}, this.props.selectionKeys);
+                delete selectionKeys[node.key];
+              }
+
+              if (this.props.onUnselect) {
+                this.props.onUnselect({
+                  originalEvent: event,
+                  node: node
+                });
+              }
+            } else {
+              if (this.isSingleSelectionMode()) {
+                selectionKeys = node.key;
+              } else if (this.isMultipleSelectionMode()) {
+                selectionKeys = !metaKey ? {} : this.props.selectionKeys ? _objectSpread$1({}, this.props.selectionKeys) : {};
+                selectionKeys[node.key] = true;
+              }
+
+              if (this.props.onSelect) {
+                this.props.onSelect({
+                  originalEvent: event,
+                  node: node
+                });
+              }
+            }
+          } else {
+            if (this.isSingleSelectionMode()) {
+              if (selected) {
+                selectionKeys = null;
+
+                if (this.props.onUnselect) {
+                  this.props.onUnselect({
+                    originalEvent: event,
+                    node: node
+                  });
+                }
+              } else {
+                selectionKeys = node.key;
+
+                if (this.props.onSelect) {
+                  this.props.onSelect({
+                    originalEvent: event,
+                    node: node
+                  });
+                }
+              }
+            } else {
+              if (selected) {
+                selectionKeys = _objectSpread$1({}, this.props.selectionKeys);
+                delete selectionKeys[node.key];
+
+                if (this.props.onUnselect) {
+                  this.props.onUnselect({
+                    originalEvent: event,
+                    node: node
+                  });
+                }
+              } else {
+                selectionKeys = this.props.selectionKeys ? _objectSpread$1({}, this.props.selectionKeys) : {};
+                selectionKeys[node.key] = true;
+
+                if (this.props.onSelect) {
+                  this.props.onSelect({
+                    originalEvent: event,
+                    node: node
+                  });
+                }
+              }
+            }
+          }
+        }
+
+        if (this.props.onSelectionChange) {
+          this.props.onSelectionChange({
+            originalEvent: event,
+            value: selectionKeys
+          });
+        }
+      }
+    }
+  }, {
+    key: "isSingleSelectionMode",
+    value: function isSingleSelectionMode() {
+      return this.props.selectionMode && this.props.selectionMode === 'single';
+    }
+  }, {
+    key: "isMultipleSelectionMode",
+    value: function isMultipleSelectionMode() {
+      return this.props.selectionMode && this.props.selectionMode === 'multiple';
+    }
+  }, {
+    key: "isSelected",
+    value: function isSelected(node) {
+      if ((this.props.selectionMode === 'single' || this.props.selectionMode === 'multiple') && this.props.selectionKeys) return this.props.selectionMode === 'single' ? this.props.selectionKeys === node.key : this.props.selectionKeys[node.key] !== undefined;else return false;
+    }
   }, {
     key: "renderRows",
     value: function renderRows() {
-      var _this = this;
+      var _this3 = this;
 
       if (this.props.paginator && !this.props.lazy) {
         var rpp = this.props.rows || 0;
@@ -1424,7 +2474,7 @@ var TreeTableBody = /*#__PURE__*/function (_Component) {
         return rows;
       } else {
         return this.props.value.map(function (node, index) {
-          return _this.createRow(node, index);
+          return _this3.createRow(node, index);
         });
       }
     }
@@ -1435,10 +2485,11 @@ var TreeTableBody = /*#__PURE__*/function (_Component) {
         return null;
       } else {
         var colSpan = this.props.columns ? this.props.columns.length : null;
+        var content = this.props.emptyMessage || localeOption('emptyMessage');
         return /*#__PURE__*/React.createElement("tr", null, /*#__PURE__*/React.createElement("td", {
           className: "p-treetable-emptymessage",
           colSpan: colSpan
-        }, this.props.emptyMessage));
+        }, content));
       }
     }
   }, {
@@ -1469,7 +2520,7 @@ _defineProperty(TreeTableBody, "defaultProps", {
   propagateSelectionDown: true,
   lazy: false,
   rowClassName: null,
-  emptyMessage: "No records found",
+  emptyMessage: null,
   loading: false,
   onExpand: null,
   onCollapse: null,
@@ -1607,14 +2658,14 @@ var TreeTableScrollableView = /*#__PURE__*/function (_Component) {
       this.setScrollHeight();
 
       if (!this.props.frozen) {
-        var scrollBarWidth = DomHandler.calculateScrollbarWidth();
+        var scrollBarWidth = DomHandler$1.calculateScrollbarWidth();
         this.scrollHeaderBox.style.marginRight = scrollBarWidth + 'px';
 
         if (this.scrollFooterBox) {
           this.scrollFooterBox.style.marginRight = scrollBarWidth + 'px';
         }
       } else {
-        this.scrollBody.style.paddingBottom = DomHandler.calculateScrollbarWidth() + 'px';
+        this.scrollBody.style.paddingBottom = DomHandler$1.calculateScrollbarWidth() + 'px';
       }
     }
   }, {
@@ -1631,8 +2682,8 @@ var TreeTableScrollableView = /*#__PURE__*/function (_Component) {
           this.scrollBody.style.visibility = 'hidden';
           this.scrollBody.style.height = '100px'; //temporary height to calculate static height
 
-          var containerHeight = DomHandler.getOuterHeight(datatableContainer);
-          var relativeHeight = DomHandler.getOuterHeight(datatableContainer.parentElement) * parseInt(this.props.scrollHeight, 10) / 100;
+          var containerHeight = DomHandler$1.getOuterHeight(datatableContainer);
+          var relativeHeight = DomHandler$1.getOuterHeight(datatableContainer.parentElement) * parseInt(this.props.scrollHeight, 10) / 100;
           var staticHeight = containerHeight - 100; //total height of headers, footers, paginators
 
           var scrollBodyHeight = relativeHeight - staticHeight;
@@ -1650,7 +2701,7 @@ var TreeTableScrollableView = /*#__PURE__*/function (_Component) {
       if (element) {
         var el = element;
 
-        while (el && !DomHandler.hasClass(el, 'p-treetable')) {
+        while (el && !DomHandler$1.hasClass(el, 'p-treetable')) {
           el = el.parentElement;
         }
 
@@ -1671,7 +2722,7 @@ var TreeTableScrollableView = /*#__PURE__*/function (_Component) {
       var frozenScrollBody;
 
       if (frozenView) {
-        frozenScrollBody = DomHandler.findSingle(frozenView, '.p-treetable-scrollable-body');
+        frozenScrollBody = DomHandler$1.findSingle(frozenView, '.p-treetable-scrollable-body');
       }
 
       this.scrollHeaderBox.style.marginLeft = -1 * this.scrollBody.scrollLeft + 'px';
@@ -1687,10 +2738,10 @@ var TreeTableScrollableView = /*#__PURE__*/function (_Component) {
   }, {
     key: "calculateRowHeight",
     value: function calculateRowHeight() {
-      var row = DomHandler.findSingle(this.scrollTable, 'tr:not(.p-treetable-emptymessage-row)');
+      var row = DomHandler$1.findSingle(this.scrollTable, 'tr:not(.p-treetable-emptymessage-row)');
 
       if (row) {
-        this.rowHeight = DomHandler.getOuterHeight(row);
+        this.rowHeight = DomHandler$1.getOuterHeight(row);
       }
     }
   }, {
@@ -2097,7 +3148,7 @@ var TreeTable = /*#__PURE__*/function (_Component) {
   }, {
     key: "onColumnResizeStart",
     value: function onColumnResizeStart(event) {
-      var containerLeft = DomHandler.getOffset(this.container).left;
+      var containerLeft = DomHandler$1.getOffset(this.container).left;
       this.resizeColumn = event.columnEl;
       this.resizeColumnProps = event.column;
       this.columnResizing = true;
@@ -2107,8 +3158,8 @@ var TreeTable = /*#__PURE__*/function (_Component) {
   }, {
     key: "onColumnResize",
     value: function onColumnResize(event) {
-      var containerLeft = DomHandler.getOffset(this.container).left;
-      DomHandler.addClass(this.container, 'p-unselectable-text');
+      var containerLeft = DomHandler$1.getOffset(this.container).left;
+      DomHandler$1.addClass(this.container, 'p-unselectable-text');
       this.resizerHelper.style.height = this.container.offsetHeight + 'px';
       this.resizerHelper.style.top = 0 + 'px';
       this.resizerHelper.style.left = event.pageX - containerLeft + this.container.scrollLeft + 'px';
@@ -2130,10 +3181,10 @@ var TreeTable = /*#__PURE__*/function (_Component) {
           if (newColumnWidth > 15 && nextColumnWidth > 15) {
             if (this.props.scrollable) {
               var scrollableView = this.findParentScrollableView(this.resizeColumn);
-              var scrollableBodyTable = DomHandler.findSingle(scrollableView, 'table.p-treetable-scrollable-body-table');
-              var scrollableHeaderTable = DomHandler.findSingle(scrollableView, 'table.p-treetable-scrollable-header-table');
-              var scrollableFooterTable = DomHandler.findSingle(scrollableView, 'table.p-treetable-scrollable-footer-table');
-              var resizeColumnIndex = DomHandler.index(this.resizeColumn);
+              var scrollableBodyTable = DomHandler$1.findSingle(scrollableView, 'table.p-treetable-scrollable-body-table');
+              var scrollableHeaderTable = DomHandler$1.findSingle(scrollableView, 'table.p-treetable-scrollable-header-table');
+              var scrollableFooterTable = DomHandler$1.findSingle(scrollableView, 'table.p-treetable-scrollable-footer-table');
+              var resizeColumnIndex = DomHandler$1.index(this.resizeColumn);
               this.resizeColGroup(scrollableHeaderTable, resizeColumnIndex, newColumnWidth, nextColumnWidth);
               this.resizeColGroup(scrollableBodyTable, resizeColumnIndex, newColumnWidth, nextColumnWidth);
               this.resizeColGroup(scrollableFooterTable, resizeColumnIndex, newColumnWidth, nextColumnWidth);
@@ -2149,11 +3200,11 @@ var TreeTable = /*#__PURE__*/function (_Component) {
           if (this.props.scrollable) {
             var _scrollableView = this.findParentScrollableView(this.resizeColumn);
 
-            var _scrollableBodyTable = DomHandler.findSingle(_scrollableView, 'table.p-treetable-scrollable-body-table');
+            var _scrollableBodyTable = DomHandler$1.findSingle(_scrollableView, 'table.p-treetable-scrollable-body-table');
 
-            var _scrollableHeaderTable = DomHandler.findSingle(_scrollableView, 'table.p-treetable-scrollable-header-table');
+            var _scrollableHeaderTable = DomHandler$1.findSingle(_scrollableView, 'table.p-treetable-scrollable-header-table');
 
-            var _scrollableFooterTable = DomHandler.findSingle(_scrollableView, 'table.p-treetable-scrollable-footer-table');
+            var _scrollableFooterTable = DomHandler$1.findSingle(_scrollableView, 'table.p-treetable-scrollable-footer-table');
 
             _scrollableBodyTable.style.width = _scrollableBodyTable.offsetWidth + delta + 'px';
             _scrollableHeaderTable.style.width = _scrollableHeaderTable.offsetWidth + delta + 'px';
@@ -2162,7 +3213,7 @@ var TreeTable = /*#__PURE__*/function (_Component) {
               _scrollableFooterTable.style.width = _scrollableHeaderTable.offsetWidth + delta + 'px';
             }
 
-            var _resizeColumnIndex = DomHandler.index(this.resizeColumn);
+            var _resizeColumnIndex = DomHandler$1.index(this.resizeColumn);
 
             this.resizeColGroup(_scrollableHeaderTable, _resizeColumnIndex, newColumnWidth, null);
             this.resizeColGroup(_scrollableBodyTable, _resizeColumnIndex, newColumnWidth, null);
@@ -2185,7 +3236,7 @@ var TreeTable = /*#__PURE__*/function (_Component) {
       this.resizerHelper.style.display = 'none';
       this.resizeColumn = null;
       this.resizeColumnProps = null;
-      DomHandler.removeClass(this.container, 'p-unselectable-text');
+      DomHandler$1.removeClass(this.container, 'p-unselectable-text');
       this.unbindColumnResizeEvents();
     }
   }, {
@@ -2194,7 +3245,7 @@ var TreeTable = /*#__PURE__*/function (_Component) {
       if (column) {
         var parent = column.parentElement;
 
-        while (parent && !DomHandler.hasClass(parent, 'p-treetable-scrollable-view')) {
+        while (parent && !DomHandler$1.hasClass(parent, 'p-treetable-scrollable-view')) {
           parent = parent.parentElement;
         }
 
@@ -2257,8 +3308,8 @@ var TreeTable = /*#__PURE__*/function (_Component) {
         return;
       }
 
-      this.iconWidth = DomHandler.getHiddenElementOuterWidth(this.reorderIndicatorUp);
-      this.iconHeight = DomHandler.getHiddenElementOuterHeight(this.reorderIndicatorUp);
+      this.iconWidth = DomHandler$1.getHiddenElementOuterWidth(this.reorderIndicatorUp);
+      this.iconHeight = DomHandler$1.getHiddenElementOuterHeight(this.reorderIndicatorUp);
       this.draggedColumnEl = this.findParentHeader(event.currentTarget);
       this.draggedColumn = column;
       event.dataTransfer.setData('text', 'b'); // Firefox requires this to make dragging possible
@@ -2271,8 +3322,8 @@ var TreeTable = /*#__PURE__*/function (_Component) {
 
       if (this.props.reorderableColumns && this.draggedColumnEl && dropHeader) {
         event.preventDefault();
-        var containerOffset = DomHandler.getOffset(this.container);
-        var dropHeaderOffset = DomHandler.getOffset(dropHeader);
+        var containerOffset = DomHandler$1.getOffset(this.container);
+        var dropHeaderOffset = DomHandler$1.getOffset(dropHeader);
 
         if (this.draggedColumnEl !== dropHeader) {
           var targetLeft = dropHeaderOffset.left - containerOffset.left; //let targetTop =  containerOffset.top - dropHeaderOffset.top;
@@ -2317,8 +3368,8 @@ var TreeTable = /*#__PURE__*/function (_Component) {
       event.preventDefault();
 
       if (this.draggedColumnEl) {
-        var dragIndex = DomHandler.index(this.draggedColumnEl);
-        var dropIndex = DomHandler.index(this.findParentHeader(event.currentTarget));
+        var dragIndex = DomHandler$1.index(this.draggedColumnEl);
+        var dropIndex = DomHandler$1.index(this.findParentHeader(event.currentTarget));
         var allowDrop = dragIndex !== dropIndex;
 
         if (allowDrop && (dropIndex - dragIndex === 1 && this.dropPosition === -1 || dragIndex - dropIndex === 1 && this.dropPosition === 1)) {
@@ -3022,7 +4073,7 @@ _defineProperty(TreeTable, "defaultProps", {
   frozenWidth: null,
   resizableColumns: false,
   columnResizeMode: 'fit',
-  emptyMessage: "No records found",
+  emptyMessage: null,
   filters: null,
   globalFilter: null,
   filterMode: 'lenient',