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 _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";

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, 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 handleQuery() {
      var dataSet = this.context.tableStore.dataSet;
      return dataSet.query();
    }
  }, {
    key: "getQueryFields",
    value: function getQueryFields() {
      var _this$context$tableSt = this.context.tableStore,
          dataSet = _this$context$tableSt.dataSet,
          _this$context$tableSt2 = _this$context$tableSt.queryBar,
          _this$context$tableSt3 = _this$context$tableSt2.queryFields,
          queryFields = _this$context$tableSt3 === void 0 ? {} : _this$context$tableSt3,
          type = _this$context$tableSt2.type;
      var queryDataSet = dataSet.queryDataSet;
      var result = [];

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

            if (type === TableQueryBarType.filterBar) {
              var placeholder = 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(isValidElement(element) ? cloneElement(element, props) : cloneElement(getEditorByField(field, current, type !== TableQueryBarType.professionalBar, type === TableQueryBarType.filterBar), _objectSpread({}, props, {}, isObject(element) ? element : {})));
          }
        });
      }

      return result;
    }
  }, {
    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 prefixCls = this.context.tableStore.prefixCls; // @ts-ignore

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

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

        var props = _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