choerodon-ui/es/cascader/index.js

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

import _extends from "@babel/runtime/helpers/extends";
import _defineProperty from "@babel/runtime/helpers/defineProperty";
import _objectWithoutProperties from "@babel/runtime/helpers/objectWithoutProperties";
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 React, { Component } from 'react';
import arrayTreeFilter from 'array-tree-filter';
import classNames from 'classnames';
import omit from 'lodash/omit';
import isEmpty from 'lodash/isEmpty';
import Input from '../input';
import Icon from '../icon';
import RcCascader from '../rc-components/cascader';
import KeyCode from '../_util/KeyCode';
import { Size } from '../_util/enum';
import { getPrefixCls } from '../configure';
import LocaleReceiver from '../locale-provider/LocaleReceiver';
import enUS from '../rc-components/cascader/locale/en_US';
export var MenuMode;

(function (MenuMode) {
  MenuMode["single"] = "single";
  MenuMode["multiple"] = "multiple";
})(MenuMode || (MenuMode = {}));

function highlightKeyword(str, keyword, prefixCls) {
  return str.split(keyword).map(function (node, index) {
    return index === 0 ? node : [React.createElement("span", {
      className: "".concat(prefixCls, "-menu-item-keyword"),
      key: "seperator"
    }, keyword), node];
  });
}

function defaultFilterOption(inputValue, path) {
  return path.some(function (option) {
    return option.label.indexOf(inputValue) > -1;
  });
}

function defaultRenderFilteredOption(inputValue, path, prefixCls) {
  return path.map(function (_ref, index) {
    var label = _ref.label;
    var node = label.indexOf(inputValue) > -1 ? highlightKeyword(label, inputValue, prefixCls) : label;
    return index === 0 ? node : [' / ', node];
  });
}

function defaultSortFilteredOption(a, b, inputValue) {
  function callback(elem) {
    return elem.label.indexOf(inputValue) > -1;
  }

  return a.findIndex(callback) - b.findIndex(callback);
}

var defaultDisplayRender = function defaultDisplayRender(label) {
  return label.join(' / ');
};

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

  var _super = _createSuper(Cascader);

  function Cascader(props) {
    var _this;

    _classCallCheck(this, Cascader);

    _this = _super.call(this, props);

    _this.handleChange = function (value, selectedOptions) {
      _this.setState({
        inputValue: ''
      });

      if (selectedOptions[0].__IS_FILTERED_OPTION) {
        var unwrappedValue = value[0];
        var unwrappedSelectedOptions = selectedOptions[0].path;

        _this.setValue(unwrappedValue, unwrappedSelectedOptions);

        return;
      }

      _this.setValue(value, selectedOptions);
    };

    _this.handlePopupVisibleChange = function (popupVisible) {
      if (!('popupVisible' in _this.props)) {
        var inputValue = _this.state.inputValue;

        _this.setState({
          popupVisible: popupVisible,
          inputFocused: popupVisible,
          inputValue: popupVisible ? inputValue : ''
        });
      }

      var onPopupVisibleChange = _this.props.onPopupVisibleChange;

      if (onPopupVisibleChange) {
        onPopupVisibleChange(popupVisible);
      }
    };

    _this.handleInputBlur = function () {
      _this.setState({
        inputFocused: false
      });
    };

    _this.handleInputClick = function (e) {
      var _this$state = _this.state,
          inputFocused = _this$state.inputFocused,
          popupVisible = _this$state.popupVisible; // Prevent `Trigger` behaviour.

      if (inputFocused || popupVisible) {
        e.stopPropagation();
        e.nativeEvent.stopImmediatePropagation();
      }
    };

    _this.handleKeyDown = function (e) {
      if (e.keyCode === KeyCode.BACKSPACE) {
        e.stopPropagation();
      }
    };

    _this.handleInputChange = function (e) {
      var inputValue = e.target.value;

      _this.setState({
        inputValue: inputValue
      });
    };

    _this.clearSelection = function (e) {
      e.preventDefault();
      e.stopPropagation();
      var inputValue = _this.state.inputValue;

      if (!inputValue) {
        _this.setValue([]);

        _this.handlePopupVisibleChange(false);
      } else {
        _this.setState({
          inputValue: ''
        });
      }
    };

    _this.setValue = function (value) {
      var selectedOptions = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];

      if (!('value' in _this.props)) {
        _this.setState({
          value: value
        });
      }

      var onChange = _this.props.onChange;

      if (onChange) {
        onChange(value, selectedOptions);
      }
    };

    _this.saveInput = function (node) {
      _this.input = node;
    };

    _this.state = {
      value: props.value || props.defaultValue || [],
      inputValue: '',
      inputFocused: false,
      popupVisible: props.popupVisible,
      flattenOptions: props.showSearch && _this.flattenTree(props.options, props.changeOnSelect)
    };
    return _this;
  }

  _createClass(Cascader, [{
    key: "componentWillReceiveProps",
    value: function componentWillReceiveProps(nextProps) {
      if ('value' in nextProps) {
        this.setState({
          value: nextProps.value || []
        });
      }

      if ('popupVisible' in nextProps) {
        this.setState({
          popupVisible: nextProps.popupVisible
        });
      }

      var options = this.props.options;

      if (nextProps.showSearch && options !== nextProps.options) {
        this.setState({
          flattenOptions: this.flattenTree(nextProps.options, nextProps.changeOnSelect)
        });
      }
    }
  }, {
    key: "getLabel",
    value: function getLabel() {
      var _this$props = this.props,
          options = _this$props.options,
          _this$props$displayRe = _this$props.displayRender,
          displayRender = _this$props$displayRe === void 0 ? defaultDisplayRender : _this$props$displayRe;
      var value = this.state.value;
      var unwrappedValue = Array.isArray(value[0]) ? value[0] : value;
      var selectedOptions = arrayTreeFilter(options, function (o, level) {
        return o.value === unwrappedValue[level];
      });
      var label = selectedOptions.map(function (o) {
        return o.label;
      });
      return displayRender(label, selectedOptions);
    }
  }, {
    key: "flattenTree",
    value: function flattenTree(options, changeOnSelect) {
      var _this2 = this;

      var ancestor = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
      var flattenOptions = [];
      options.forEach(function (option) {
        var path = ancestor.concat(option);

        if (changeOnSelect || !option.children || !option.children.length) {
          flattenOptions.push(path);
        }

        if (option.children) {
          flattenOptions = flattenOptions.concat(_this2.flattenTree(option.children, changeOnSelect, path));
        }
      });
      return flattenOptions;
    }
  }, {
    key: "generateFilteredOptions",
    value: function generateFilteredOptions(prefixCls) {
      var _this$props2 = this.props,
          showSearch = _this$props2.showSearch,
          notFoundContent = _this$props2.notFoundContent;
      var _showSearch$filter = showSearch.filter,
          filter = _showSearch$filter === void 0 ? defaultFilterOption : _showSearch$filter,
          _showSearch$render = showSearch.render,
          render = _showSearch$render === void 0 ? defaultRenderFilteredOption : _showSearch$render,
          _showSearch$sort = showSearch.sort,
          sort = _showSearch$sort === void 0 ? defaultSortFilteredOption : _showSearch$sort;
      var _this$state2 = this.state,
          flattenOptions = _this$state2.flattenOptions,
          inputValue = _this$state2.inputValue;
      var filtered = flattenOptions.filter(function (path) {
        return filter(inputValue, path);
      }).sort(function (a, b) {
        return sort(a, b, inputValue);
      });

      if (filtered.length > 0) {
        return filtered.map(function (path) {
          return {
            __IS_FILTERED_OPTION: true,
            path: path,
            label: render(inputValue, path, prefixCls),
            value: path.map(function (o) {
              return o.value;
            }),
            disabled: path.some(function (o) {
              return o.disabled;
            })
          };
        });
      }

      return [{
        label: notFoundContent,
        value: 'ANT_CASCADER_NOT_FOUND',
        disabled: true
      }];
    }
  }, {
    key: "focus",
    value: function focus() {
      this.input.focus();
    }
  }, {
    key: "blur",
    value: function blur() {
      this.input.blur();
    }
  }, {
    key: "render",
    value: function render() {
      var _classNames,
          _classNames2,
          _classNames3,
          _this3 = this;

      var props = this.props,
          state = this.state;

      var customizePrefixCls = props.prefixCls,
          customizeInputPrefixCls = props.inputPrefixCls,
          children = props.children,
          placeholder = props.placeholder,
          size = props.size,
          disabled = props.disabled,
          className = props.className,
          style = props.style,
          _props$showSearch = props.showSearch,
          showSearch = _props$showSearch === void 0 ? false : _props$showSearch,
          allowClear = props.allowClear,
          otherProps = _objectWithoutProperties(props, ["prefixCls", "inputPrefixCls", "children", "placeholder", "size", "disabled", "className", "style", "showSearch", "allowClear"]);

      var prefixCls = getPrefixCls('cascader', customizePrefixCls);
      var inputPrefixCls = getPrefixCls('input', customizeInputPrefixCls);
      var defaultValue = props.defaultValue;
      var value = state.value;
      var sizeCls = classNames((_classNames = {}, _defineProperty(_classNames, "".concat(inputPrefixCls, "-lg"), size === Size.large), _defineProperty(_classNames, "".concat(inputPrefixCls, "-sm"), size === Size.small), _classNames));
      var arrowCls = classNames((_classNames2 = {}, _defineProperty(_classNames2, "".concat(prefixCls, "-picker-arrow"), true), _defineProperty(_classNames2, "".concat(prefixCls, "-picker-arrow-expand"), state.popupVisible), _classNames2));
      var pickerCls = classNames(className, "".concat(prefixCls, "-picker"), (_classNames3 = {}, _defineProperty(_classNames3, "".concat(prefixCls, "-picker-with-value"), state.inputValue), _defineProperty(_classNames3, "".concat(prefixCls, "-picker-disabled"), disabled), _defineProperty(_classNames3, "".concat(prefixCls, "-picker-").concat(size), !!size), _defineProperty(_classNames3, "".concat(inputPrefixCls, "-has-value"), !!defaultValue || value.length), _defineProperty(_classNames3, "".concat(inputPrefixCls, "-focused"), state.popupVisible), _classNames3)); // Fix bug of https://github.com/facebook/react/pull/5004
      // and https://fb.me/react-unknown-prop

      var inputProps = omit(otherProps, ['onChange', 'options', 'popupPlacement', 'transitionName', 'displayRender', 'onPopupVisibleChange', 'changeOnSelect', 'expandTrigger', 'popupVisible', 'getPopupContainer', 'loadData', 'popupClassName', 'filterOption', 'renderFilteredOption', 'sortFilteredOption', 'notFoundContent', 'allowClear', 'singleMenuStyle', 'singleMenuItemStyle', 'singlePleaseRender', 'singleMenuItemRender', 'menuMode', 'defaultValue']);
      var options = props.options;

      if (state.inputValue) {
        options = this.generateFilteredOptions(prefixCls);
      } // Dropdown menu should keep previous status until it is fully closed.


      if (!state.popupVisible) {
        options = this.cachedOptions;
      } else {
        this.cachedOptions = options;
      }

      var dropdownMenuColumnStyle = {};
      var isNotFound = (options || []).length === 1 && options[0].value === 'ANT_CASCADER_NOT_FOUND';

      if (isNotFound) {
        dropdownMenuColumnStyle.height = 'auto'; // Height of one row.
      } // The default value of `matchInputWidth` is `true`


      var resultListMatchInputWidth = showSearch.matchInputWidth !== false;

      if (resultListMatchInputWidth && state.inputValue && this.input) {
        dropdownMenuColumnStyle.width = this.input.input.offsetWidth;
      }

      var clearIcon = allowClear && !disabled && value.length > 0 || state.inputValue ? React.createElement(Icon, {
        type: "close",
        className: "".concat(prefixCls, "-picker-clear"),
        onClick: this.clearSelection
      }) : null;
      var input = children || React.createElement("span", {
        style: style,
        className: pickerCls
      }, React.createElement("span", {
        className: "".concat(prefixCls, "-picker-label")
      }, this.getLabel()), React.createElement(Input, _extends({}, inputProps, {
        ref: this.saveInput,
        prefixCls: inputPrefixCls,
        placeholder: value && value.length > 0 ? undefined : placeholder,
        className: "".concat(prefixCls, "-input ").concat(sizeCls),
        value: state.inputValue,
        disabled: disabled,
        readOnly: !showSearch,
        autoComplete: "off",
        onClick: showSearch ? this.handleInputClick : undefined,
        onBlur: showSearch ? this.handleInputBlur : undefined,
        onKeyDown: this.handleKeyDown,
        onChange: showSearch ? this.handleInputChange : undefined
      })), clearIcon, React.createElement(Icon, {
        type: "arrow_drop_down",
        className: arrowCls
      }));
      /**
       * 添加多语言配置
       * @param locale any
       */

      var renderCascader = function renderCascader(locale) {
        // 只配置部分语言其他英语即可
        var cascaderLocal = isEmpty(locale) ? enUS.Cascader : locale;
        return React.createElement(RcCascader, _extends({}, props, {
          inputPrefixCls: inputPrefixCls,
          prefixCls: prefixCls,
          options: options,
          value: value,
          popupVisible: state.popupVisible,
          onPopupVisibleChange: _this3.handlePopupVisibleChange,
          onChange: _this3.handleChange,
          dropdownMenuColumnStyle: dropdownMenuColumnStyle,
          locale: cascaderLocal
        }), input);
      };

      return React.createElement(LocaleReceiver, {
        componentName: "Cascader",
        defaultLocale: enUS
      }, renderCascader);
    }
  }]);

  return Cascader;
}(Component);

export { Cascader as default };
Cascader.displayName = 'Cascader';
Cascader.defaultProps = {
  placeholder: 'Please select',
  transitionName: 'slide-up',
  popupPlacement: 'bottomLeft',
  options: [],
  disabled: false,
  allowClear: true,
  notFoundContent: 'Not Found',
  menuMode: MenuMode.multiple
};
//# sourceMappingURL=index.js.map