@jetbrains/ring-ui 5.0.126 → 5.0.128

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

@@ -1,4 +1,4 @@
-import { _ as _defineProperty, a as _extends } from '../_helpers/_rollupPluginBabelHelpers.js';
+import { _ as _extends } from '../_helpers/_rollupPluginBabelHelpers.js';
 import React, { Component } from 'react';
 import PropTypes from 'prop-types';
 import { isNodeInVisiblePartOfPage } from '../global/dom.js';
@@ -10,30 +10,55 @@ const FOCUSABLE_ELEMENTS = 'input, button, select, textarea, a[href], *[tabindex
  * @name TabTrap
  */
 class TabTrap extends Component {
-  constructor() {
-    var _this;
-    super(...arguments);
-    _this = this;
-    _defineProperty(this, "previousFocusedNode", void 0);
-    _defineProperty(this, "trapWithoutFocus", void 0);
-    _defineProperty(this, "restoreFocus", () => {
-      const {
-        previousFocusedNode
-      } = this;
-      if (previousFocusedNode instanceof HTMLElement && previousFocusedNode.focus && isNodeInVisiblePartOfPage(previousFocusedNode)) {
-        previousFocusedNode.focus({
-          preventScroll: true
-        });
-      }
-    });
-    _defineProperty(this, "node", void 0);
-    _defineProperty(this, "containerRef", node => {
-      if (!node) {
-        return;
-      }
-      this.node = node;
-    });
-    _defineProperty(this, "focusElement", function () {
+  static propTypes = {
+    children: PropTypes.node.isRequired,
+    trapDisabled: PropTypes.bool,
+    autoFocusFirst: PropTypes.bool,
+    focusBackOnClose: PropTypes.bool,
+    focusBackOnExit: PropTypes.bool
+  };
+  static defaultProps = {
+    trapDisabled: false,
+    autoFocusFirst: true,
+    focusBackOnClose: true,
+    focusBackOnExit: false
+  };
+  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();
+    }
+  }
+  componentWillUnmount() {
+    if (this.props.focusBackOnClose) {
+      this.restoreFocus();
+    }
+  }
+  previousFocusedNode;
+  trapWithoutFocus;
+  restoreFocus = () => {
+    const {
+      previousFocusedNode
+    } = this;
+    if (previousFocusedNode instanceof HTMLElement && previousFocusedNode.focus && isNodeInVisiblePartOfPage(previousFocusedNode)) {
+      previousFocusedNode.focus({
+        preventScroll: true
+      });
+    }
+  };
+  node;
+  containerRef = node => {
+    if (!node) {
+      return;
+    }
+    this.node = node;
+  };
+  focusElement = (() => {
+    var _this = this;
+    return function () {
       let first = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
       const {
         node
@@ -46,58 +71,44 @@ class TabTrap extends Component {
       if (toBeFocused) {
         toBeFocused.focus();
       }
-    });
-    _defineProperty(this, "focusFirst", () => this.focusElement(true));
-    _defineProperty(this, "focusLast", () => this.focusElement(false));
-    _defineProperty(this, "focusLastIfEnabled", 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();
-        }
-      } else {
-        this.focusLast();
-      }
-    });
-    _defineProperty(this, "handleBlurIfWithoutFocus", event => {
-      if (!this.trapWithoutFocus) {
-        return;
-      }
-      this.trapWithoutFocus = false;
-      const newFocused = event.nativeEvent.relatedTarget;
-      if (!newFocused) {
-        return;
-      }
-      if (newFocused instanceof Element && this.node?.contains(newFocused)) {
-        return;
+    };
+  })();
+  focusFirst = () => this.focusElement(true);
+  focusLast = () => this.focusElement(false);
+  focusLastIfEnabled = 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();
       }
+    } else {
       this.focusLast();
-    });
-    _defineProperty(this, "trapButtonNode", void 0);
-    _defineProperty(this, "trapButtonRef", node => {
-      if (!node) {
-        return;
-      }
-      this.trapButtonNode = node;
-    });
-  }
-  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();
     }
-  }
-  componentWillUnmount() {
-    if (this.props.focusBackOnClose) {
-      this.restoreFocus();
+  };
+  handleBlurIfWithoutFocus = event => {
+    if (!this.trapWithoutFocus) {
+      return;
     }
-  }
+    this.trapWithoutFocus = false;
+    const newFocused = event.nativeEvent.relatedTarget;
+    if (!newFocused) {
+      return;
+    }
+    if (newFocused instanceof Element && this.node?.contains(newFocused)) {
+      return;
+    }
+    this.focusLast();
+  };
+  trapButtonNode;
+  trapButtonRef = node => {
+    if (!node) {
+      return;
+    }
+    this.trapButtonNode = node;
+  };
   render() {
     const {
       children,
@@ -132,18 +143,5 @@ class TabTrap extends Component {
     }));
   }
 }
-_defineProperty(TabTrap, "propTypes", {
-  children: PropTypes.node.isRequired,
-  trapDisabled: PropTypes.bool,
-  autoFocusFirst: PropTypes.bool,
-  focusBackOnClose: PropTypes.bool,
-  focusBackOnExit: PropTypes.bool
-});
-_defineProperty(TabTrap, "defaultProps", {
-  trapDisabled: false,
-  autoFocusFirst: true,
-  focusBackOnClose: true,
-  focusBackOnExit: false
-});
 
 export { FOCUSABLE_ELEMENTS, TabTrap as default };

package/dist/table/cell.js

@@ -1,4 +1,4 @@
-import { _ as _defineProperty, a as _extends } from '../_helpers/_rollupPluginBabelHelpers.js';
+import { _ as _extends } from '../_helpers/_rollupPluginBabelHelpers.js';
 import React, { PureComponent } from 'react';
 import PropTypes from 'prop-types';
 import classNames from 'classnames';
@@ -6,6 +6,11 @@ import joinDataTestAttributes from '../global/data-tests.js';
 import { m as modules_1db4bbca } from '../_helpers/table.js';
 
 class Cell extends PureComponent {
+  static propTypes = {
+    children: PropTypes.any,
+    className: PropTypes.string,
+    'data-test': PropTypes.string
+  };
   render() {
     const classes = classNames(modules_1db4bbca.cell, this.props.className);
     return /*#__PURE__*/React.createElement("td", _extends({}, this.props, {
@@ -14,10 +19,5 @@ class Cell extends PureComponent {
     }), this.props.children);
   }
 }
-_defineProperty(Cell, "propTypes", {
-  children: PropTypes.any,
-  className: PropTypes.string,
-  'data-test': PropTypes.string
-});
 
 export { Cell as default };

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

@@ -1,30 +1,13 @@
-import { _ as _defineProperty, a as _extends } from '../_helpers/_rollupPluginBabelHelpers.js';
+import { _ as _extends } from '../_helpers/_rollupPluginBabelHelpers.js';
 import React, { PureComponent } from 'react';
 
 function disableHoverHOC(ComposedComponent) {
-  var _class;
-  return _class = class DisableHover extends PureComponent {
-    constructor() {
-      super(...arguments);
-      _defineProperty(this, "state", {
-        disabledHover: false
-      });
-      _defineProperty(this, "onMouseMove", () => {
-        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({
-            disabledHover: true
-          });
-        }
-      });
-    }
+  return class DisableHover extends PureComponent {
+    static propTypes = ComposedComponent.propTypes;
+    static defaultProps = ComposedComponent.defaultProps;
+    state = {
+      disabledHover: false
+    };
     componentDidMount() {
       document.addEventListener('mousemove', this.onMouseMove);
       document.addEventListener('keydown', this.onKeyDown, true);
@@ -33,12 +16,27 @@ function disableHoverHOC(ComposedComponent) {
       document.removeEventListener('mousemove', this.onMouseMove);
       document.removeEventListener('keydown', this.onKeyDown, true);
     }
+    onMouseMove = () => {
+      if (this.state.disabledHover) {
+        this.setState({
+          disabledHover: false
+        });
+      }
+    };
+    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({
+          disabledHover: 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;
+  };
 }
 
 export { disableHoverHOC as default };

package/dist/table/header-cell.js

@@ -1,4 +1,4 @@
-import { _ as _defineProperty, a as _extends } from '../_helpers/_rollupPluginBabelHelpers.js';
+import { _ as _extends } from '../_helpers/_rollupPluginBabelHelpers.js';
 import React, { PureComponent } from 'react';
 import PropTypes from 'prop-types';
 import classNames from 'classnames';
@@ -14,24 +14,33 @@ import '../icon/icon__svg.js';
 import '../global/memoize.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;
-        onSort({
-          column,
-          order: !(this.sorted && sortOrder)
-        });
-      }
-    });
-  }
+  static propTypes = {
+    children: PropTypes.any,
+    className: PropTypes.string,
+    column: PropTypes.object.isRequired,
+    onSort: PropTypes.func,
+    sortKey: PropTypes.string,
+    sortOrder: PropTypes.bool,
+    'data-test': PropTypes.string
+  };
+  static defaultProps = {
+    onSort: () => {}
+  };
+  sortable;
+  sorted;
+  onClick = () => {
+    if (this.sortable) {
+      const {
+        column,
+        onSort,
+        sortOrder
+      } = this.props;
+      onSort({
+        column,
+        order: !(this.sorted && sortOrder)
+      });
+    }
+  };
   onChildrenClick(e) {
     e.stopPropagation();
   }
@@ -70,17 +79,5 @@ class HeaderCell extends PureComponent {
     })));
   }
 }
-_defineProperty(HeaderCell, "propTypes", {
-  children: PropTypes.any,
-  className: PropTypes.string,
-  column: PropTypes.object.isRequired,
-  onSort: PropTypes.func,
-  sortKey: PropTypes.string,
-  sortOrder: PropTypes.bool,
-  'data-test': PropTypes.string
-});
-_defineProperty(HeaderCell, "defaultProps", {
-  onSort: () => {}
-});
 
 export { HeaderCell as default };

package/dist/table/header.js

@@ -1,4 +1,4 @@
-import { _ as _defineProperty, a as _extends } from '../_helpers/_rollupPluginBabelHelpers.js';
+import { _ as _extends } from '../_helpers/_rollupPluginBabelHelpers.js';
 import React, { PureComponent } from 'react';
 import PropTypes from 'prop-types';
 import classNames from 'classnames';
@@ -23,43 +23,65 @@ import '@jetbrains/icons/chevron-10px';
 import '../global/data-tests.js';
 
 class Header extends PureComponent {
-  constructor() {
-    super(...arguments);
-    _defineProperty(this, "state", {
-      fixed: false,
-      headerWidth: undefined,
-      widths: []
-    });
-    _defineProperty(this, "id", getUID('table-header-'));
-    _defineProperty(this, "onCheckboxFocus", event => {
-      event.currentTarget.blur();
-    });
-    _defineProperty(this, "_columnsRowNode", void 0);
-    _defineProperty(this, "storeColumnsRowNode", node => {
-      if (node) {
-        this._columnsRowNode = node;
-        this.calculateColumnsWidths(node);
-      }
-    });
-    _defineProperty(this, "onScrollIn", () => {
-      this.calculateColumnsWidths(this._columnsRowNode);
-      this.setState({
-        fixed: false
-      });
+  static propTypes = {
+    caption: PropTypes.string,
+    selectable: PropTypes.bool,
+    draggable: PropTypes.bool,
+    checked: PropTypes.bool,
+    checkboxDisabled: PropTypes.bool,
+    sticky: PropTypes.bool,
+    topStickOffset: PropTypes.string,
+    onCheckboxChange: PropTypes.func,
+    columns: PropTypes.array.isRequired,
+    onSort: PropTypes.func,
+    sortKey: PropTypes.string,
+    sortOrder: PropTypes.bool
+  };
+  static defaultProps = {
+    selectable: true,
+    draggable: false,
+    checked: true,
+    sticky: true,
+    topStickOffset: '0px',
+    onSort: () => {},
+    onCheckboxChange: () => {},
+    sortKey: 'id',
+    sortOrder: true
+  };
+  state = {
+    fixed: false,
+    headerWidth: undefined,
+    widths: []
+  };
+  id = getUID('table-header-');
+  onCheckboxFocus = event => {
+    event.currentTarget.blur();
+  };
+  _columnsRowNode;
+  storeColumnsRowNode = node => {
+    if (node) {
+      this._columnsRowNode = node;
+      this.calculateColumnsWidths(node);
+    }
+  };
+  onScrollIn = () => {
+    this.calculateColumnsWidths(this._columnsRowNode);
+    this.setState({
+      fixed: false
     });
-    _defineProperty(this, "onScrollOut", _ref => {
-      let {
-        currentPosition
-      } = _ref;
-      if (currentPosition !== 'above') {
-        return;
-      }
-      this.calculateColumnsWidths(this._columnsRowNode);
-      this.setState({
-        fixed: true
-      });
+  };
+  onScrollOut = _ref => {
+    let {
+      currentPosition
+    } = _ref;
+    if (currentPosition !== 'above') {
+      return;
+    }
+    this.calculateColumnsWidths(this._columnsRowNode);
+    this.setState({
+      fixed: true
     });
-  }
+  };
   calculateColumnsWidths(columnsRowNode) {
     var _columnsRowNode$child;
     this.setState({
@@ -152,30 +174,5 @@ class Header extends PureComponent {
     }, this.createCells(widths)));
   }
 }
-_defineProperty(Header, "propTypes", {
-  caption: PropTypes.string,
-  selectable: PropTypes.bool,
-  draggable: PropTypes.bool,
-  checked: PropTypes.bool,
-  checkboxDisabled: PropTypes.bool,
-  sticky: PropTypes.bool,
-  topStickOffset: PropTypes.string,
-  onCheckboxChange: PropTypes.func,
-  columns: PropTypes.array.isRequired,
-  onSort: PropTypes.func,
-  sortKey: PropTypes.string,
-  sortOrder: PropTypes.bool
-});
-_defineProperty(Header, "defaultProps", {
-  selectable: true,
-  draggable: false,
-  checked: true,
-  sticky: true,
-  topStickOffset: '0px',
-  onSort: () => {},
-  onCheckboxChange: () => {},
-  sortKey: 'id',
-  sortOrder: true
-});
 
 export { Header as default };