@jetbrains/ring-ui 5.1.1 → 5.1.4

package/dist/table/selection.js

@@ -1,15 +1,34 @@
-import { _ as _defineProperty } from '../_helpers/_rollupPluginBabelHelpers.js';
+import { d as _createClass, m as _toConsumableArray, c as _classCallCheck, _ as _defineProperty } from '../_helpers/_rollupPluginBabelHelpers.js';
+import 'core-js/modules/es.array.iterator.js';
+import 'core-js/modules/es.object.to-string.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';
+import 'core-js/modules/es.array.filter.js';
+import 'core-js/modules/es.array.index-of.js';
 
-let Selection$1 = class Selection {
-  constructor() {
-    let {
-      data = [],
-      selected = new Set(),
-      focused = null,
-      getKey = item => item.id,
-      getChildren = () => [],
-      isItemSelectable = () => true
-    } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+var Selection = /*#__PURE__*/function () {
+  function Selection() {
+    var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+      _ref$data = _ref.data,
+      data = _ref$data === void 0 ? [] : _ref$data,
+      _ref$selected = _ref.selected,
+      selected = _ref$selected === void 0 ? new Set() : _ref$selected,
+      _ref$focused = _ref.focused,
+      focused = _ref$focused === void 0 ? null : _ref$focused,
+      _ref$getKey = _ref.getKey,
+      getKey = _ref$getKey === void 0 ? function (item) {
+        return item.id;
+      } : _ref$getKey,
+      _ref$getChildren = _ref.getChildren,
+      getChildren = _ref$getChildren === void 0 ? function () {
+        return [];
+      } : _ref$getChildren,
+      _ref$isItemSelectable = _ref.isItemSelectable,
+      isItemSelectable = _ref$isItemSelectable === void 0 ? function () {
+        return true;
+      } : _ref$isItemSelectable;
+    _classCallCheck(this, Selection);
     _defineProperty(this, "_rawData", void 0);
     _defineProperty(this, "_getChildren", void 0);
     _defineProperty(this, "_data", void 0);
@@ -25,164 +44,215 @@ let Selection$1 = class Selection {
     this._getKey = getKey;
     this._isItemSelectable = isItemSelectable;
   }
-  _buildData(data) {
-    return new Set(data);
-  }
-  _buildSelected(data, selected) {
-    return new Set(selected);
-  }
-  cloneWith(_ref) {
-    let {
-      data,
-      selected,
-      focused
-    } = _ref;
-    const newData = data || this._rawData;
-    let newSelected;
-    if (data && !selected) {
-      newSelected = new Set([...this._buildData(newData)].filter(item => [...this._selected].some(it => this._getKey(item) === this._getKey(it))));
-      newSelected = this._buildSelected(this._buildData(newData), newSelected);
-    } else if (selected) {
-      newSelected = selected;
-    } else {
-      newSelected = this._selected;
-    }
-    newSelected = new Set([...newSelected].filter(item => this._isItemSelectable(item)));
-    const cloneFocus = () => [...this._buildData(data)].filter(item => this._focused && this._getKey(item) === this._getKey(this._focused))[0];
-    const newFocused = focused === undefined ? this._focused : focused;
-    return new this.constructor({
-      data: newData,
-      selected: newSelected,
-      focused: data && !focused ? cloneFocus() : newFocused,
-      getKey: this._getKey,
-      getChildren: this._getChildren,
-      isItemSelectable: this._isItemSelectable
-    });
-  }
-  focus(value) {
-    return this.cloneWith({
-      focused: value
-    });
-  }
-  moveUp() {
-    const focused = this._focused;
-    const data = [...this._data];
-    if (!focused) {
+  _createClass(Selection, [{
+    key: "_buildData",
+    value: function _buildData(data) {
+      return new Set(data);
+    }
+  }, {
+    key: "_buildSelected",
+    value: function _buildSelected(data, selected) {
+      return new Set(selected);
+    }
+  }, {
+    key: "cloneWith",
+    value: function cloneWith(_ref2) {
+      var _this = this;
+      var data = _ref2.data,
+        selected = _ref2.selected,
+        focused = _ref2.focused;
+      var newData = data || this._rawData;
+      var newSelected;
+      if (data && !selected) {
+        newSelected = new Set(_toConsumableArray(this._buildData(newData)).filter(function (item) {
+          return _toConsumableArray(_this._selected).some(function (it) {
+            return _this._getKey(item) === _this._getKey(it);
+          });
+        }));
+        newSelected = this._buildSelected(this._buildData(newData), newSelected);
+      } else if (selected) {
+        newSelected = selected;
+      } else {
+        newSelected = this._selected;
+      }
+      newSelected = new Set(_toConsumableArray(newSelected).filter(function (item) {
+        return _this._isItemSelectable(item);
+      }));
+      var cloneFocus = function cloneFocus() {
+        return _toConsumableArray(_this._buildData(data)).filter(function (item) {
+          return _this._focused && _this._getKey(item) === _this._getKey(_this._focused);
+        })[0];
+      };
+      var newFocused = focused === undefined ? this._focused : focused;
+      return new this.constructor({
+        data: newData,
+        selected: newSelected,
+        focused: data && !focused ? cloneFocus() : newFocused,
+        getKey: this._getKey,
+        getChildren: this._getChildren,
+        isItemSelectable: this._isItemSelectable
+      });
+    }
+  }, {
+    key: "focus",
+    value: function focus(value) {
       return this.cloneWith({
-        focused: data[data.length - 1]
+        focused: value
       });
     }
-    const nextItem = data[data.indexOf(focused) - 1];
-    if (nextItem) {
+  }, {
+    key: "moveUp",
+    value: function moveUp() {
+      var focused = this._focused;
+      var data = _toConsumableArray(this._data);
+      if (!focused) {
+        return this.cloneWith({
+          focused: data[data.length - 1]
+        });
+      }
+      var nextItem = data[data.indexOf(focused) - 1];
+      if (nextItem) {
+        return this.cloneWith({
+          focused: nextItem
+        });
+      }
+      return undefined;
+    }
+  }, {
+    key: "moveDown",
+    value: function moveDown() {
+      var focused = this._focused;
+      var data = _toConsumableArray(this._data);
+      if (!focused) {
+        return this.cloneWith({
+          focused: data[0]
+        });
+      }
+      var nextItem = data[data.indexOf(focused) + 1];
+      if (nextItem) {
+        return this.cloneWith({
+          focused: nextItem
+        });
+      }
+      return undefined;
+    }
+  }, {
+    key: "moveStart",
+    value: function moveStart() {
+      var data = _toConsumableArray(this._data);
+      if (data.length) {
+        return this.cloneWith({
+          focused: data[0]
+        });
+      }
+      return undefined;
+    }
+  }, {
+    key: "moveEnd",
+    value: function moveEnd() {
+      var data = _toConsumableArray(this._data);
+      if (data.length) {
+        return this.cloneWith({
+          focused: data.pop()
+        });
+      }
+      return undefined;
+    }
+  }, {
+    key: "select",
+    value: function select() {
+      var value = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this._focused;
+      if (!value || !this._isItemSelectable(value)) {
+        return this;
+      }
+      var selected = new Set(this._selected);
+      selected.add(value);
       return this.cloneWith({
-        focused: nextItem
+        selected: selected
       });
     }
-    return undefined;
-  }
-  moveDown() {
-    const focused = this._focused;
-    const data = [...this._data];
-    if (!focused) {
+  }, {
+    key: "deselect",
+    value: function deselect() {
+      var value = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this._focused;
+      if (!value || !this._isItemSelectable(value)) {
+        return this;
+      }
+      var selected = new Set(this._selected);
+      selected.delete(value);
       return this.cloneWith({
-        focused: data[0]
+        selected: selected
       });
     }
-    const nextItem = data[data.indexOf(focused) + 1];
-    if (nextItem) {
+  }, {
+    key: "toggleSelection",
+    value: function toggleSelection() {
+      var value = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this._focused;
+      if (this.isSelected(value)) {
+        return this.deselect(value);
+      } else {
+        return this.select(value);
+      }
+    }
+  }, {
+    key: "selectAll",
+    value: function selectAll() {
       return this.cloneWith({
-        focused: nextItem
+        selected: _toConsumableArray(this._data)
       });
     }
-    return undefined;
-  }
-  moveStart() {
-    const data = [...this._data];
-    if (data.length) {
+  }, {
+    key: "resetFocus",
+    value: function resetFocus() {
       return this.cloneWith({
-        focused: data[0]
+        focused: null
       });
     }
-    return undefined;
-  }
-  moveEnd() {
-    const data = [...this._data];
-    if (data.length) {
+  }, {
+    key: "resetSelection",
+    value: function resetSelection() {
       return this.cloneWith({
-        focused: data.pop()
+        selected: new Set()
       });
     }
-    return undefined;
-  }
-  select() {
-    let value = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this._focused;
-    if (!value || !this._isItemSelectable(value)) {
-      return this;
-    }
-    const selected = new Set(this._selected);
-    selected.add(value);
-    return this.cloneWith({
-      selected
-    });
-  }
-  deselect() {
-    let value = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this._focused;
-    if (!value || !this._isItemSelectable(value)) {
-      return this;
-    }
-    const selected = new Set(this._selected);
-    selected.delete(value);
-    return this.cloneWith({
-      selected
-    });
-  }
-  toggleSelection() {
-    let value = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this._focused;
-    if (this.isSelected(value)) {
-      return this.deselect(value);
-    } else {
-      return this.select(value);
+  }, {
+    key: "reset",
+    value: function reset() {
+      return this.resetFocus().resetSelection();
     }
-  }
-  selectAll() {
-    return this.cloneWith({
-      selected: [...this._data]
-    });
-  }
-  resetFocus() {
-    return this.cloneWith({
-      focused: null
-    });
-  }
-  resetSelection() {
-    return this.cloneWith({
-      selected: new Set()
-    });
-  }
-  reset() {
-    return this.resetFocus().resetSelection();
-  }
-  isFocused(value) {
-    return this._focused === value;
-  }
-  isSelected(value) {
-    return value != null && this._selected.has(value);
-  }
-  getFocused() {
-    return this._focused;
-  }
-  getSelected() {
-    return new Set(this._selected);
-  }
-  getActive() {
-    if (this._selected.size) {
+  }, {
+    key: "isFocused",
+    value: function isFocused(value) {
+      return this._focused === value;
+    }
+  }, {
+    key: "isSelected",
+    value: function isSelected(value) {
+      return value != null && this._selected.has(value);
+    }
+  }, {
+    key: "getFocused",
+    value: function getFocused() {
+      return this._focused;
+    }
+  }, {
+    key: "getSelected",
+    value: function getSelected() {
       return new Set(this._selected);
-    } else if (this._focused) {
-      return new Set([this._focused]);
-    } else {
-      return new Set();
     }
-  }
-};
+  }, {
+    key: "getActive",
+    value: function getActive() {
+      if (this._selected.size) {
+        return new Set(this._selected);
+      } else if (this._focused) {
+        return new Set([this._focused]);
+      } else {
+        return new Set();
+      }
+    }
+  }]);
+  return Selection;
+}();
 
-export { Selection$1 as default };
+export { Selection as default };

package/dist/table/smart-table.d.ts

@@ -20,6 +20,7 @@ declare class SmartTable<T extends SelectionItem> extends PureComponent<SmartTab
         isItemSelectable: PropTypes.Requireable<(...args: any[]) => any> | React.Validator<((item: SelectionItem) => boolean) | null | undefined>;
         innerRef?: React.Validator<React.Ref<HTMLTableRowElement> | undefined> | undefined;
         autofocus?: React.Validator<boolean | null | undefined> | undefined;
+        scrollOnTableFocus?: React.Validator<boolean | null | undefined> | undefined;
         disabledHover?: React.Validator<boolean> | undefined;
         remoteSelection?: React.Validator<boolean | null | undefined> | undefined;
         onSort?: React.Validator<((params: import("./header-cell").SortParams) => void) | null | undefined> | undefined;
@@ -32,6 +33,7 @@ declare class SmartTable<T extends SelectionItem> extends PureComponent<SmartTab
         stickyHeader?: React.Validator<boolean | null | undefined> | undefined;
         getItemLevel?: React.Validator<((item: SelectionItem) => number) | null | undefined> | undefined;
         getItemClassName?: React.Validator<((item: SelectionItem) => string | null | undefined) | null | undefined> | undefined;
+        getMetaColumnClassName?: React.Validator<((item: SelectionItem) => string | null | undefined) | null | undefined> | undefined;
         getItemDataTest?: React.Validator<((item: SelectionItem) => string | null | undefined) | null | undefined> | undefined;
         isItemCollapsible?: React.Validator<((item: SelectionItem) => boolean) | null | undefined> | undefined;
         isParentCollapsible?: React.Validator<((item: SelectionItem) => boolean) | null | undefined> | undefined;
@@ -57,6 +59,6 @@ declare class SmartTable<T extends SelectionItem> extends PureComponent<SmartTab
     };
     UNSAFE_componentWillReceiveProps(nextProps: SmartTableProps<T>): void;
     onSelect: (selection: Selection<T>) => void;
-    render(): JSX.Element;
+    render(): React.JSX.Element;
 }
 export default SmartTable;

package/dist/table/smart-table.js

@@ -1,25 +1,47 @@
-import { _ as _defineProperty, a as _extends } from '../_helpers/_rollupPluginBabelHelpers.js';
+import { e as _objectWithoutProperties, _ as _defineProperty, g as _objectSpread2, 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 React, { PureComponent } from 'react';
 import PropTypes from 'prop-types';
 import TableContainer from './table.js';
-import Selection$1 from './selection.js';
+import Selection from './selection.js';
+import 'core-js/modules/es.array.map.js';
 import 'classnames';
 import 'react-movable';
 import '../global/focus-sensor-hoc.js';
 import '../global/prop-types.js';
 import '../global/composeRefs.js';
+import 'core-js/modules/es.object.to-string.js';
+import 'core-js/modules/web.dom-collections.for-each.js';
 import '../global/get-uid.js';
+import 'core-js/modules/es.regexp.to-string.js';
 import '../shortcuts/shortcuts.js';
 import '../shortcuts/core.js';
+import 'core-js/modules/es.array.includes.js';
+import 'core-js/modules/es.string.includes.js';
+import 'core-js/modules/es.object.assign.js';
+import 'core-js/modules/es.array.slice.js';
+import 'core-js/modules/es.array.splice.js';
+import 'core-js/modules/es.regexp.exec.js';
+import 'core-js/modules/es.string.match.js';
+import 'core-js/modules/es.array.find-index.js';
 import 'combokeys';
 import '../global/sniffer.js';
 import 'sniffr';
 import '../loader/loader.js';
 import '../global/data-tests.js';
+import 'core-js/modules/es.array.reduce.js';
+import 'core-js/modules/es.object.entries.js';
 import '../loader/loader__core.js';
+import 'core-js/modules/es.array.fill.js';
+import 'core-js/modules/es.array.filter.js';
 import '../global/dom.js';
+import 'core-js/modules/es.string.split.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';
 import './header.js';
-import 'react-waypoint';
 import '../checkbox/checkbox.js';
 import '@jetbrains/icons/checkmark-14px';
 import '@jetbrains/icons/remove-14px';
@@ -28,13 +50,18 @@ import 'util-deprecate';
 import '../icon/icon__constants.js';
 import '../_helpers/icon.js';
 import '../icon/icon__svg.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.map.js';
+import 'core-js/modules/es.weak-map.js';
 import '../_helpers/checkbox.js';
 import '../_helpers/table.js';
 import './header-cell.js';
 import '@jetbrains/icons/unsorted-10px';
 import '@jetbrains/icons/chevron-10px';
 import './selection-shortcuts-hoc.js';
+import 'core-js/modules/es.array.index-of.js';
 import './disable-hover-hoc.js';
 import './row-with-focus-sensor.js';
 import './row.js';
@@ -42,7 +69,6 @@ import '@jetbrains/icons/chevron-right';
 import '@jetbrains/icons/chevron-down';
 import '@jetbrains/icons/drag';
 import '../button/button.js';
-import 'focus-visible';
 import '../link/clickableLink.js';
 import '../global/controls-height.js';
 import '../_helpers/button__classes.js';
@@ -52,65 +78,76 @@ import 'react-dom';
 import '../global/schedule-raf.js';
 import '../tab-trap/tab-trap.js';
 import '../popup/position.js';
+import 'core-js/modules/es.array.sort.js';
 import '../popup/popup.consts.js';
 import '../popup/popup.target.js';
 import './cell.js';
 
 var _Table$propTypes;
-const {
-  selection: __selection__,
-  onSelect: __onSelect__,
-  ...restPropTypes
-} = (_Table$propTypes = TableContainer.propTypes) !== null && _Table$propTypes !== void 0 ? _Table$propTypes : {};
-class SmartTable extends PureComponent {
-  constructor() {
-    super(...arguments);
-    _defineProperty(this, "state", {
-      selection: new Selection$1({
-        data: this.props.data,
-        isItemSelectable: this.props.isItemSelectable
+var _ref = (_Table$propTypes = TableContainer.propTypes) !== null && _Table$propTypes !== void 0 ? _Table$propTypes : {};
+  _ref.selection;
+  _ref.onSelect;
+  var restPropTypes = _objectWithoutProperties(_ref, ["selection", "onSelect"]);
+var SmartTable = /*#__PURE__*/function (_PureComponent) {
+  _inherits(SmartTable, _PureComponent);
+  var _super = _createSuper(SmartTable);
+  function SmartTable() {
+    var _this;
+    _classCallCheck(this, SmartTable);
+    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", {
+      selection: new Selection({
+        data: _this.props.data,
+        isItemSelectable: _this.props.isItemSelectable
       })
     });
-    _defineProperty(this, "onSelect", selection => {
-      this.setState({
-        selection
+    _defineProperty(_assertThisInitialized(_this), "onSelect", function (selection) {
+      _this.setState({
+        selection: selection
       });
-      this.props.onSelectionChange(selection);
+      _this.props.onSelectionChange(selection);
     });
+    return _this;
   }
-  UNSAFE_componentWillReceiveProps(nextProps) {
-    const {
-      data,
-      isItemSelectable,
-      selection
-    } = nextProps;
-    if (this.props.remoteSelection && this.props.selection !== selection) {
-      this.setState({
-        selection
-      });
-    } else if (this.props.data !== data || this.props.isItemSelectable !== isItemSelectable) {
-      this.setState({
-        selection: new Selection$1({
-          data,
-          isItemSelectable
-        })
-      });
+  _createClass(SmartTable, [{
+    key: "UNSAFE_componentWillReceiveProps",
+    value: function UNSAFE_componentWillReceiveProps(nextProps) {
+      var data = nextProps.data,
+        isItemSelectable = nextProps.isItemSelectable,
+        selection = nextProps.selection;
+      if (this.props.remoteSelection && this.props.selection !== selection) {
+        this.setState({
+          selection: selection
+        });
+      } else if (this.props.data !== data || this.props.isItemSelectable !== isItemSelectable) {
+        this.setState({
+          selection: new Selection({
+            data: data,
+            isItemSelectable: isItemSelectable
+          })
+        });
+      }
     }
-  }
-  render() {
-    return /*#__PURE__*/React.createElement(TableContainer, _extends({}, this.props, {
-      selection: this.state.selection,
-      onSelect: this.onSelect
-    }));
-  }
-}
-_defineProperty(SmartTable, "propTypes", {
+  }, {
+    key: "render",
+    value: function render() {
+      return /*#__PURE__*/React.createElement(TableContainer, _extends({}, this.props, {
+        selection: this.state.selection,
+        onSelect: this.onSelect
+      }));
+    }
+  }]);
+  return SmartTable;
+}(PureComponent);
+_defineProperty(SmartTable, "propTypes", _objectSpread2({
   onSelectionChange: PropTypes.func,
-  isItemSelectable: PropTypes.func,
-  ...restPropTypes
-});
+  isItemSelectable: PropTypes.func
+}, restPropTypes));
 _defineProperty(SmartTable, "defaultProps", {
-  onSelectionChange: () => {}
+  onSelectionChange: function onSelectionChange() {}
 });
 
 export { SmartTable as default };