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

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

import _extends from "@babel/runtime/helpers/extends";
import _objectSpread from "@babel/runtime/helpers/objectSpread2";
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 _createSuper from "@babel/runtime/helpers/createSuper";
import _regeneratorRuntime from "@babel/runtime/regenerator";
import { __decorate } from "tslib";
import React, { cloneElement, Component, isValidElement } from 'react';
import { observer } from 'mobx-react';
import isObject from 'lodash/isObject';
import { TableQueryBarType } from '../Table';
import TableContext from '../TableContext';
import autobind from '../../_util/autobind';
import { getEditorByField, getPlaceholderByField } from '../../table/utils';
import TableProfessionalBar from './TableProfessionalBar';
import TableDynamicFilterBar from './TableDynamicFilterBar';

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

  var _super = _createSuper(PerformanceTableQueryBar);

  function PerformanceTableQueryBar() {
    _classCallCheck(this, PerformanceTableQueryBar);

    return _super.apply(this, arguments);
  }

  _createClass(PerformanceTableQueryBar, [{
    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: "handleQuery",
    value: function () {
      var _handleQuery = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
        var _this$context, tableStore, _this$context$tableSt, dataSet, queryDataSet;

        return _regeneratorRuntime.wrap(function _callee$(_context) {
          while (1) {
            switch (_context.prev = _context.next) {
              case 0:
                _this$context = this.context, tableStore = _this$context.tableStore, _this$context$tableSt = _this$context.tableStore, dataSet = _this$context$tableSt.dataSet, queryDataSet = _this$context$tableSt.dataSet.queryDataSet;

                if (!(tableStore.queryBar === TableQueryBarType.filterBar)) {
                  _context.next = 19;
                  break;
                }

                _context.next = 4;
                return dataSet.modifiedCheck(undefined, dataSet, 'query');

              case 4:
                _context.t2 = _context.sent;

                if (!_context.t2) {
                  _context.next = 7;
                  break;
                }

                _context.t2 = queryDataSet;

              case 7:
                _context.t1 = _context.t2;

                if (!_context.t1) {
                  _context.next = 10;
                  break;
                }

                _context.t1 = queryDataSet.current;

              case 10:
                _context.t0 = _context.t1;

                if (!_context.t0) {
                  _context.next = 15;
                  break;
                }

                _context.next = 14;
                return queryDataSet.current.validate();

              case 14:
                _context.t0 = _context.sent;

              case 15:
                if (!_context.t0) {
                  _context.next = 17;
                  break;
                }

                return _context.abrupt("return", dataSet.query());

              case 17:
                _context.next = 20;
                break;

              case 19:
                return _context.abrupt("return", dataSet.query());

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

      function handleQuery() {
        return _handleQuery.apply(this, arguments);
      }

      return handleQuery;
    }()
  }, {
    key: "getQueryFields",
    value: function getQueryFields() {
      var _this$context$tableSt2 = this.context.tableStore,
          dataSet = _this$context$tableSt2.dataSet,
          _this$context$tableSt3 = _this$context$tableSt2.queryBar,
          _this$context$tableSt4 = _this$context$tableSt3.queryFields,
          queryFields = _this$context$tableSt4 === void 0 ? {} : _this$context$tableSt4,
          type = _this$context$tableSt3.type;
      var queryDataSet = dataSet.queryDataSet;
      var result = [];

      if (queryDataSet) {
        var fields = queryDataSet.fields,
            current = queryDataSet.current,
            _queryDataSet$props$f = queryDataSet.props.fields,
            propFields = _queryDataSet$props$f === void 0 ? [] : _queryDataSet$props$f;
        var cloneFields = fields.toJS();

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

            if (type === TableQueryBarType.filterBar) {
              var placeholder = /*#__PURE__*/isValidElement(element) && element.props.placeholder ? element.props.placeholder : getPlaceholderByField(field, current);
              filterBarProps = {
                placeholder: placeholder,
                border: false,
                clearButton: true
              };
            }

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

            result.push( /*#__PURE__*/isValidElement(element) ? /*#__PURE__*/cloneElement(element, props) : /*#__PURE__*/cloneElement(getEditorByField(field, current, type !== TableQueryBarType.professionalBar, type === TableQueryBarType.filterBar), _objectSpread(_objectSpread({}, props), isObject(element) ? element : {})));
          }
        };

        propFields.forEach(function (_ref) {
          var name = _ref.name;

          if (name) {
            var field = cloneFields.get(name);

            if (field) {
              cloneFields["delete"](name);
              processField(field, name);
            }
          }
        });
        cloneFields.forEach(function (field, name) {
          processField(field, name);
        });
      }

      return result;
    }
  }, {
    key: "renderProfessionalBar",
    value: function renderProfessionalBar(props) {
      var prefixCls = this.context.tableStore.prefixCls;
      return /*#__PURE__*/React.createElement(TableProfessionalBar, _extends({
        key: "toolbar",
        prefixCls: prefixCls
      }, props));
    }
  }, {
    key: "renderDynamicFilterBar",
    value: function renderDynamicFilterBar(props) {
      var prefixCls = this.context.tableStore.prefixCls; // @ts-ignore

      return /*#__PURE__*/React.createElement(TableDynamicFilterBar, _extends({
        key: "toolbar",
        prefixCls: prefixCls
      }, props));
    }
  }, {
    key: "render",
    value: function render() {
      var _this$context$tableSt5 = this.context.tableStore,
          queryBar = _this$context$tableSt5.queryBar,
          dataSet = _this$context$tableSt5.dataSet;

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

        var props = _objectSpread(_objectSpread({}, queryBar), {}, {
          queryFields: queryFields,
          queryDataSet: queryDataSet
        });

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

        switch (queryBar.type) {
          case TableQueryBarType.professionalBar:
            return this.renderProfessionalBar(props);

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

          default:
        }
      }

      return null;
    }
  }], [{
    key: "contextType",
    get: function get() {
      return TableContext;
    }
  }]);

  return PerformanceTableQueryBar;
}(Component);

PerformanceTableQueryBar.displayName = 'PerformanceTableQueryBar';
PerformanceTableQueryBar.defaultProps = {
  queryFieldsLimit: 3
};

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

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

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