dtable-ui-component 0.2.1 → 0.2.2

package/es/components/cell-editor/single-select-editor.js

@@ -0,0 +1,202 @@
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _inherits from "@babel/runtime/helpers/esm/inherits";
+import _createSuper from "@babel/runtime/helpers/esm/createSuper";
+import React, { Fragment } from 'react';
+import MediaQuery from 'react-responsive';
+import { getLocale } from '../../lang';
+import EditEditorButton from '../common/edit-editor-button';
+import SelectEditorOption from '../common/select-editor-option';
+import PCSelectEditorPopover from '../cell-editor-popover/pc-select-editor-popover';
+import MBSingleSelectPopover from '../cell-editor-popover/mb-select-editor-popover';
+
+var SingleSelectEditor = /*#__PURE__*/function (_React$Component) {
+  _inherits(SingleSelectEditor, _React$Component);
+
+  var _super = _createSuper(SingleSelectEditor);
+
+  function SingleSelectEditor(props) {
+    var _this;
+
+    _classCallCheck(this, SingleSelectEditor);
+
+    _this = _super.call(this, props);
+
+    _this.onDocumentToggle = function (e) {
+      if (_this.editorContainer !== e.target && !_this.editorContainer.contains(e.target)) {
+        _this.onClosePopover();
+      }
+    };
+
+    _this.formatOption = function () {
+      var newValue = _this.state.newValue;
+
+      var option = _this.options.find(function (option) {
+        return option.id === newValue;
+      });
+
+      return option;
+    };
+
+    _this.onAddOptionToggle = function (event) {
+      event.nativeEvent.stopImmediatePropagation();
+      event.stopPropagation();
+
+      if (_this.props.isReadOnly) {
+        return;
+      }
+
+      var isPopoverShow = !_this.state.isPopoverShow;
+
+      if (isPopoverShow) {
+        var popoverPosition = _this.caculatePopoverPosition();
+
+        _this.setState({
+          isPopoverShow: isPopoverShow,
+          popoverPosition: popoverPosition
+        });
+      } else {
+        _this.setState({
+          isPopoverShow: isPopoverShow
+        });
+      }
+    };
+
+    _this.onCommit = function (newValue) {
+      var updated = {};
+      var column = _this.props.column;
+      updated[column.key] = newValue;
+
+      _this.props.onCommit(updated);
+    };
+
+    _this.onOptionItemToggle = function (option) {
+      var newValue = _this.state.newValue === option.id ? '' : option.id;
+
+      _this.setState({
+        newValue: newValue
+      }, function () {
+        _this.onCommit(newValue);
+
+        _this.onClosePopover();
+      });
+    };
+
+    _this.caculatePopoverPosition = function () {
+      var POPOVER_MAX_HEIGHT = 200;
+      var innerHeight = window.innerHeight;
+
+      var _this$editor$getClien = _this.editor.getClientRects()[0],
+          top = _this$editor$getClien.top,
+          height = _this$editor$getClien.height;
+
+      var isBelow = innerHeight - (top + height) > POPOVER_MAX_HEIGHT;
+      var position = {
+        top: height + 1,
+        left: 0
+      };
+
+      if (!isBelow) {
+        var bottom = height + 1;
+        position = {
+          bottom: bottom,
+          left: 0
+        };
+      }
+
+      return position;
+    };
+
+    _this.onAddNewOption = function (optionName) {
+      _this.props.onAddNewOption(optionName);
+
+      _this.onClosePopover();
+    };
+
+    _this.onClosePopover = function () {
+      _this.setState({
+        isPopoverShow: false
+      });
+    };
+
+    _this.setEditorContainerRef = function (editorContainer) {
+      _this.editorContainer = editorContainer;
+    };
+
+    _this.setEditorRef = function (editor) {
+      _this.editor = editor;
+    };
+
+    _this.state = {
+      newValue: props.value,
+      isPopoverShow: false,
+      popoverPosition: {}
+    };
+    var _column = _this.props.column;
+    _this.options = _column.data && (_column.data.options || []);
+    return _this;
+  }
+
+  _createClass(SingleSelectEditor, [{
+    key: "componentDidMount",
+    value: function componentDidMount() {
+      document.addEventListener('click', this.onDocumentToggle);
+    }
+  }, {
+    key: "componentWillUnmount",
+    value: function componentWillUnmount() {
+      document.removeEventListener('click', this.onDocumentToggle);
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this$state = this.state,
+          isPopoverShow = _this$state.isPopoverShow,
+          popoverPosition = _this$state.popoverPosition;
+      var option = this.formatOption();
+      var options = this.options;
+      var selectedOptions = option ? [option] : [];
+      return /*#__PURE__*/React.createElement("div", {
+        ref: this.setEditorContainerRef,
+        className: "cell-editor dtable-ui-single-select-editor"
+      }, /*#__PURE__*/React.createElement("div", {
+        ref: this.setEditorRef,
+        className: "dtable-ui-select-editor-container",
+        onClick: this.onAddOptionToggle
+      }, option ? /*#__PURE__*/React.createElement(SelectEditorOption, {
+        option: option
+      }) : /*#__PURE__*/React.createElement(EditEditorButton, {
+        text: getLocale('Add_an_option')
+      })), isPopoverShow && /*#__PURE__*/React.createElement(Fragment, null, /*#__PURE__*/React.createElement(MediaQuery, {
+        query: "(min-width: 768px)"
+      }, /*#__PURE__*/React.createElement(PCSelectEditorPopover, {
+        popoverPosition: popoverPosition,
+        options: options,
+        selectedOptions: selectedOptions,
+        onOptionItemToggle: this.onOptionItemToggle,
+        isSupportNewOption: this.props.isSupportNewOption,
+        onAddNewOption: this.onAddNewOption
+      })), /*#__PURE__*/React.createElement(MediaQuery, {
+        query: "(max-width: 767.8px)"
+      }, /*#__PURE__*/React.createElement(MBSingleSelectPopover, {
+        isReadOnly: this.props.isReadOnly,
+        value: [this.state.newValue],
+        column: this.props.column,
+        options: options,
+        onOptionItemToggle: this.onOptionItemToggle,
+        isShowRemoveIcon: true,
+        isSupportNewOption: this.props.isSupportNewOption,
+        onAddNewOption: this.onAddNewOption,
+        onClosePopover: this.onClosePopover
+      }))));
+    }
+  }]);
+
+  return SingleSelectEditor;
+}(React.Component);
+
+SingleSelectEditor.defaultProps = {
+  isReadOnly: false,
+  value: ''
+};
+export default SingleSelectEditor;

package/es/components/cell-editor/text-editor.js

@@ -0,0 +1,122 @@
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _inherits from "@babel/runtime/helpers/esm/inherits";
+import _createSuper from "@babel/runtime/helpers/esm/createSuper";
+import React from 'react';
+import isHotkey from 'is-hotkey';
+
+var TextEditor = /*#__PURE__*/function (_React$Component) {
+  _inherits(TextEditor, _React$Component);
+
+  var _super = _createSuper(TextEditor);
+
+  function TextEditor(props) {
+    var _this;
+
+    _classCallCheck(this, TextEditor);
+
+    _this = _super.call(this, props);
+
+    _this.onCommit = function () {
+      var updated = {};
+      var column = _this.props.column;
+      var newValue = _this.state.newValue;
+      updated[column.key] = newValue ? newValue.trim() : '';
+
+      _this.props.onCommit(updated);
+
+      _this.setState({
+        isEditorShow: false
+      });
+    };
+
+    _this.onBlur = function () {
+      _this.onCommit();
+    };
+
+    _this.onChange = function (event) {
+      var value = event.target.value;
+
+      _this.setState({
+        newValue: value
+      });
+    };
+
+    _this.onEditorhandle = function () {
+      if (_this.props.isReadOnly) {
+        return;
+      }
+
+      _this.setState({
+        isEditorShow: true
+      }, function () {
+        _this.input.focus();
+      });
+    };
+
+    _this.onKeyDown = function (event) {
+      var _event$currentTarget = event.currentTarget,
+          selectionStart = _event$currentTarget.selectionStart,
+          selectionEnd = _event$currentTarget.selectionEnd,
+          value = _event$currentTarget.value;
+
+      if (isHotkey('enter', event)) {
+        event.preventDefault();
+
+        _this.onBlur();
+      } else if (event.keyCode === 37 && selectionStart === 0 || event.keyCode === 39 && selectionEnd === value.length) {
+        event.stopPropagation();
+      }
+    };
+
+    _this.onPaste = function (e) {
+      e.stopPropagation();
+    };
+
+    _this.onCut = function (e) {
+      e.stopPropagation();
+    };
+
+    _this.setInputRef = function (input) {
+      _this.input = input;
+    };
+
+    _this.state = {
+      newValue: props.value,
+      isEditorShow: false
+    };
+    return _this;
+  }
+
+  _createClass(TextEditor, [{
+    key: "render",
+    value: function render() {
+      return /*#__PURE__*/React.createElement("div", {
+        className: "cell-editor text-editor"
+      }, /*#__PURE__*/React.createElement("div", {
+        className: "text-editor-container"
+      }, !this.state.isEditorShow && /*#__PURE__*/React.createElement("div", {
+        className: "form-control",
+        onClick: this.onEditorhandle
+      }, this.state.newValue), this.state.isEditorShow && /*#__PURE__*/React.createElement("input", {
+        ref: this.setInputRef,
+        type: "text",
+        className: "form-control",
+        value: this.state.newValue,
+        onChange: this.onChange,
+        onKeyDown: this.onKeyDown,
+        onBlur: this.onBlur,
+        onCut: this.onCut,
+        onPaste: this.onPaste
+      })));
+    }
+  }]);
+
+  return TextEditor;
+}(React.Component);
+
+TextEditor.defaultProps = {
+  isReadOnly: false,
+  value: ''
+};
+export default TextEditor;

package/es/components/cell-editor-dialog/pc-file-editor-dialog.js

@@ -0,0 +1,46 @@
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _inherits from "@babel/runtime/helpers/esm/inherits";
+import _createSuper from "@babel/runtime/helpers/esm/createSuper";
+import React from 'react';
+import { Modal, ModalHeader, ModalBody } from 'reactstrap';
+import { getLocale } from '../../lang';
+
+var FileEditorDialog = /*#__PURE__*/function (_React$Component) {
+  _inherits(FileEditorDialog, _React$Component);
+
+  var _super = _createSuper(FileEditorDialog);
+
+  function FileEditorDialog(props) {
+    var _this;
+
+    _classCallCheck(this, FileEditorDialog);
+
+    _this = _super.call(this, props);
+    _this.state = {};
+    return _this;
+  }
+
+  _createClass(FileEditorDialog, [{
+    key: "render",
+    value: function render() {
+      var closeEditor = this.props.closeEditor;
+      return /*#__PURE__*/React.createElement(Modal, {
+        isOpen: true,
+        toggle: closeEditor
+      }, /*#__PURE__*/React.createElement(ModalHeader, {
+        toggle: closeEditor
+      }, getLocale('Add_Files')), /*#__PURE__*/React.createElement(ModalBody, {
+        className: "file-editor-container"
+      }));
+    }
+  }]);
+
+  return FileEditorDialog;
+}(React.Component);
+
+FileEditorDialog.defaultProps = {
+  isCheckRepeat: false,
+  columnType: 'file'
+};
+export default FileEditorDialog;

package/es/components/cell-editor-popover/mb-collaborator-editor-popover.js

@@ -0,0 +1,177 @@
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _assertThisInitialized from "@babel/runtime/helpers/esm/assertThisInitialized";
+import _inherits from "@babel/runtime/helpers/esm/inherits";
+import _createSuper from "@babel/runtime/helpers/esm/createSuper";
+import React from 'react';
+import { getLocale } from '../../lang';
+import MBEditorHeader from '../common/mobile/mb-editor-header';
+
+var MBCollaboratorEditorPopover = /*#__PURE__*/function (_React$Component) {
+  _inherits(MBCollaboratorEditorPopover, _React$Component);
+
+  var _super = _createSuper(MBCollaboratorEditorPopover);
+
+  function MBCollaboratorEditorPopover(props) {
+    var _this;
+
+    _classCallCheck(this, MBCollaboratorEditorPopover);
+
+    _this = _super.call(this, props);
+
+    _this.handleHistaryBack = function (e) {
+      e.preventDefault();
+
+      _this.props.onClosePopover();
+    };
+
+    _this.onContainerClick = function (event) {
+      if (_this.editorPopover && _this.editorPopover.contains(event.target)) {
+        event.stopPropagation();
+        event.nativeEvent.stopImmediatePropagation();
+        return false;
+      }
+    };
+
+    _this.onChangeSearch = function (event) {
+      var searchVal = _this.state.searchVal;
+
+      if (searchVal === event.target.value) {
+        return;
+      }
+
+      searchVal = event.target.value;
+
+      _this.setState({
+        searchVal: searchVal
+      });
+    };
+
+    _this.getSelectedCollaborators = function () {
+      var _this$props = _this.props,
+          value = _this$props.value,
+          collaborators = _this$props.collaborators;
+
+      if (!Array.isArray(value)) {
+        return [];
+      }
+
+      return collaborators.filter(function (collaborator) {
+        return value.indexOf(collaborator.email) > -1;
+      });
+    };
+
+    _this.getFilteredCollaborators = function () {
+      var collaborators = _this.props.collaborators;
+      var searchVal = _this.state.searchVal;
+      return searchVal ? collaborators.filter(function (item) {
+        return item.name.indexOf(searchVal) > -1;
+      }) : collaborators;
+    };
+
+    _this.onSelectCollaborator = function (collaborator) {
+      _this.props.onCollaboratorItemToggle(collaborator);
+    };
+
+    _this.onRemoveCollaborator = function (collaborator) {
+      _this.props.onCollaboratorItemToggle(collaborator);
+    };
+
+    _this.renderFilteredCollaborators = function (collaborators) {
+      var value = _this.props.value;
+      return collaborators.map(function (collaborator, index) {
+        var isSelect = value.some(function (item) {
+          return item === collaborator.email;
+        });
+        return /*#__PURE__*/React.createElement("div", {
+          className: "mb-collaborator-option-item",
+          key: index,
+          onMouseDown: _this.onSelectCollaborator.bind(_assertThisInitialized(_this), collaborator)
+        }, /*#__PURE__*/React.createElement("span", {
+          className: "mb-collaborator-info"
+        }, /*#__PURE__*/React.createElement("span", {
+          className: "collaborator-avatar"
+        }, /*#__PURE__*/React.createElement("img", {
+          src: collaborator.avatar_url,
+          width: "24",
+          height: "24",
+          alt: "avatar"
+        })), /*#__PURE__*/React.createElement("span", {
+          className: "collaborator-name"
+        }, collaborator.name)), isSelect && /*#__PURE__*/React.createElement("i", {
+          className: "mb-collaborator-checked dtable-font dtable-icon-check-mark"
+        }));
+      });
+    };
+
+    _this.setEditorPopover = function (editorPopover) {
+      _this.editorPopover = editorPopover;
+    };
+
+    _this.state = {
+      searchVal: ''
+    };
+    return _this;
+  }
+
+  _createClass(MBCollaboratorEditorPopover, [{
+    key: "componentDidMount",
+    value: function componentDidMount() {
+      history.pushState(null, null, '#'); // eslint-disable-line
+
+      window.addEventListener('popstate', this.handleHistaryBack, false);
+    }
+  }, {
+    key: "componentWillUnmount",
+    value: function componentWillUnmount() {
+      window.removeEventListener('popstate', this.handleHistaryBack, false);
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var column = this.props.column;
+      var searchVal = this.state.searchVal;
+      var filteredCollaborators = this.getFilteredCollaborators();
+      return /*#__PURE__*/React.createElement("div", {
+        ref: this.setEditorPopover,
+        className: "dtable-ui-mb-editor-popover mb-collaborator-editor-popover",
+        onClick: this.onContainerClick
+      }, /*#__PURE__*/React.createElement(MBEditorHeader, {
+        title: column.name,
+        leftContent: /*#__PURE__*/React.createElement("i", {
+          className: "dtable-font dtable-icon-return"
+        }),
+        rightContent: /*#__PURE__*/React.createElement("span", null, getLocale('Done')),
+        onLeftClick: this.props.onClosePopover,
+        onRightClick: this.props.onClosePopover
+      }), /*#__PURE__*/React.createElement("div", {
+        className: "dtable-ui-mb-editor-body dtable-ui-mb-collaborator-editor-body"
+      }, /*#__PURE__*/React.createElement("div", {
+        className: "mb-search-collaborator-items"
+      }, /*#__PURE__*/React.createElement("input", {
+        className: "form-control",
+        type: "text",
+        placeholder: getLocale('Find_a_collaborator'),
+        value: searchVal,
+        onChange: this.onChangeSearch,
+        onClick: this.onInputClick
+      })), /*#__PURE__*/React.createElement("div", {
+        className: "mb-collaborators-container"
+      }, /*#__PURE__*/React.createElement("div", {
+        className: "title"
+      }, getLocale('Choose_a_collaborator')), /*#__PURE__*/React.createElement("div", {
+        className: "content"
+      }, filteredCollaborators.length === 0 && /*#__PURE__*/React.createElement("div", {
+        className: "search-result-none"
+      }, getLocale('No_collaborators_avaliable')), filteredCollaborators.length > 0 && this.renderFilteredCollaborators(filteredCollaborators)))));
+    }
+  }]);
+
+  return MBCollaboratorEditorPopover;
+}(React.Component);
+
+MBCollaboratorEditorPopover.defaultProps = {
+  isReadOnly: false,
+  value: []
+};
+export default MBCollaboratorEditorPopover;