@jetbrains/ring-ui 4.2.7 → 4.2.10

package/dist/table/selection.js

@@ -0,0 +1,223 @@
+import 'core-js/modules/web.dom-collections.iterator.js';
+
+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] : {};
+    this._rawData = data;
+    this._getChildren = getChildren;
+    this._data = this._buildData(data);
+    this._selected = selected;
+    this._focused = focused;
+    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) {
+      return this.cloneWith({
+        focused: data[data.length - 1]
+      });
+    }
+
+    const nextItem = data[data.indexOf(focused) - 1];
+
+    if (nextItem) {
+      return this.cloneWith({
+        focused: nextItem
+      });
+    }
+
+    return undefined;
+  }
+
+  moveDown() {
+    const focused = this._focused;
+    const data = [...this._data];
+
+    if (!focused) {
+      return this.cloneWith({
+        focused: data[0]
+      });
+    }
+
+    const nextItem = data[data.indexOf(focused) + 1];
+
+    if (nextItem) {
+      return this.cloneWith({
+        focused: nextItem
+      });
+    }
+
+    return undefined;
+  }
+
+  moveStart() {
+    const data = [...this._data];
+
+    if (data.length) {
+      return this.cloneWith({
+        focused: data[0]
+      });
+    }
+
+    return undefined;
+  }
+
+  moveEnd() {
+    const data = [...this._data];
+
+    if (data.length) {
+      return this.cloneWith({
+        focused: data.pop()
+      });
+    }
+
+    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);
+    }
+  }
+
+  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 this._selected.has(value);
+  }
+
+  getFocused() {
+    return this._focused;
+  }
+
+  getSelected() {
+    return new Set(this._selected);
+  }
+
+  getActive() {
+    if (this._selected.size) {
+      return new Set(this._selected);
+    } else if (this._focused) {
+      return new Set([this._focused]);
+    } else {
+      return new Set();
+    }
+  }
+
+}
+
+export { Selection as default };

package/dist/table/smart-table.js

@@ -0,0 +1,125 @@
+import { _ as _defineProperty, a as _extends } from '../_helpers/_rollupPluginBabelHelpers.js';
+import 'core-js/modules/web.dom-collections.iterator.js';
+import React, { PureComponent } from 'react';
+import PropTypes from 'prop-types';
+import Table from './table.js';
+import Selection from './selection.js';
+import 'classnames';
+import 'react-movable';
+import '../global/focus-sensor-hoc.js';
+import '../global/composeRefs.js';
+import '../global/get-uid.js';
+import '../shortcuts/shortcuts.js';
+import '../shortcuts/core.js';
+import 'combokeys';
+import '../global/sniffer.js';
+import 'sniffr';
+import '../loader/loader.js';
+import '../global/data-tests.js';
+import '../loader/loader__core.js';
+import '../global/dom.js';
+import './header.js';
+import 'react-waypoint';
+import '../checkbox/checkbox.js';
+import '@jetbrains/icons/checkmark';
+import '@jetbrains/icons/remove-10px';
+import '../icon/icon.js';
+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 '../global/memoize.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 './disable-hover-hoc.js';
+import './row-with-focus-sensor.js';
+import './row.js';
+import '@jetbrains/icons/chevron-right';
+import '@jetbrains/icons/chevron-down';
+import '@jetbrains/icons/drag';
+import '../button/button.js';
+import 'focus-visible';
+import '../global/theme.js';
+import '../link/clickableLink.js';
+import '../_helpers/button__classes.js';
+import '../tooltip/tooltip.js';
+import '../popup/popup.js';
+import 'react-dom';
+import '../global/schedule-raf.js';
+import '../tab-trap/tab-trap.js';
+import '../popup/position.js';
+import '../popup/popup.consts.js';
+import '../popup/popup.target.js';
+import './cell.js';
+
+const {
+  selection: __selection__,
+  onSelect: __onSelect__,
+  ...restPropTypes
+} = Table.propTypes;
+
+class SmartTable extends PureComponent {
+  constructor() {
+    super(...arguments);
+
+    _defineProperty(this, "state", {
+      selection: new Selection({
+        data: this.props.data,
+        isItemSelectable: this.props.isItemSelectable
+      })
+    });
+
+    _defineProperty(this, "onSelect", selection => {
+      this.setState({
+        selection
+      });
+      this.props.onSelectionChange(selection);
+    });
+  }
+
+  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({
+          data,
+          isItemSelectable
+        })
+      });
+    }
+  }
+
+  render() {
+    return /*#__PURE__*/React.createElement(Table, _extends({}, this.props, {
+      selection: this.state.selection,
+      onSelect: this.onSelect
+    }));
+  }
+
+}
+
+_defineProperty(SmartTable, "propTypes", {
+  onSelectionChange: PropTypes.func,
+  isItemSelectable: PropTypes.func,
+  ...restPropTypes
+});
+
+_defineProperty(SmartTable, "defaultProps", {
+  onSelectionChange: () => {}
+});
+
+export { SmartTable as default };