@jetbrains/ring-ui 5.1.1 → 5.1.3

package/dist/tab-trap/tab-trap.d.ts

@@ -39,5 +39,5 @@ export default class TabTrap extends Component<TabTrapProps> {
     handleBlurIfWithoutFocus: (event: React.FocusEvent) => void;
     trapButtonNode?: HTMLElement | null;
     trapButtonRef: (node: HTMLElement | null) => void;
-    render(): JSX.Element;
+    render(): React.JSX.Element;
 }

package/dist/tab-trap/tab-trap.js

@@ -1,137 +1,170 @@
-import { _ as _defineProperty, a as _extends } from '../_helpers/_rollupPluginBabelHelpers.js';
+import { _ as _defineProperty, a as _inherits, b as _createSuper, c as _classCallCheck, k as _assertThisInitialized, m as _toConsumableArray, d as _createClass, e as _objectWithoutProperties, f as _extends } from '../_helpers/_rollupPluginBabelHelpers.js';
+import 'core-js/modules/es.array.concat.js';
+import 'core-js/modules/es.array.filter.js';
+import 'core-js/modules/es.object.to-string.js';
 import React, { Component } from 'react';
 import PropTypes from 'prop-types';
 import { isNodeInVisiblePartOfPage } from '../global/dom.js';
+import 'core-js/modules/es.object.assign.js';
+import 'core-js/modules/web.dom-collections.for-each.js';
+import 'core-js/modules/es.regexp.exec.js';
+import 'core-js/modules/es.string.split.js';
+import 'core-js/modules/es.object.entries.js';
+import 'core-js/modules/es.object.keys.js';
+import 'core-js/modules/es.array.iterator.js';
+import 'core-js/modules/es.set.js';
+import 'core-js/modules/es.string.iterator.js';
+import 'core-js/modules/web.dom-collections.iterator.js';
 
-var modules_6dce58ae = {"light":"light_rui_3588","trapButton":"trapButton_rui_3588"};
+var modules_6dce58ae = {"light":"light_rui_2ac4","trapButton":"trapButton_rui_3588"};
 
-const FOCUSABLE_ELEMENTS = 'input, button, select, textarea, a[href], *[tabindex]:not([data-trap-button]):not([data-scrollable-container])';
+var _excluded = ["children", "trapDisabled", "autoFocusFirst", "focusBackOnClose", "focusBackOnExit"];
+var FOCUSABLE_ELEMENTS = 'input, button, select, textarea, a[href], *[tabindex]:not([data-trap-button]):not([data-scrollable-container])';
 /**
  * @name TabTrap
  */
-class TabTrap extends Component {
-  constructor() {
+var TabTrap = /*#__PURE__*/function (_Component) {
+  _inherits(TabTrap, _Component);
+  var _super = _createSuper(TabTrap);
+  function TabTrap() {
     var _this;
-    super(...arguments);
-    _this = this;
-    _defineProperty(this, "previousFocusedNode", void 0);
-    _defineProperty(this, "trapWithoutFocus", void 0);
-    _defineProperty(this, "restoreFocus", () => {
-      const {
-        previousFocusedNode
-      } = this;
+    _classCallCheck(this, TabTrap);
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    _this = _super.call.apply(_super, [this].concat(args));
+    _defineProperty(_assertThisInitialized(_this), "previousFocusedNode", void 0);
+    _defineProperty(_assertThisInitialized(_this), "trapWithoutFocus", void 0);
+    _defineProperty(_assertThisInitialized(_this), "restoreFocus", function () {
+      var _assertThisInitialize = _assertThisInitialized(_this),
+        previousFocusedNode = _assertThisInitialize.previousFocusedNode;
       if (previousFocusedNode instanceof HTMLElement && previousFocusedNode.focus && isNodeInVisiblePartOfPage(previousFocusedNode)) {
         previousFocusedNode.focus({
           preventScroll: true
         });
       }
     });
-    _defineProperty(this, "node", void 0);
-    _defineProperty(this, "containerRef", node => {
+    _defineProperty(_assertThisInitialized(_this), "node", void 0);
+    _defineProperty(_assertThisInitialized(_this), "containerRef", function (node) {
       if (!node) {
         return;
       }
-      this.node = node;
+      _this.node = node;
     });
-    _defineProperty(this, "focusElement", function () {
-      let first = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
-      const {
-        node
-      } = _this;
+    _defineProperty(_assertThisInitialized(_this), "focusElement", function () {
+      var first = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
+      var _assertThisInitialize2 = _assertThisInitialized(_this),
+        node = _assertThisInitialize2.node;
       if (!node) {
         return;
       }
-      const tabables = [...node.querySelectorAll(FOCUSABLE_ELEMENTS)].filter(item => item.tabIndex >= 0);
-      const toBeFocused = first ? tabables[0] : tabables[tabables.length - 1];
+      var tabables = _toConsumableArray(node.querySelectorAll(FOCUSABLE_ELEMENTS)).filter(function (item) {
+        return item.tabIndex >= 0;
+      });
+      var toBeFocused = first ? tabables[0] : tabables[tabables.length - 1];
       if (toBeFocused) {
         toBeFocused.focus();
       }
     });
-    _defineProperty(this, "focusFirst", () => this.focusElement(true));
-    _defineProperty(this, "focusLast", () => this.focusElement(false));
-    _defineProperty(this, "focusLastIfEnabled", event => {
-      if (this.trapWithoutFocus) {
+    _defineProperty(_assertThisInitialized(_this), "focusFirst", function () {
+      return _this.focusElement(true);
+    });
+    _defineProperty(_assertThisInitialized(_this), "focusLast", function () {
+      return _this.focusElement(false);
+    });
+    _defineProperty(_assertThisInitialized(_this), "focusLastIfEnabled", function (event) {
+      if (_this.trapWithoutFocus) {
         return;
       }
-      if (this.props.focusBackOnExit) {
-        const prevFocused = event.nativeEvent.relatedTarget;
-        if (prevFocused != null && this.node != null && prevFocused instanceof Element && this.node.contains(prevFocused)) {
-          this.restoreFocus();
+      if (_this.props.focusBackOnExit) {
+        var prevFocused = event.nativeEvent.relatedTarget;
+        if (prevFocused != null && _this.node != null && prevFocused instanceof Element && _this.node.contains(prevFocused)) {
+          _this.restoreFocus();
         }
       } else {
-        this.focusLast();
+        _this.focusLast();
       }
     });
-    _defineProperty(this, "handleBlurIfWithoutFocus", event => {
-      if (!this.trapWithoutFocus) {
+    _defineProperty(_assertThisInitialized(_this), "handleBlurIfWithoutFocus", function (event) {
+      var _this$node;
+      if (!_this.trapWithoutFocus) {
         return;
       }
-      this.trapWithoutFocus = false;
-      const newFocused = event.nativeEvent.relatedTarget;
+      _this.trapWithoutFocus = false;
+      var newFocused = event.nativeEvent.relatedTarget;
       if (!newFocused) {
         return;
       }
-      if (newFocused instanceof Element && this.node?.contains(newFocused)) {
+      if (newFocused instanceof Element && (_this$node = _this.node) !== null && _this$node !== void 0 && _this$node.contains(newFocused)) {
         return;
       }
-      this.focusLast();
+      _this.focusLast();
     });
-    _defineProperty(this, "trapButtonNode", void 0);
-    _defineProperty(this, "trapButtonRef", node => {
+    _defineProperty(_assertThisInitialized(_this), "trapButtonNode", void 0);
+    _defineProperty(_assertThisInitialized(_this), "trapButtonRef", function (node) {
       if (!node) {
         return;
       }
-      this.trapButtonNode = node;
+      _this.trapButtonNode = node;
     });
+    return _this;
   }
-  componentDidMount() {
-    this.previousFocusedNode = document.activeElement;
-    if (this.props.autoFocusFirst) {
-      this.focusFirst();
-    } else if (!this.props.trapDisabled && (!this.node || !this.node.contains(this.previousFocusedNode))) {
-      this.trapWithoutFocus = true;
-      this.trapButtonNode?.focus();
+  _createClass(TabTrap, [{
+    key: "componentDidMount",
+    value: function componentDidMount() {
+      this.previousFocusedNode = document.activeElement;
+      if (this.props.autoFocusFirst) {
+        this.focusFirst();
+      } else if (!this.props.trapDisabled && (!this.node || !this.node.contains(this.previousFocusedNode))) {
+        var _this$trapButtonNode;
+        this.trapWithoutFocus = true;
+        (_this$trapButtonNode = this.trapButtonNode) === null || _this$trapButtonNode === void 0 ? void 0 : _this$trapButtonNode.focus();
+      }
     }
-  }
-  componentWillUnmount() {
-    if (this.props.focusBackOnClose) {
-      this.restoreFocus();
+  }, {
+    key: "componentWillUnmount",
+    value: function componentWillUnmount() {
+      if (this.props.focusBackOnClose) {
+        this.restoreFocus();
+      }
     }
-  }
-  render() {
-    const {
-      children,
-      trapDisabled,
-      autoFocusFirst,
-      focusBackOnClose,
-      focusBackOnExit,
-      ...restProps
-    } = this.props;
-    if (trapDisabled) {
+  }, {
+    key: "render",
+    value: function render() {
+      var _this$props = this.props,
+        children = _this$props.children,
+        trapDisabled = _this$props.trapDisabled;
+        _this$props.autoFocusFirst;
+        _this$props.focusBackOnClose;
+        var focusBackOnExit = _this$props.focusBackOnExit,
+        restProps = _objectWithoutProperties(_this$props, _excluded);
+      if (trapDisabled) {
+        return /*#__PURE__*/React.createElement("div", _extends({
+          ref: this.containerRef
+        }, restProps), children);
+      }
       return /*#__PURE__*/React.createElement("div", _extends({
         ref: this.containerRef
-      }, restProps), children);
+      }, restProps), /*#__PURE__*/React.createElement("div", {
+        // It never actually stays focused
+        // eslint-disable-next-line jsx-a11y/no-noninteractive-tabindex
+        tabIndex: 0,
+        ref: this.trapButtonRef,
+        className: modules_6dce58ae.trapButton,
+        onFocus: this.focusLastIfEnabled,
+        onBlur: this.handleBlurIfWithoutFocus,
+        "data-trap-button": true
+      }), children, /*#__PURE__*/React.createElement("div", {
+        // It never actually stays focused
+        // eslint-disable-next-line jsx-a11y/no-noninteractive-tabindex
+        tabIndex: 0,
+        onFocus: focusBackOnExit ? this.restoreFocus : this.focusFirst,
+        "data-trap-button": true
+      }));
     }
-    return /*#__PURE__*/React.createElement("div", _extends({
-      ref: this.containerRef
-    }, restProps), /*#__PURE__*/React.createElement("div", {
-      // It never actually stays focused
-      // eslint-disable-next-line jsx-a11y/no-noninteractive-tabindex
-      tabIndex: 0,
-      ref: this.trapButtonRef,
-      className: modules_6dce58ae.trapButton,
-      onFocus: this.focusLastIfEnabled,
-      onBlur: this.handleBlurIfWithoutFocus,
-      "data-trap-button": true
-    }), children, /*#__PURE__*/React.createElement("div", {
-      // It never actually stays focused
-      // eslint-disable-next-line jsx-a11y/no-noninteractive-tabindex
-      tabIndex: 0,
-      onFocus: focusBackOnExit ? this.restoreFocus : this.focusFirst,
-      "data-trap-button": true
-    }));
-  }
-}
+  }]);
+  return TabTrap;
+}(Component);
 _defineProperty(TabTrap, "propTypes", {
   children: PropTypes.node.isRequired,
   trapDisabled: PropTypes.bool,

package/dist/table/cell.d.ts

@@ -1,4 +1,4 @@
-import { PureComponent, TdHTMLAttributes } from 'react';
+import React, { PureComponent, TdHTMLAttributes } from 'react';
 import PropTypes from 'prop-types';
 export interface CellProps extends TdHTMLAttributes<HTMLTableDataCellElement> {
     'data-test'?: string | null | undefined;
@@ -9,5 +9,5 @@ export default class Cell extends PureComponent<CellProps> {
         className: PropTypes.Requireable<string>;
         'data-test': PropTypes.Requireable<string>;
     };
-    render(): JSX.Element;
+    render(): React.JSX.Element;
 }

package/dist/table/cell.js

@@ -1,19 +1,33 @@
-import { _ as _defineProperty, a as _extends } from '../_helpers/_rollupPluginBabelHelpers.js';
+import { _ as _defineProperty, a as _inherits, b as _createSuper, c as _classCallCheck, d as _createClass, f as _extends } from '../_helpers/_rollupPluginBabelHelpers.js';
 import React, { PureComponent } from 'react';
 import PropTypes from 'prop-types';
 import classNames from 'classnames';
 import joinDataTestAttributes from '../global/data-tests.js';
 import { m as modules_1db4bbca } from '../_helpers/table.js';
+import 'core-js/modules/es.array.reduce.js';
+import 'core-js/modules/es.object.to-string.js';
+import 'core-js/modules/es.object.entries.js';
+import 'core-js/modules/es.array.concat.js';
 
-class Cell extends PureComponent {
-  render() {
-    const classes = classNames(modules_1db4bbca.cell, this.props.className);
-    return /*#__PURE__*/React.createElement("td", _extends({}, this.props, {
-      className: classes,
-      "data-test": joinDataTestAttributes('ring-table-cell', this.props['data-test'])
-    }), this.props.children);
+var Cell = /*#__PURE__*/function (_PureComponent) {
+  _inherits(Cell, _PureComponent);
+  var _super = _createSuper(Cell);
+  function Cell() {
+    _classCallCheck(this, Cell);
+    return _super.apply(this, arguments);
   }
-}
+  _createClass(Cell, [{
+    key: "render",
+    value: function render() {
+      var classes = classNames(modules_1db4bbca.cell, this.props.className);
+      return /*#__PURE__*/React.createElement("td", _extends({}, this.props, {
+        className: classes,
+        "data-test": joinDataTestAttributes('ring-table-cell', this.props['data-test'])
+      }), this.props.children);
+    }
+  }]);
+  return Cell;
+}(PureComponent);
 _defineProperty(Cell, "propTypes", {
   children: PropTypes.any,
   className: PropTypes.string,

package/dist/table/disable-hover-hoc.d.ts

@@ -12,7 +12,7 @@ export default function disableHoverHOC<P extends DisableHoverAddProps>(Composed
         componentWillUnmount(): void;
         onMouseMove: () => void;
         onKeyDown: (e: KeyboardEvent) => void;
-        render(): JSX.Element;
+        render(): React.JSX.Element;
         context: unknown;
         setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<DisableHoverProps<P>>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
         forceUpdate(callback?: (() => void) | undefined): void;
@@ -39,7 +39,7 @@ export default function disableHoverHOC<P extends DisableHoverAddProps>(Composed
         componentWillUnmount(): void;
         onMouseMove: () => void;
         onKeyDown: (e: KeyboardEvent) => void;
-        render(): JSX.Element;
+        render(): React.JSX.Element;
         context: unknown;
         setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<DisableHoverProps<P>>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
         forceUpdate(callback?: (() => void) | undefined): void;

package/dist/table/disable-hover-hoc.js

@@ -1,44 +1,62 @@
-import { _ as _defineProperty, a as _extends } from '../_helpers/_rollupPluginBabelHelpers.js';
+import { _ as _defineProperty, a as _inherits, b as _createSuper, c as _classCallCheck, k as _assertThisInitialized, d as _createClass, f as _extends } from '../_helpers/_rollupPluginBabelHelpers.js';
+import 'core-js/modules/es.array.concat.js';
+import 'core-js/modules/es.array.includes.js';
 import React, { PureComponent } from 'react';
 
 function disableHoverHOC(ComposedComponent) {
   var _class;
-  return _class = class DisableHover extends PureComponent {
-    constructor() {
-      super(...arguments);
-      _defineProperty(this, "state", {
+  return _class = /*#__PURE__*/function (_PureComponent) {
+    _inherits(DisableHover, _PureComponent);
+    var _super = _createSuper(DisableHover);
+    function DisableHover() {
+      var _this;
+      _classCallCheck(this, DisableHover);
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      _this = _super.call.apply(_super, [this].concat(args));
+      _defineProperty(_assertThisInitialized(_this), "state", {
         disabledHover: false
       });
-      _defineProperty(this, "onMouseMove", () => {
-        if (this.state.disabledHover) {
-          this.setState({
+      _defineProperty(_assertThisInitialized(_this), "onMouseMove", function () {
+        if (_this.state.disabledHover) {
+          _this.setState({
             disabledHover: false
           });
         }
       });
-      _defineProperty(this, "onKeyDown", e => {
-        const metaKeys = [16, 17, 18, 19, 20, 91]; // eslint-disable-line @typescript-eslint/no-magic-numbers
-        if (!this.state.disabledHover && !metaKeys.includes(e.keyCode)) {
-          this.setState({
+      _defineProperty(_assertThisInitialized(_this), "onKeyDown", function (e) {
+        var metaKeys = [16, 17, 18, 19, 20, 91]; // eslint-disable-line @typescript-eslint/no-magic-numbers
+        if (!_this.state.disabledHover && !metaKeys.includes(e.keyCode)) {
+          _this.setState({
             disabledHover: true
           });
         }
       });
+      return _this;
     }
-    componentDidMount() {
-      document.addEventListener('mousemove', this.onMouseMove);
-      document.addEventListener('keydown', this.onKeyDown, true);
-    }
-    componentWillUnmount() {
-      document.removeEventListener('mousemove', this.onMouseMove);
-      document.removeEventListener('keydown', this.onKeyDown, true);
-    }
-    render() {
-      return /*#__PURE__*/React.createElement(ComposedComponent, _extends({}, this.props, {
-        disabledHover: this.state.disabledHover
-      }));
-    }
-  }, _defineProperty(_class, "propTypes", ComposedComponent.propTypes), _defineProperty(_class, "defaultProps", ComposedComponent.defaultProps), _class;
+    _createClass(DisableHover, [{
+      key: "componentDidMount",
+      value: function componentDidMount() {
+        document.addEventListener('mousemove', this.onMouseMove);
+        document.addEventListener('keydown', this.onKeyDown, true);
+      }
+    }, {
+      key: "componentWillUnmount",
+      value: function componentWillUnmount() {
+        document.removeEventListener('mousemove', this.onMouseMove);
+        document.removeEventListener('keydown', this.onKeyDown, true);
+      }
+    }, {
+      key: "render",
+      value: function render() {
+        return /*#__PURE__*/React.createElement(ComposedComponent, _extends({}, this.props, {
+          disabledHover: this.state.disabledHover
+        }));
+      }
+    }]);
+    return DisableHover;
+  }(PureComponent), _defineProperty(_class, "propTypes", ComposedComponent.propTypes), _defineProperty(_class, "defaultProps", ComposedComponent.defaultProps), _class;
 }
 
 export { disableHoverHOC as default };

package/dist/table/header-cell.d.ts

@@ -1,4 +1,4 @@
-import { PureComponent, ReactNode, SyntheticEvent, ThHTMLAttributes } from 'react';
+import React, { PureComponent, ReactNode, SyntheticEvent, ThHTMLAttributes } from 'react';
 import PropTypes from 'prop-types';
 export interface Column<T = never> {
     id: string;
@@ -39,5 +39,5 @@ export default class HeaderCell extends PureComponent<HeaderCellProps> {
     sorted?: boolean;
     onClick: () => void;
     onChildrenClick(e: SyntheticEvent): void;
-    render(): JSX.Element;
+    render(): React.JSX.Element;
 }

package/dist/table/header-cell.js

@@ -1,4 +1,5 @@
-import { _ as _defineProperty, a as _extends } from '../_helpers/_rollupPluginBabelHelpers.js';
+import { _ as _defineProperty, a as _inherits, b as _createSuper, c as _classCallCheck, k as _assertThisInitialized, d as _createClass, e as _objectWithoutProperties, f as _extends } from '../_helpers/_rollupPluginBabelHelpers.js';
+import 'core-js/modules/es.array.concat.js';
 import React, { PureComponent } from 'react';
 import PropTypes from 'prop-types';
 import classNames from 'classnames';
@@ -11,65 +12,84 @@ import 'util-deprecate';
 import '../icon/icon__constants.js';
 import '../_helpers/icon.js';
 import '../icon/icon__svg.js';
+import 'core-js/modules/es.regexp.exec.js';
+import 'core-js/modules/es.string.replace.js';
+import 'core-js/modules/es.string.starts-with.js';
 import '../global/memoize.js';
+import 'core-js/modules/es.array.iterator.js';
+import 'core-js/modules/es.map.js';
+import 'core-js/modules/es.object.to-string.js';
+import 'core-js/modules/es.string.iterator.js';
+import 'core-js/modules/web.dom-collections.iterator.js';
+import 'core-js/modules/es.weak-map.js';
+import 'core-js/modules/es.array.reduce.js';
+import 'core-js/modules/es.object.entries.js';
 
-class HeaderCell extends PureComponent {
-  constructor() {
-    super(...arguments);
-    _defineProperty(this, "sortable", void 0);
-    _defineProperty(this, "sorted", void 0);
-    _defineProperty(this, "onClick", () => {
-      if (this.sortable) {
-        const {
-          column,
-          onSort,
-          sortOrder
-        } = this.props;
+var _excluded = ["className", "column", "onSort", "sortKey", "sortOrder", "data-test"];
+var HeaderCell = /*#__PURE__*/function (_PureComponent) {
+  _inherits(HeaderCell, _PureComponent);
+  var _super = _createSuper(HeaderCell);
+  function HeaderCell() {
+    var _this;
+    _classCallCheck(this, HeaderCell);
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    _this = _super.call.apply(_super, [this].concat(args));
+    _defineProperty(_assertThisInitialized(_this), "sortable", void 0);
+    _defineProperty(_assertThisInitialized(_this), "sorted", void 0);
+    _defineProperty(_assertThisInitialized(_this), "onClick", function () {
+      if (_this.sortable) {
+        var _this$props = _this.props,
+          column = _this$props.column,
+          onSort = _this$props.onSort,
+          sortOrder = _this$props.sortOrder;
         onSort({
-          column,
-          order: !(this.sorted && sortOrder)
+          column: column,
+          order: !(_this.sorted && sortOrder)
         });
       }
     });
+    return _this;
   }
-  onChildrenClick(e) {
-    e.stopPropagation();
-  }
-  render() {
-    const {
-      className,
-      column,
-      onSort,
-      sortKey,
-      sortOrder,
-      'data-test': dataTest,
-      ...restProps
-    } = this.props;
-    this.sortable = column.sortable === true;
-    this.sorted = sortKey === column.id;
-    const glyph = this.sorted ? chevronDown : sortableIcon;
-    const classes = classNames(className, column.headerClassName, {
-      [modules_1db4bbca.headerCell]: true,
-      [modules_1db4bbca.headerCellSortable]: this.sortable,
-      [modules_1db4bbca.headerCellSorted]: this.sorted,
-      [modules_1db4bbca.sortedUp]: sortOrder && this.sorted,
-      [modules_1db4bbca.cellRight]: column.rightAlign
-    });
-    return /*#__PURE__*/React.createElement("th", _extends({}, restProps, {
-      className: classes,
-      onClick: this.onClick,
-      "data-test": joinDataTestAttributes('ring-table-header-cell', dataTest)
-    }), /*#__PURE__*/React.createElement("span", {
-      onClick: this.onChildrenClick,
-      role: "presentation"
-    }, this.props.children), column.getHeaderValue ? column.getHeaderValue() : column.title, this.sortable && /*#__PURE__*/React.createElement("span", {
-      className: modules_1db4bbca.sorter
-    }, /*#__PURE__*/React.createElement(Icon, {
-      glyph: glyph,
-      className: modules_1db4bbca.icon
-    })));
-  }
-}
+  _createClass(HeaderCell, [{
+    key: "onChildrenClick",
+    value: function onChildrenClick(e) {
+      e.stopPropagation();
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _classNames;
+      var _this$props2 = this.props,
+        className = _this$props2.className,
+        column = _this$props2.column;
+        _this$props2.onSort;
+        var sortKey = _this$props2.sortKey,
+        sortOrder = _this$props2.sortOrder,
+        dataTest = _this$props2['data-test'],
+        restProps = _objectWithoutProperties(_this$props2, _excluded);
+      this.sortable = column.sortable === true;
+      this.sorted = sortKey === column.id;
+      var glyph = this.sorted ? chevronDown : sortableIcon;
+      var classes = classNames(className, column.headerClassName, (_classNames = {}, _defineProperty(_classNames, modules_1db4bbca.headerCell, true), _defineProperty(_classNames, modules_1db4bbca.headerCellSortable, this.sortable), _defineProperty(_classNames, modules_1db4bbca.headerCellSorted, this.sorted), _defineProperty(_classNames, modules_1db4bbca.sortedUp, sortOrder && this.sorted), _defineProperty(_classNames, modules_1db4bbca.cellRight, column.rightAlign), _classNames));
+      return /*#__PURE__*/React.createElement("th", _extends({}, restProps, {
+        className: classes,
+        onClick: this.onClick,
+        "data-test": joinDataTestAttributes('ring-table-header-cell', dataTest)
+      }), /*#__PURE__*/React.createElement("span", {
+        onClick: this.onChildrenClick,
+        role: "presentation"
+      }, this.props.children), column.getHeaderValue ? column.getHeaderValue() : column.title, this.sortable && /*#__PURE__*/React.createElement("span", {
+        className: modules_1db4bbca.sorter
+      }, /*#__PURE__*/React.createElement(Icon, {
+        glyph: glyph,
+        className: modules_1db4bbca.icon
+      })));
+    }
+  }]);
+  return HeaderCell;
+}(PureComponent);
 _defineProperty(HeaderCell, "propTypes", {
   children: PropTypes.any,
   className: PropTypes.string,
@@ -80,7 +100,7 @@ _defineProperty(HeaderCell, "propTypes", {
   'data-test': PropTypes.string
 });
 _defineProperty(HeaderCell, "defaultProps", {
-  onSort: () => {}
+  onSort: function onSort() {}
 });
 
 export { HeaderCell as default };

package/dist/table/header.d.ts

@@ -1,6 +1,5 @@
-import { ChangeEventHandler, PureComponent, ReactNode, SyntheticEvent } from 'react';
+import React, { ChangeEventHandler, PureComponent, ReactNode, SyntheticEvent } from 'react';
 import PropTypes from 'prop-types';
-import { Waypoint } from 'react-waypoint';
 import { Column, SortParams } from './header-cell';
 export interface HeaderProps {
     columns: readonly Column[];
@@ -49,19 +48,9 @@ export default class Header extends PureComponent<HeaderProps> {
         sortKey: string;
         sortOrder: boolean;
     };
-    state: {
-        fixed: boolean;
-        headerWidth: undefined;
-        widths: never[];
-    };
     id: string;
     onCheckboxFocus: (event: SyntheticEvent<HTMLElement>) => void;
-    private _columnsRowNode?;
-    storeColumnsRowNode: (node: HTMLElement | null) => void;
-    onScrollIn: () => void;
-    onScrollOut: ({ currentPosition }: Waypoint.CallbackArgs) => void;
-    calculateColumnsWidths(columnsRowNode: HTMLElement | null | undefined): void;
-    createCells(widths?: never[]): JSX.Element[];
-    render(): JSX.Element;
+    createCells(widths?: never[]): React.JSX.Element[];
+    render(): React.JSX.Element;
 }
 export type HeaderAttrs = JSX.LibraryManagedAttributes<typeof Header, HeaderProps>;