@seafile/sdoc-editor 1.0.17 → 1.0.18

package/dist/basic-sdk/extension/plugins/seatable-tables/seatable-settings/filter-setter/filter-popover-widgets/filters-list.css

@@ -0,0 +1,321 @@
+.filters-list {
+  min-height: 120px;
+  max-height: 100%;
+  padding: 15px;
+}
+
+.filters-list.empty-filters-container {
+  min-height: 80px;
+  padding: 16px;
+}
+
+.filters-list.empty-filters-container .empty-filters-list {
+  padding-left: 0;
+}
+
+.filters-list .empty-filters-list {
+  padding: 0.25rem;
+  font-size: 14px;
+  opacity: 0.5;
+}
+
+.filters-list .filter-item {
+  display: flex;
+  align-items: center;
+  padding: 0.25rem 0;
+}
+
+.filters-list .filter-item .condition {
+  display: flex;
+  flex: 1;
+}
+
+.filters-list .filter-item .condition > div {
+  height: 38px;
+  line-height: 38px;
+  margin-left: 0.5rem;
+}
+
+.filters-list .filter-item .condition > div:first-child {
+  margin-left: 0;
+}
+
+.filters-list .filter-item .filter-term {
+  max-width: 300px;
+}
+
+.filters-list .filter-item .filter-term .option-group-content .option.option-active .dtable-font {
+  color: #798d99;
+}
+
+.filters-list .filter-conjunction {
+  width: 72px;
+}
+
+.filters-list .filter-conjunction-readonly {
+  width: 52px;
+}
+
+.filters-list .filter-container {
+  width: calc(100% - 72px);
+  display: flex;
+}
+
+.filters-list .dtable-select .selected-option-show {
+  width: calc(100% - 20px);
+  height: 20px;
+}
+
+.filters-list .dtable-select .selected-option {
+  width: auto;
+  overflow-x: auto;
+}
+
+.filters-list .dtable-select .dtable-icon-drop-down {
+  margin-left: 0.5rem;
+}
+
+.filters-list .selected-conjunction-show {
+  padding: 0 10px;
+  color: #999;
+}
+
+.filters-list .filter-column {
+  max-width: 150px;
+}
+
+.filter-term .selector-multiple-select .option,
+.filter-term .selector-single-select .option {
+  height: 30px;
+  padding: 0 10px;
+}
+
+.filter-term .selector-multiple-select .select-option-name,
+.filter-term .selector-single-select .select-option-name {
+  margin-top: 5px;
+}
+
+.filter-term .selector-single-select .option:hover {
+  color: #212529;
+  background-color: #f7f7f7;
+}
+
+.filter-term .selector-single-select .option:hover .select-option-name,
+.filter-term .selector-multiple-select .option:hover .select-option-name,
+.filter-term .selector-collaborator .option:hover .select-option-name {
+  color: unset;
+}
+
+.filter-term .selector-collaborator .dtable-icon-drop-down {
+  padding-left: 5px;
+}
+
+.filters-list .selector-collaborator .selected-option-show {
+  text-overflow: unset;
+}
+
+.filters-list .selector-multiple-select .option:hover,
+.filters-list .selector-multiple-select .option.option-active,
+.filters-list .selector-collaborator .option:hover,
+.filters-list .selector-collaborator .option.option-active {
+  color: #212529;
+  background-color: #f7f7f7;
+}
+
+.filters-list .selector-multiple-select .option.option-active .select-option-name,
+.filters-list .selector-collaborator .option.option-active .select-option-name {
+  color: #212529;
+}
+
+.filters-list .selected-option .multiple-select-option,
+.filters-list .selected-option .single-select-option {
+  margin: 0;
+  display: inline-block;
+}
+
+.filters-list .filter-term input {
+  display: flex;
+  width: 100%;
+  height: 38px;
+  background-color: #ffffff;
+  padding-left: 8px;
+  padding-right: 8px;
+  outline: none;
+  border-radius: 3px;
+  font-size: 0.875rem;
+}
+
+.filters-list .filter-term input:hover {
+  border-color: rgb(179, 179, 179);
+}
+
+.filters-list .filter-term input.disabled:hover {
+  border-color: rgba(0, 40, 100, 0.12);
+}
+
+.filters-list .filter-term input:hover:focus {
+  border-color: #1991eb;
+}
+
+.filters-list .filter-term input:focus {
+  color: #495057;
+  background-color: #fff;
+  border-color: #1991eb;
+  outline: 0;
+  box-shadow: 0 0 0 2px rgba(70, 127, 207, 0.25);
+}
+
+.filters-list .filter-term .date-picker-container input:focus {
+  color: #495057;
+  background-color: #fff;
+  border: 1px solid #fff;
+  outline: 0;
+}
+
+.filters-list .filter-term .date-picker-container table tr {
+  height: 30px;
+}
+
+.filters-list .filter-term input[type='checkbox'] {
+  width: inherit;
+}
+
+.filters-list .filter-term input[type='checkbox']:focus {
+  border: 0;
+  box-shadow: none;
+}
+
+.filter-term .filter-rate-list {
+  display: flex;
+  padding: 0 5px;
+  border: 1px solid rgba(0, 40, 100, 0.12);
+}
+
+.filters-list .delete-filter {
+  width: 12px;
+  height: 20px;
+  margin-right: 14px;
+  text-align: center;
+}
+
+.filters-list .delete-filter:hover {
+  cursor: pointer;
+}
+
+.filters-list .delete-filter .dtable-icon-fork-number {
+  display: inline-block;
+  font-size: 12px;
+  color: #999;
+}
+
+.filters-list .multiple-option-name {
+  display: flex;
+  align-items: center;
+}
+
+.filters-list .multiple-check-icon,
+.filters-list .collaborator-check-icon {
+  display: inline-flex;
+  width: 20px;
+  height: 20px;
+  align-items: center;
+  text-align: center;
+}
+
+.filters-list .multiple-check-icon .dtable-icon-check-mark,
+.filters-list .collaborator-check-icon .dtable-icon-check-mark {
+  font-size: 12px;
+  color: #798d99;
+}
+
+.user-select-item,
+.collaborator {
+  display: inline-flex;
+  align-items: center;
+  height: 20px;
+  margin-right: 10px;
+  padding: 0 8px 0 2px;
+  font-size: 13px;
+  border-radius: 10px;
+  background: #eaeaea;
+}
+
+.filters-list .collaborator-show {
+  flex: 1;
+}
+
+.filters-list .collaborator-avatar-container {
+  width: 16px;
+}
+
+.filters-list .collaborator-avatar {
+  width: 16px;
+  height: 16px;
+  transform: translateY(-1px);
+  border-radius: 50%;
+}
+
+.filters-list .option .collaborator-avatar {
+  transform: translateY(-2px);
+}
+
+.filters-list .collaborator-name {
+  margin-left: 5px;
+  max-width: 200px;
+}
+
+.filters-list .option-collaborator {
+  display: flex;
+}
+
+.filters-list .collaborator-container {
+  flex: 1;
+}
+
+.filters-list .popover-add-tool {
+  border-top: none;
+  color: #555555;
+}
+
+.filters-list .popover-add-tool .popover-add-icon {
+  margin-right: 14px;
+}
+
+.filters-list .option-group {
+  max-height: 360px;
+  overflow: auto;
+}
+
+.filters-list .filter-item .dtable-icon-fork-number:hover {
+  color: #555;
+}
+
+.filters-list .filter-container-readonly .dtable-select .selected-option-show,
+.filters-list .filter-conjunction-readonly .dtable-select .selected-option-show {
+  width: 100%;
+}
+
+.filters-list .filter-checkbox-predicate .dtable-select .selected-option-show {
+  width: 100%;
+}
+
+.dropdown-item .collaborator,
+.filters-list .option-group .option-group-content .collaborator {
+  background-color: unset;
+}
+
+.filters-list .dtable-select .selected-option-show .remove-container {
+  display: none;
+}
+
+.filter-header-icon {
+  display: inline-block;
+  padding: 0 0.3125rem;
+  margin-left: -0.3125rem;
+}
+
+.filter-header-icon .dtable-font {
+  font-size: 14px;
+  color: #aaa;
+  cursor: default;
+}

package/dist/basic-sdk/extension/plugins/seatable-tables/seatable-settings/filter-setter/filter-popover-widgets/filters-list.js

@@ -0,0 +1,121 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import React, { Component } from 'react';
+import classnames from 'classnames';
+import { CellType, FILTER_COLUMN_OPTIONS, FORMULA_COLUMN_TYPES_MAP, FORMULA_RESULT_TYPE, ValidateFilter } from 'dtable-utils';
+import { getColumnByKey } from '../../utils/utils';
+import FilterItemUtils from './filter-item-utils';
+import FilterItem from './filter-item';
+import './filters-list.css';
+class FiltersList extends Component {
+  constructor(props) {
+    super(props);
+    _defineProperty(this, "updateFilter", (filterIndex, updatedFilter) => {
+      if (!updatedFilter) return;
+      this.props.updateFilter(filterIndex, updatedFilter);
+    });
+    _defineProperty(this, "deleteFilter", index => {
+      const {
+        scheduleUpdate
+      } = this.props;
+      this.props.deleteFilter(index, scheduleUpdate);
+    });
+    _defineProperty(this, "updateConjunction", filterConjunction => {
+      this.props.updateFilterConjunction(filterConjunction);
+    });
+    _defineProperty(this, "getConjunctionOptions", () => {
+      const {
+        t
+      } = this.props;
+      if (!this.conjunctionOptions) {
+        this.conjunctionOptions = FilterItemUtils.generatorConjunctionOptions(t);
+      }
+      return this.conjunctionOptions;
+    });
+    _defineProperty(this, "getFilterColumns", () => {
+      const {
+        columns
+      } = this.props;
+      return columns.filter(column => {
+        const {
+          data
+        } = column;
+        let {
+          type
+        } = column;
+        if (data && (type === CellType.LINK || FORMULA_COLUMN_TYPES_MAP[type] && data.result_type === FORMULA_RESULT_TYPE.ARRAY)) {
+          type = data.array_type;
+        }
+        return Object.prototype.hasOwnProperty.call(FILTER_COLUMN_OPTIONS, type);
+      });
+    });
+    _defineProperty(this, "getColumnOptions", () => {
+      if (!this.columnOptions) {
+        const filterColumns = this.getFilterColumns();
+        this.columnOptions = filterColumns.map(column => {
+          return FilterItemUtils.generatorColumnOption(column);
+        });
+      }
+      return this.columnOptions;
+    });
+    _defineProperty(this, "renderFilterItem", (filter, index, errMsg, filterColumn) => {
+      const {
+        filterConjunction,
+        value
+      } = this.props;
+      const conjunctionOptions = this.getConjunctionOptions();
+      const columnOptions = this.getColumnOptions();
+      return /*#__PURE__*/React.createElement(FilterItem, {
+        key: index,
+        isLocked: this.props.isLocked,
+        index: index,
+        filter: filter,
+        errMsg: errMsg,
+        filterColumn: filterColumn,
+        filterConjunction: filterConjunction,
+        conjunctionOptions: conjunctionOptions,
+        filterColumnOptions: columnOptions,
+        value: value,
+        deleteFilter: this.deleteFilter,
+        updateFilter: this.updateFilter,
+        updateConjunction: this.updateConjunction,
+        collaborators: this.props.collaborators,
+        isPre: this.props.isPre
+      });
+    });
+    this.conjunctionOptions = null;
+    this.columnOptions = null;
+  }
+  UNSAFE_componentWillReceiveProps(nextProps) {
+    if (nextProps.columns !== this.props.columns) {
+      this.columnOptions = null;
+    }
+  }
+  render() {
+    let {
+      filters,
+      className,
+      emptyPlaceholder,
+      columns
+    } = this.props;
+    const isEmpty = filters.length === 0;
+    return /*#__PURE__*/React.createElement("div", {
+      className: classnames('filters-list', {
+        'empty-filters-container': isEmpty
+      }, {
+        [className]: className
+      })
+    }, isEmpty && /*#__PURE__*/React.createElement("div", {
+      className: "empty-filters-list"
+    }, emptyPlaceholder), !isEmpty && filters.map((filter, index) => {
+      const {
+        column_key
+      } = filter;
+      const {
+        error_message
+      } = ValidateFilter.validateColumn(column_key, columns);
+      const filterColumn = getColumnByKey(column_key, columns) || {};
+      return this.renderFilterItem(filter, index, error_message, filterColumn);
+    }));
+  }
+}
+export default FiltersList;

package/dist/basic-sdk/extension/plugins/seatable-tables/seatable-settings/filter-setter/filter-popover-widgets/number-editor/index.js

@@ -0,0 +1,161 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import React, { Component } from 'react';
+import ReactDOM from 'react-dom';
+import classnames from 'classnames';
+import { DEFAULT_NUMBER_FORMAT, getNumberDisplayString, replaceNumberNotAllowInput, formatStringToNumber } from 'dtable-utils';
+import { isMac } from '../../../utils/utils';
+class NumberEditor extends Component {
+  constructor(props) {
+    super(props);
+    _defineProperty(this, "getValue", () => {
+      const {
+        column
+      } = this.props;
+      const {
+        value
+      } = this.state;
+      return {
+        [column.key]: formatStringToNumber(value, column.data)
+      };
+    });
+    _defineProperty(this, "updateValue", (value, callback) => {
+      if (value === this.state.value) {
+        return;
+      }
+      this.setState({
+        value
+      }, () => {
+        callback && callback();
+      });
+    });
+    _defineProperty(this, "focusInput", () => {
+      this.input && this.input.focus();
+    });
+    _defineProperty(this, "blurInput", () => {
+      this.input && this.input.blur();
+    });
+    _defineProperty(this, "onBlur", () => {
+      const {
+        column
+      } = this.props;
+      const columnData = column.data;
+      const number = formatStringToNumber(this.getInputNode().value, columnData);
+      const formattedNumber = getNumberDisplayString(number, columnData) || '';
+      this.setState({
+        value: formattedNumber
+      }, () => {
+        this.props.onCommit();
+      });
+    });
+    _defineProperty(this, "onPaste", e => {
+      e.stopPropagation();
+    });
+    _defineProperty(this, "onCut", e => {
+      e.stopPropagation();
+    });
+    _defineProperty(this, "onKeyDown", event => {
+      let {
+        selectionStart,
+        selectionEnd,
+        value
+      } = event.currentTarget;
+      // 13: enter
+      if (event.keyCode === 13) {
+        event.preventDefault();
+        this.onBlur();
+        // 37: left arrow; 39: right arrow
+      } else if (event.keyCode === 37 && selectionStart === 0 || event.keyCode === 39 && selectionEnd === value.length) {
+        event.stopPropagation();
+      }
+      if (this.props.onKeyDown) {
+        this.props.onKeyDown(event);
+      }
+    });
+    _defineProperty(this, "onChange", event => {
+      event.persist();
+      const {
+        data
+      } = this.props.column; // data maybe 'null'
+      const format = data && data.format ? data.format : DEFAULT_NUMBER_FORMAT;
+      let currency_symbol = null;
+      if (data && data.format === 'custom_currency') {
+        currency_symbol = data['currency_symbol'];
+      }
+      const initValue = event.target.value.trim();
+
+      // Prevent the repetition of periods bug in the Chinese input method of the Windows system
+      if (!isMac() && initValue.indexOf('.。') > -1) return;
+      const value = replaceNumberNotAllowInput(initValue, format, currency_symbol);
+      if (value === this.state.value) {
+        return;
+      }
+      this.setState({
+        value
+      }, () => {
+        if (this.props.onChange) {
+          this.props.onChange(event);
+        }
+      });
+    });
+    _defineProperty(this, "onClick", event => {
+      if (this.props.onInputClick) {
+        this.props.onInputClick(event);
+      }
+    });
+    _defineProperty(this, "getInputNode", () => {
+      const domNode = ReactDOM.findDOMNode(this.input);
+      if (domNode.tagName === 'INPUT') {
+        return domNode;
+      }
+      return domNode.querySelector('input:not([type=hidden])');
+    });
+    _defineProperty(this, "setInputRef", input => {
+      this.input = input;
+      return this.input;
+    });
+    const {
+      value: _value,
+      column: _column
+    } = props;
+    const {
+      data: _data = {}
+    } = _column;
+    this.state = {
+      value: getNumberDisplayString(_value, _data) || ''
+    };
+  }
+  UNSAFE_componentWillReceiveProps(nextProps) {
+    if (this.props.value !== nextProps.value) {
+      const {
+        column
+      } = nextProps;
+      const {
+        data = {}
+      } = column;
+      const newValue = getNumberDisplayString(nextProps.value, data) || '';
+      this.setState({
+        value: newValue
+      });
+    }
+  }
+  render() {
+    const {
+      readOnly,
+      extraClassName
+    } = this.props;
+    return /*#__PURE__*/React.createElement("input", {
+      ref: this.setInputRef,
+      type: "text",
+      className: classnames('form-control number-editor', extraClassName),
+      disabled: readOnly,
+      value: this.state.value || '',
+      onBlur: this.onBlur,
+      onPaste: this.onPaste,
+      onCut: this.onCut,
+      onKeyDown: this.onKeyDown,
+      onChange: this.onChange,
+      onClick: this.onClick
+    });
+  }
+}
+export default NumberEditor;

package/dist/basic-sdk/extension/plugins/seatable-tables/seatable-settings/filter-setter/filter-popover-widgets/rate-item/index.js

@@ -0,0 +1,73 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import React from 'react';
+import { UncontrolledTooltip } from 'reactstrap';
+class RateItem extends React.Component {
+  constructor(props) {
+    super(props);
+    _defineProperty(this, "onMouseEnterRateItem", () => {
+      const {
+        rateItemIndex
+      } = this.props;
+      this.props.onMouseEnterRateItem(rateItemIndex);
+    });
+    _defineProperty(this, "onMouseLeaveRateItem", () => {
+      this.props.onMouseLeaveRateItem();
+    });
+    _defineProperty(this, "onChangeRateNumber", () => {
+      const {
+        onChangeRateNumber,
+        rateItemIndex,
+        editable
+      } = this.props;
+      if (onChangeRateNumber && editable) {
+        onChangeRateNumber(rateItemIndex);
+      }
+    });
+    this.tooltipRef = React.createRef();
+    this.state = {
+      isOpen: false
+    };
+  }
+  render() {
+    const {
+      enterRateItemIndex,
+      rateItemIndex,
+      value,
+      column,
+      isShowRateItem,
+      editable
+    } = this.props;
+    const {
+      rate_style_color,
+      rate_style_type
+    } = column.data || {};
+    const rateShowType = rate_style_type ? rate_style_type : 'dtable-icon-rate';
+    if (!isShowRateItem && rateItemIndex > value) return null;
+    let itemStyle = {
+      cursor: editable ? 'pointer' : 'default',
+      color: value >= rateItemIndex ? rate_style_color : '#e5e5e5'
+    };
+    let style = itemStyle;
+    if (enterRateItemIndex >= rateItemIndex) {
+      style = _objectSpread(_objectSpread({}, itemStyle), {}, {
+        color: rate_style_color,
+        opacity: 0.4
+      });
+    }
+    return /*#__PURE__*/React.createElement("div", {
+      onMouseEnter: this.onMouseEnterRateItem,
+      onMouseLeave: this.onMouseLeaveRateItem,
+      style: style,
+      onClick: this.onChangeRateNumber,
+      className: "rate-item ".concat(value >= rateItemIndex ? 'rate-item-active' : '')
+    }, /*#__PURE__*/React.createElement("span", {
+      className: "dtable-font ".concat(rateShowType),
+      ref: this.tooltipRef
+    }), editable && /*#__PURE__*/React.createElement(UncontrolledTooltip, {
+      placement: "bottom",
+      target: this.tooltipRef
+    }, rateItemIndex));
+  }
+}
+export default RateItem;

package/dist/basic-sdk/extension/plugins/seatable-tables/seatable-settings/filter-setter/filter-popover.css

@@ -0,0 +1,30 @@
+.filter-popover .popover {
+  max-width: none;
+  min-width: 300px;
+}
+
+.filter-popover .popover-add-tool {
+  border-top: none;
+  color: #555555;
+}
+
+.filter-popover .popover-add-tool.disabled {
+  color: #c2c2c2;
+}
+
+.filter-popover .popover-add-tool.disabled:hover {
+  cursor: not-allowed;
+  background: #fff;
+}
+
+.filter-popover .popover-add-tool .popover-add-icon {
+  margin-right: 14px;
+}
+
+.filter-popover .filter-popover-footer {
+  display: flex;
+  align-items: center;
+  justify-content: flex-end;
+  padding: 1rem;
+  border-top: 1px solid #e9ecef;
+}