choerodon-ui/pro/es/table/query-bar/index.js

An enterprise-class UI design language and React-based implementation

import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
import _objectSpread from "@babel/runtime/helpers/objectSpread2";
import _objectWithoutProperties from "@babel/runtime/helpers/objectWithoutProperties";
import _regeneratorRuntime from "@babel/runtime/regenerator";
import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
import _createClass from "@babel/runtime/helpers/createClass";
import _inherits from "@babel/runtime/helpers/inherits";
import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
import _extends from "@babel/runtime/helpers/extends";

function _createSuper(Derived) {
  function isNativeReflectConstruct() {
    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
    if (Reflect.construct.sham) return false;
    if (typeof Proxy === "function") return true;

    try {
      Date.prototype.toString.call(Reflect.construct(Date, [], function () {}));
      return true;
    } catch (e) {
      return false;
    }
  }

  return function () {
    var Super = _getPrototypeOf(Derived),
        result;

    if (isNativeReflectConstruct()) {
      var NewTarget = _getPrototypeOf(this).constructor;

      result = Reflect.construct(Super, arguments, NewTarget);
    } else {
      result = Super.apply(this, arguments);
    }

    return _possibleConstructorReturn(this, result);
  };
}

import { __decorate } from "tslib";
import React, { cloneElement, useState, Component, isValidElement } from 'react';
import { observer } from 'mobx-react';
import { action, isArrayLike, observable } from 'mobx';
import isObject from 'lodash/isObject';
import isString from 'lodash/isString';
import isNumber from 'lodash/isNumber';
import reduce from 'lodash/reduce';
import { pxToRem } from '../../../../es/_util/UnitConvertor';
import { getConfig } from '../../../../es/configure';
import Icon from '../../../../es/icon';
import { ProgressStatus } from '../../../../es/progress/enum';
import noop from 'lodash/noop';
import { TableButtonType, TableQueryBarType } from '../enum';
import TableButtons from './TableButtons';
import Table from '../Table';
import Button from '../../button/Button';
import { ButtonType, ButtonColor } from '../../button/enum';
import { DataSetStatus, FieldType, DataSetExportStatus } from '../../data-set/enum';
import { $l } from '../../locale-context';
import TableContext from '../TableContext';
import autobind from '../../_util/autobind';
import DataSet from '../../data-set';
import Modal from '../../modal';
import Progress from '../../progress';
import Column from '../Column';
import { getEditorByField, getPlaceholderByField } from '../utils';
import TableToolBar from './TableToolBar';
import TableFilterBar from './TableFilterBar';
import TableAdvancedQueryBar from './TableAdvancedQueryBar';
import TableProfessionalBar from './TableProfessionalBar';
import TableDynamicFilterBar from './TableDynamicFilterBar';
import { findBindFieldBy, exportExcel } from '../../data-set/utils';
import Dropdown from '../../dropdown/Dropdown';
import Menu from '../../menu';
import TextField from '../../text-field';
var ExportBody = observer(function (props) {
  var dataSet = props.dataSet,
      prefixCls = props.prefixCls;
  var exportMessage = $l('Table', 'export_ing');
  var exportProgress = {
    percent: 1,
    status: ProgressStatus.active
  };

  switch (dataSet.exportStatus) {
    case DataSetExportStatus.start:
      exportProgress = {
        percent: 1,
        status: ProgressStatus.active
      };
      break;

    case DataSetExportStatus.exporting:
      exportProgress = {
        percent: dataSet.exportProgress,
        status: ProgressStatus.active
      };
      break;

    case DataSetExportStatus.progressing:
      exportProgress = {
        percent: dataSet.exportProgress,
        status: ProgressStatus.active
      };
      break;

    case DataSetExportStatus.failed:
      exportMessage = $l('Table', 'export_failed');
      exportProgress = {
        percent: 50,
        status: ProgressStatus.exception
      };
      break;

    case DataSetExportStatus.success:
      exportMessage = $l('Table', 'export_success');
      exportProgress = {
        percent: 100,
        status: ProgressStatus.success
      };
      break;

    default:
      break;
  }

  return React.createElement("div", {
    className: "".concat(prefixCls, "-export-progress-body")
  }, React.createElement("span", null, exportMessage), React.createElement(Progress, _extends({}, exportProgress)));
});
var ExportFooter = observer(function (props) {
  var dataSet = props.dataSet,
      prefixCls = props.prefixCls,
      exportButton = props.exportButton;

  var _useState = useState(dataSet.name || $l('Table', 'defalut_export')),
      _useState2 = _slicedToArray(_useState, 2),
      username = _useState2[0],
      setUsername = _useState2[1];

  var handleClick = function handleClick() {
    exportButton(dataSet.exportStatus, username);
  };

  var _useState3 = useState(undefined),
      _useState4 = _slicedToArray(_useState3, 2),
      messageTimeout = _useState4[0],
      setMessageTimeout = _useState4[1];

  React.useEffect(function () {
    var currentTimeout = null;
    currentTimeout = setTimeout(function () {
      if (dataSet && dataSet.exportStatus !== DataSetExportStatus.success && dataSet.exportStatus !== DataSetExportStatus.failed) {
        setMessageTimeout($l('Table', 'export_waiting'));
      }
    }, 5000);
    return function () {
      if (currentTimeout) {
        clearTimeout(currentTimeout);
      }
    };
  }, []);
  return React.createElement("div", {
    className: "".concat(prefixCls, "-export-progress-footer")
  }, dataSet.exportStatus === DataSetExportStatus.failed && React.createElement(React.Fragment, null, React.createElement("span", null, $l('Table', 'export_break')), React.createElement(Button, {
    onClick: handleClick
  }, $l('Table', 'retry_button'))), dataSet.exportStatus === DataSetExportStatus.success && React.createElement(React.Fragment, null, React.createElement("div", null, React.createElement("span", null, "".concat($l('Table', 'file_name'), ":")), React.createElement(TextField, {
    value: username,
    onChange: function onChange(value) {
      setUsername(value);
    }
  })), React.createElement(Button, {
    color: ButtonColor.primary,
    onClick: handleClick
  }, $l('Table', 'download_button'))), dataSet.exportStatus !== DataSetExportStatus.success && dataSet.exportStatus !== DataSetExportStatus.failed && React.createElement(React.Fragment, null, React.createElement("span", null, messageTimeout || $l('Table', 'export_operating')), React.createElement(Button, {
    color: ButtonColor.gray,
    onClick: handleClick
  }, $l('Table', 'cancel_button'))));
});

var TableQueryBar =
/*#__PURE__*/
function (_Component) {
  _inherits(TableQueryBar, _Component);

  var _super = _createSuper(TableQueryBar);

  function TableQueryBar() {
    var _this;

    _classCallCheck(this, TableQueryBar);

    _this = _super.apply(this, arguments);
    /**
     * 点击汇总条展开收起
     * @param summary
     */

    _this.openMore = function (summary) {
      if (_this.moreSummary && _this.moreSummary.length) {
        _this.moreSummary = [];
      } else {
        _this.moreSummary = _this.renderSummary(summary);
      }

      return _this.moreSummary;
    };

    return _this;
  }

  _createClass(TableQueryBar, [{
    key: "componentWillUnmount",
    value: function componentWillUnmount() {
      if (this.exportModal) {
        this.exportModal.close(true);
      }
    }
  }, {
    key: "handleButtonCreate",
    value: function handleButtonCreate() {
      var dataSet = this.context.tableStore.dataSet;
      dataSet.create({}, 0);
    }
  }, {
    key: "handleButtonSubmit",
    value: function handleButtonSubmit() {
      var dataSet = this.context.tableStore.dataSet;
      return dataSet.submit();
    }
  }, {
    key: "handleButtonDelete",
    value: function handleButtonDelete() {
      var dataSet = this.context.tableStore.dataSet;
      return dataSet["delete"](dataSet.selected);
    }
  }, {
    key: "handleButtonRemove",
    value: function handleButtonRemove() {
      var dataSet = this.context.tableStore.dataSet;
      dataSet.remove(dataSet.selected);
    }
  }, {
    key: "handleButtonReset",
    value: function handleButtonReset() {
      var dataSet = this.context.tableStore.dataSet;
      dataSet.reset();
    }
  }, {
    key: "handleQueryReset",
    value: function handleQueryReset() {
      var queryDataSet = this.context.tableStore.dataSet.queryDataSet;

      if (queryDataSet) {
        var current = queryDataSet.current;

        if (current) {
          current.reset();
        }

        this.handleQuery();
      }
    }
  }, {
    key: "handleExpandAll",
    value: function handleExpandAll() {
      var tableStore = this.context.tableStore;
      tableStore.expandAll();
    }
  }, {
    key: "handleCollapseAll",
    value: function handleCollapseAll() {
      var tableStore = this.context.tableStore;
      tableStore.collapseAll();
    }
  }, {
    key: "handleButtonExport",
    value: function () {
      var _handleButtonExport = _asyncToGenerator(
      /*#__PURE__*/
      _regeneratorRuntime.mark(function _callee() {
        var tableStore, columnHeaders;
        return _regeneratorRuntime.wrap(function _callee$(_context) {
          while (1) {
            switch (_context.prev = _context.next) {
              case 0:
                tableStore = this.context.tableStore;
                _context.next = 3;
                return tableStore.getColumnHeaders();

              case 3:
                columnHeaders = _context.sent;
                this.exportDataSet = new DataSet({
                  data: columnHeaders,
                  paging: false
                });
                this.exportDataSet.selectAll();
                this.exportModal = Modal.open({
                  title: $l('Table', 'choose_export_columns'),
                  children: React.createElement(React.Fragment, null, React.createElement(Table, {
                    dataSet: this.exportDataSet,
                    style: {
                      height: pxToRem(300)
                    }
                  }, React.createElement(Column, {
                    header: $l('Table', 'column_name'),
                    name: "label",
                    resizable: false
                  }))),
                  closable: true,
                  okText: $l('Table', 'export_button'),
                  onOk: this.handleExport,
                  style: {
                    width: pxToRem(400)
                  }
                });

              case 7:
              case "end":
                return _context.stop();
            }
          }
        }, _callee, this);
      }));

      function handleButtonExport() {
        return _handleButtonExport.apply(this, arguments);
      }

      return handleButtonExport;
    }()
  }, {
    key: "handleQuery",
    value: function handleQuery() {
      var dataSet = this.context.tableStore.dataSet;
      return dataSet.query();
    }
  }, {
    key: "handleExport",
    value: function handleExport() {
      var _this2 = this;

      var selected = this.exportDataSet.selected;
      var clientExportQuantity = this.props.clientExportQuantity,
          _this$context$tableSt = this.context.tableStore,
          prefixCls = _this$context$tableSt.prefixCls,
          dataSet = _this$context$tableSt.dataSet;

      if (selected.length) {
        var exportModal = this.exportModal;
        dataSet["export"](selected.reduce(function (columns, record) {
          var myName = record.get('name');
          var myField = dataSet.getField(myName);

          if (myField && myField.type === FieldType.object) {
            var bindField = findBindFieldBy(myField, dataSet.fields, 'textField');

            if (bindField) {
              myName = bindField.name;
            }
          }

          columns[myName] = record.get('label');
          return columns;
        }, {}), clientExportQuantity).then(function (exportData) {
          _this2.exportData = exportData;
        });

        if (exportModal) {
          exportModal.update({
            title: $l('Table', 'export_button'),
            children: React.createElement(ExportBody, {
              prefixCls: prefixCls,
              dataSet: dataSet
            }),
            onCancel: this.handleExportButton,
            footer: React.createElement(ExportFooter, {
              prefixCls: prefixCls,
              exportButton: this.handleExportButton,
              exportModal: exportModal,
              dataSet: dataSet
            })
          });
        }
      }

      return false;
    }
  }, {
    key: "handleExportButton",
    value: function handleExportButton(data, filename) {
      var dataSet = this.context.tableStore.dataSet;

      if (data === DataSetExportStatus.success) {
        if (this.exportData) {
          exportExcel(this.exportData, filename);
          this.exportModal.close();
          this.exportData = null;
        }
      } else if (data === DataSetExportStatus.failed) {
        this.exportData = null;
        this.handleExport();
      } else {
        this.exportModal.close();
        this.exportData = null;
      }

      dataSet.exportStatus = undefined;
    }
  }, {
    key: "getButtonProps",
    value: function getButtonProps(type) {
      var _this$context = this.context,
          isTree = _this$context.isTree,
          dataSet = _this$context.tableStore.dataSet;
      var disabled = dataSet.status !== DataSetStatus.ready;

      switch (type) {
        case TableButtonType.add:
          return {
            icon: 'playlist_add',
            onClick: this.handleButtonCreate,
            children: $l('Table', 'create_button'),
            disabled: disabled || (dataSet.parent ? !dataSet.parent.current : false)
          };

        case TableButtonType.save:
          return {
            icon: 'save',
            onClick: this.handleButtonSubmit,
            children: $l('Table', 'save_button'),
            type: ButtonType.submit,
            disabled: disabled
          };

        case TableButtonType["delete"]:
          return {
            icon: 'delete',
            onClick: this.handleButtonDelete,
            children: $l('Table', 'delete_button'),
            disabled: disabled || dataSet.selected.length === 0
          };

        case TableButtonType.remove:
          return {
            icon: 'remove_circle',
            onClick: this.handleButtonRemove,
            children: $l('Table', 'remove_button'),
            disabled: disabled || dataSet.selected.length === 0
          };

        case TableButtonType.reset:
          return {
            icon: 'undo',
            onClick: this.handleButtonReset,
            children: $l('Table', 'reset_button'),
            type: ButtonType.reset
          };

        case TableButtonType.query:
          return {
            icon: 'search',
            onClick: this.handleQuery,
            children: $l('Table', 'query_button')
          };

        case TableButtonType["export"]:
          return {
            icon: 'export',
            onClick: this.handleButtonExport,
            children: $l('Table', 'export_button')
          };

        case TableButtonType.expandAll:
          return isTree ? {
            icon: 'add_box',
            onClick: this.handleExpandAll,
            children: $l('Table', 'expand_button')
          } : undefined;

        case TableButtonType.collapseAll:
          return isTree ? {
            icon: 'short_text',
            onClick: this.handleCollapseAll,
            children: $l('Table', 'collapse_button')
          } : undefined;

        default:
      }
    }
    /**
     * 渲染表头汇总列
     * @param summary
     */

  }, {
    key: "renderSummary",
    value: function renderSummary(summary) {
      var _this$props = this.props,
          summaryBar = _this$props.summaryBar,
          _this$props$summaryFi = _this$props.summaryFieldsLimit,
          summaryFieldsLimit = _this$props$summaryFi === void 0 ? 3 : _this$props$summaryFi,
          _this$context$tableSt2 = this.context.tableStore,
          prefixCls = _this$context$tableSt2.prefixCls,
          dataSet = _this$context$tableSt2.dataSet;
      var fieldTypeArr = [FieldType.currency, FieldType.number];

      if (summaryBar && summary && summary.length) {
        return summary.map(function (summaryCol, index) {
          var field = dataSet.getField(summaryCol);
          var hasSeparate = summaryBar.length > summaryFieldsLimit || index !== summaryBar.length - 1;

          if (isString(summaryCol) && field && fieldTypeArr.includes(field.type)) {
            var summaryValue = reduce(dataSet.data.map(function (record) {
              return isNumber(record.get(summaryCol)) ? record.get(summaryCol) : 0;
            }), function (sum, n) {
              return sum + n;
            });
            return React.createElement("div", {
              key: field.get('name')
            }, React.createElement("div", {
              className: "".concat(prefixCls, "-summary-col")
            }, React.createElement("div", {
              className: "".concat(prefixCls, "-summary-col-label"),
              title: field.get('label')
            }, field.get('label'), ":"), React.createElement("div", {
              className: "".concat(prefixCls, "-summary-col-value"),
              title: summaryValue
            }, summaryValue)), hasSeparate && React.createElement("div", {
              className: "".concat(prefixCls, "-summary-col-separate")
            }, React.createElement("div", null)));
          }

          if (typeof summaryCol === 'function') {
            var summaryObj = summaryCol({
              summaryFieldsLimit: summaryFieldsLimit,
              dataSet: dataSet
            });
            return React.createElement("div", {
              key: isString(summaryObj.label) ? summaryObj.label : ''
            }, React.createElement("div", {
              className: "".concat(prefixCls, "-summary-col")
            }, React.createElement("div", {
              className: "".concat(prefixCls, "-summary-col-label"),
              title: isString(summaryObj.label) ? summaryObj.label : ''
            }, summaryObj.label, ":"), React.createElement("div", {
              className: "".concat(prefixCls, "-summary-col-value"),
              title: isString(summaryObj.value) || isNumber(summaryObj.value) ? summaryObj.value.toString() : ''
            }, summaryObj.value)), hasSeparate && React.createElement("div", {
              className: "".concat(prefixCls, "-summary-col-separate")
            }, React.createElement("div", null)));
          }

          return null;
        });
      }
    }
    /**
     * 汇总条展开收起按钮
     * @param summary
     */

  }, {
    key: "getMoreSummaryButton",
    value: function getMoreSummaryButton(summary) {
      var _this3 = this;

      var prefixCls = this.context.tableStore.prefixCls;

      if (summary.length) {
        return React.createElement("div", {
          className: "".concat(prefixCls, "-summary-button-more")
        }, React.createElement("a", {
          onClick: function onClick() {
            return _this3.openMore(summary);
          }
        }, $l('Table', 'more'), this.moreSummary && this.moreSummary.length ? React.createElement(Icon, {
          type: 'expand_less'
        }) : React.createElement(Icon, {
          type: 'expand_more'
        })));
      }
    }
    /**
     * 渲染汇总条
     */

  }, {
    key: "getSummaryBar",
    value: function getSummaryBar() {
      var _this$props2 = this.props,
          summaryBar = _this$props2.summaryBar,
          summaryFieldsLimit = _this$props2.summaryFieldsLimit,
          prefixCls = this.context.tableStore.prefixCls;

      if (summaryBar) {
        var currentSummaryBar = this.renderSummary(summaryBar.slice(0, summaryFieldsLimit));
        var moreSummary = summaryBar.slice(summaryFieldsLimit);
        var moreSummaryButton = this.getMoreSummaryButton(moreSummary);
        var width = 170 * Math.min(summaryBar.length, summaryFieldsLimit) + Math.min(summaryBar.length, summaryFieldsLimit);
        return React.createElement("div", {
          className: "".concat(prefixCls, "-summary-group-wrapper")
        }, React.createElement("div", {
          className: "".concat(prefixCls, "-summary-group"),
          style: {
            width: width
          }
        }, currentSummaryBar, this.moreSummary), moreSummaryButton);
      }
    }
    /**
     * buttons 大于 buttonsLimits 放入下拉
     * @param buttonsLimits
     */

  }, {
    key: "getMoreButton",
    value: function getMoreButton(buttonsLimits) {
      var _this4 = this;

      var buttons = this.props.buttons;
      var prefixCls = this.context.tableStore.prefixCls;
      var tableButtonProps = getConfig('tableButtonProps');
      var children = [];

      if (buttons && buttons.length && buttonsLimits) {
        buttons.slice(buttonsLimits).forEach(function (button) {
          var props = {};

          if (isArrayLike(button)) {
            props = button[1] || {};
            button = button[0];
          }

          if (isString(button) && button in TableButtonType) {
            var _props = props,
                afterClick = _props.afterClick,
                buttonProps = _objectWithoutProperties(_props, ["afterClick"]);

            var defaultButtonProps = _this4.getButtonProps(button);

            if (defaultButtonProps) {
              if (afterClick) {
                var onClick = defaultButtonProps.onClick;

                defaultButtonProps.onClick =
                /*#__PURE__*/
                function () {
                  var _ref = _asyncToGenerator(
                  /*#__PURE__*/
                  _regeneratorRuntime.mark(function _callee2(e) {
                    return _regeneratorRuntime.wrap(function _callee2$(_context2) {
                      while (1) {
                        switch (_context2.prev = _context2.next) {
                          case 0:
                            e.persist();
                            _context2.prev = 1;
                            _context2.next = 4;
                            return onClick(e);

                          case 4:
                            _context2.prev = 4;
                            afterClick(e);
                            return _context2.finish(4);

                          case 7:
                          case "end":
                            return _context2.stop();
                        }
                      }
                    }, _callee2, null, [[1,, 4, 7]]);
                  }));

                  return function (_x) {
                    return _ref.apply(this, arguments);
                  };
                }();
              }

              children.push(React.createElement(Menu.Item, {
                key: button,
                className: "".concat(prefixCls, "-button-menu-item")
              }, React.createElement(Button, _extends({
                key: "".concat(button, "-btn")
              }, tableButtonProps, defaultButtonProps, buttonProps))));
            }
          } else if (isValidElement(button)) {
            children.push(React.createElement(Menu.Item, {
              className: "".concat(prefixCls, "-button-menu-item")
            }, cloneElement(button, _objectSpread({}, tableButtonProps, {}, button.props))));
          } else if (isObject(button)) {
            children.push(React.createElement(Menu.Item, {
              className: "".concat(prefixCls, "-button-menu-item")
            }, React.createElement(Button, _extends({}, tableButtonProps, button))));
          }
        });
      }

      var menu = React.createElement(Menu, null, children);
      return React.createElement(Dropdown, {
        overlay: menu,
        key: "dropdown_button"
      }, React.createElement(Button, _extends({}, tableButtonProps, {
        key: "more_button"
      }), $l('Table', 'more'), " ", React.createElement(Icon, {
        type: 'expand_more'
      })));
    }
  }, {
    key: "getButtons",
    value: function getButtons() {
      var _this5 = this;

      var _this$props3 = this.props,
          buttons = _this$props3.buttons,
          summaryBar = _this$props3.summaryBar,
          buttonsLimit = _this$props3.buttonsLimit;
      var children = [];

      if (buttons) {
        // 汇总条存在下 buttons 大于 3 个放入下拉
        var buttonsLimits = summaryBar ? buttonsLimit || 3 : buttonsLimit;
        var tableButtonProps = getConfig('tableButtonProps');
        var buttonsArr = buttons.slice(0, buttonsLimits);
        buttonsArr.forEach(function (button) {
          var props = {};

          if (isArrayLike(button)) {
            props = button[1] || {};
            button = button[0];
          }

          if (isString(button) && button in TableButtonType) {
            var _props2 = props,
                afterClick = _props2.afterClick,
                buttonProps = _objectWithoutProperties(_props2, ["afterClick"]);

            var defaultButtonProps = _this5.getButtonProps(button);

            if (defaultButtonProps) {
              if (afterClick) {
                var onClick = defaultButtonProps.onClick;

                defaultButtonProps.onClick =
                /*#__PURE__*/
                function () {
                  var _ref2 = _asyncToGenerator(
                  /*#__PURE__*/
                  _regeneratorRuntime.mark(function _callee3(e) {
                    return _regeneratorRuntime.wrap(function _callee3$(_context3) {
                      while (1) {
                        switch (_context3.prev = _context3.next) {
                          case 0:
                            e.persist();
                            _context3.prev = 1;
                            _context3.next = 4;
                            return onClick(e);

                          case 4:
                            _context3.prev = 4;
                            afterClick(e);
                            return _context3.finish(4);

                          case 7:
                          case "end":
                            return _context3.stop();
                        }
                      }
                    }, _callee3, null, [[1,, 4, 7]]);
                  }));

                  return function (_x2) {
                    return _ref2.apply(this, arguments);
                  };
                }();
              }

              children.push(React.createElement(Button, _extends({
                key: button
              }, tableButtonProps, defaultButtonProps, buttonProps)));
            }
          } else if (isValidElement(button)) {
            children.push(cloneElement(button, _objectSpread({}, tableButtonProps, {}, button.props)));
          } else if (isObject(button)) {
            children.push(React.createElement(Button, _extends({}, tableButtonProps, button)));
          }
        });

        if (buttonsLimits && buttons.length > buttonsLimits) {
          var moreButton = this.getMoreButton(buttonsLimits);
          children.push(moreButton);
        }
      }

      return children;
    }
  }, {
    key: "getQueryFields",
    value: function getQueryFields() {
      var _this$context$tableSt3 = this.context.tableStore,
          dataSet = _this$context$tableSt3.dataSet,
          queryBar = _this$context$tableSt3.queryBar,
          queryFields = this.props.queryFields;
      var queryDataSet = dataSet.queryDataSet;
      var result = [];

      if (queryDataSet) {
        var fields = queryDataSet.fields;
        return _toConsumableArray(fields.entries()).reduce(function (list, _ref3) {
          var _ref4 = _slicedToArray(_ref3, 2),
              name = _ref4[0],
              field = _ref4[1];

          if (!field.get('bind') && !name.includes('__tls')) {
            var element = queryFields[name];
            var filterBarProps = {};

            if (queryBar === TableQueryBarType.filterBar) {
              var placeholder = isValidElement(element) && element.props.placeholder ? element.props.placeholder : getPlaceholderByField(field);
              filterBarProps = {
                placeholder: placeholder
              };
            }

            var props = _objectSpread({
              key: name,
              name: name,
              dataSet: queryDataSet,
              isFlat: queryBar === TableQueryBarType.filterBar
            }, filterBarProps);

            list.push(isValidElement(element) ? cloneElement(element, props) : cloneElement(getEditorByField(field, queryBar !== TableQueryBarType.professionalBar, queryBar === TableQueryBarType.filterBar), _objectSpread({}, props, {}, isObject(element) ? element : {})));
          }

          return list;
        }, result);
      }

      return result;
    }
  }, {
    key: "renderToolBar",
    value: function renderToolBar(props) {
      var prefixCls = this.context.tableStore.prefixCls;
      return React.createElement(TableToolBar, _extends({
        key: "toolbar",
        prefixCls: prefixCls
      }, props));
    }
  }, {
    key: "renderFilterBar",
    value: function renderFilterBar(props) {
      var prefixCls = this.context.tableStore.prefixCls;
      var _this$props4 = this.props,
          filterBarFieldName = _this$props4.filterBarFieldName,
          filterBarPlaceholder = _this$props4.filterBarPlaceholder;
      return React.createElement(TableFilterBar, _extends({
        key: "toolbar",
        prefixCls: prefixCls,
        paramName: filterBarFieldName,
        placeholder: filterBarPlaceholder
      }, props));
    }
  }, {
    key: "renderAdvancedQueryBar",
    value: function renderAdvancedQueryBar(props) {
      var prefixCls = this.context.tableStore.prefixCls;
      return React.createElement(TableAdvancedQueryBar, _extends({
        key: "toolbar",
        prefixCls: prefixCls
      }, props));
    }
  }, {
    key: "renderProfessionalBar",
    value: function renderProfessionalBar(props) {
      var prefixCls = this.context.tableStore.prefixCls;
      return React.createElement(TableProfessionalBar, _extends({
        key: "toolbar",
        prefixCls: prefixCls
      }, props));
    }
  }, {
    key: "renderDynamicFilterBar",
    value: function renderDynamicFilterBar(props) {
      var _this$props5 = this.props,
          dynamicFilterBar = _this$props5.dynamicFilterBar,
          searchCode = _this$props5.searchCode;
      var prefixCls = this.context.tableStore.prefixCls;
      return React.createElement(TableDynamicFilterBar, _extends({
        key: "toolbar",
        searchCode: searchCode,
        dynamicFilterBar: dynamicFilterBar,
        prefixCls: prefixCls
      }, props));
    }
  }, {
    key: "expandTree",
    value: function expandTree() {
      var tableStore = this.context.tableStore;
      var queryBarProps = tableStore.props.queryBarProps;

      if (typeof queryBarProps.onQuery === 'function') {
        queryBarProps.onQuery();
      }

      tableStore.expandAll();
    }
  }, {
    key: "collapseTree",
    value: function collapseTree() {
      var tableStore = this.context.tableStore;
      var queryBarProps = tableStore.props.queryBarProps;

      if (typeof queryBarProps.onReset === 'function') {
        queryBarProps.onReset();
      }

      tableStore.collapseAll();
    }
  }, {
    key: "render",
    value: function render() {
      var buttons = this.getButtons();
      var summaryBar = this.getSummaryBar();
      var _this$context$tableSt4 = this.context.tableStore,
          dataSet = _this$context$tableSt4.dataSet,
          queryBar = _this$context$tableSt4.queryBar,
          prefixCls = _this$context$tableSt4.prefixCls,
          isTree = _this$context$tableSt4.isTree,
          queryBarProps = _this$context$tableSt4.props.queryBarProps,
          _this$props6 = this.props,
          queryFieldsLimit = _this$props6.queryFieldsLimit,
          summaryFieldsLimit = _this$props6.summaryFieldsLimit,
          pagination = _this$props6.pagination,
          treeQueryExpanded = _this$props6.treeQueryExpanded,
          showQueryBar = this.showQueryBar;

      if (showQueryBar) {
        var queryDataSet = dataSet.queryDataSet;
        var queryFields = this.getQueryFields();

        var tableQueryBarProps = _objectSpread({}, queryBarProps, {}, getConfig('queryBarProps'));

        var onReset = tableQueryBarProps && typeof tableQueryBarProps.onReset === 'function' ? tableQueryBarProps.onReset : noop;
        var onQuery = tableQueryBarProps && typeof tableQueryBarProps.onQuery === 'function' ? tableQueryBarProps.onQuery : noop;

        var props = _objectSpread({}, tableQueryBarProps, {
          dataSet: dataSet,
          queryDataSet: queryDataSet,
          buttons: buttons,
          pagination: pagination,
          queryFields: queryFields,
          queryFieldsLimit: queryFieldsLimit,
          summaryFieldsLimit: summaryFieldsLimit,
          summaryBar: summaryBar,
          onQuery: treeQueryExpanded && isTree ? this.expandTree : onQuery,
          onReset: treeQueryExpanded && isTree ? this.collapseTree : onReset
        });

        if (typeof queryBar === 'function') {
          return queryBar(props);
        }

        switch (queryBar) {
          case TableQueryBarType.normal:
            return this.renderToolBar(props);

          case TableQueryBarType.bar:
            return this.renderFilterBar(props);

          case TableQueryBarType.advancedBar:
            return this.renderAdvancedQueryBar(props);

          case TableQueryBarType.professionalBar:
            return this.renderProfessionalBar(props);

          case TableQueryBarType.filterBar:
            return this.renderDynamicFilterBar(props);

          default:
        }
      }

      return [React.createElement(TableButtons, {
        key: "toolbar",
        prefixCls: prefixCls,
        buttons: buttons
      }, summaryBar), pagination];
    }
  }, {
    key: "showQueryBar",
    get: function get() {
      var showQueryBar = this.props.showQueryBar,
          queryBar = this.context.tableStore.queryBar;
      return showQueryBar !== false && queryBar !== TableQueryBarType.none;
    }
  }]);

  return TableQueryBar;
}(Component);

TableQueryBar.displayName = 'TableQueryBar';
TableQueryBar.contextType = TableContext;
TableQueryBar.defaultProps = {
  summaryFieldsLimit: 3
};

__decorate([observable], TableQueryBar.prototype, "moreSummary", void 0);

__decorate([autobind], TableQueryBar.prototype, "handleButtonCreate", null);

__decorate([autobind], TableQueryBar.prototype, "handleButtonSubmit", null);

__decorate([autobind], TableQueryBar.prototype, "handleButtonDelete", null);

__decorate([autobind], TableQueryBar.prototype, "handleButtonRemove", null);

__decorate([autobind], TableQueryBar.prototype, "handleButtonReset", null);

__decorate([autobind], TableQueryBar.prototype, "handleQueryReset", null);

__decorate([autobind], TableQueryBar.prototype, "handleExpandAll", null);

__decorate([autobind], TableQueryBar.prototype, "handleCollapseAll", null);

__decorate([autobind], TableQueryBar.prototype, "handleButtonExport", null);

__decorate([autobind], TableQueryBar.prototype, "handleQuery", null);

__decorate([autobind], TableQueryBar.prototype, "handleExport", null);

__decorate([autobind, action], TableQueryBar.prototype, "handleExportButton", null);

__decorate([action], TableQueryBar.prototype, "openMore", void 0);

__decorate([autobind], TableQueryBar.prototype, "expandTree", null);

__decorate([autobind], TableQueryBar.prototype, "collapseTree", null);

TableQueryBar = __decorate([observer], TableQueryBar);
export default TableQueryBar;
//# sourceMappingURL=index.js.map