ming-demo3/lib/components/basic/inputfloat.js

mdf metaui web

"use strict";

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));

var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));

var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));

var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));

var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));

var _react = _interopRequireDefault(require("react"));

var _reactDom = require("react-dom");

var _baseui = require("@mdf/baseui");

var _label = _interopRequireDefault(require("./label"));

var _text = _interopRequireDefault(require("./text"));

var InputFloatControl = function (_React$Component) {
  (0, _inherits2["default"])(InputFloatControl, _React$Component);

  function InputFloatControl(props) {
    var _this;

    (0, _classCallCheck2["default"])(this, InputFloatControl);
    _this = (0, _possibleConstructorReturn2["default"])(this, (0, _getPrototypeOf2["default"])(InputFloatControl).call(this, props));
    _this.state = _this.setStateByProps(_this.props, true);
    return _this;
  }

  (0, _createClass2["default"])(InputFloatControl, [{
    key: "setStateByProps",
    value: function setStateByProps(props, bConstructor) {
      var numPoint = this.formatToDisplayStyle(props.numpoint, 0, 2);
      var value = this.formatToDisplayStyle(props.value, numPoint, "");
      var obj = {};
      obj = {
        bIsNull: props.bIsNull,
        value: value,
        triggerValue: value,
        min: props.min == undefined ? -999999999 : props.min,
        isIncludeMinValue: props.isIncludeMinValue == undefined ? true : props.isIncludeMinValue,
        max: props.max || 999999999,
        isIncludeMaxValue: props.isIncludeMaxValue == undefined ? true : props.isIncludeMaxValue,
        numPoint: numPoint,
        className: props.className || '',
        placeholder: props.placeholder || '',
        id: props.id || ''
      };
      return obj;
    }
  }, {
    key: "componentDidMount",
    value: function componentDidMount() {
      if (this.props.focus) {
        var input = cb.dom((0, _reactDom.findDOMNode)(this.refs.input)).find('input');
        input.length && input[0].focus();
      }
    }
  }, {
    key: "render",
    value: function render() {
      var _this2 = this;

      var id = this.state.id;
      if (id == undefined || id == '') return _react["default"].createElement("div", null, _react["default"].createElement(_baseui.Input, {
        placeholder: this.state.placeholder,
        disabled: !!this.props.disabled,
        visible: !!this.props.visible,
        value: this.state.value,
        onChange: function onChange(e) {
          return _this2.valueChange(e);
        },
        onBlur: function onBlur(e) {
          return _this2.inputOnBlur(e);
        }
      }));else return _react["default"].createElement("div", null, _react["default"].createElement(_baseui.Input, {
        id: id,
        placeholder: this.state.placeholder,
        disabled: !!this.props.disabled,
        visible: !!this.props.visible,
        value: this.state.value,
        onChange: function onChange(e) {
          return _this2.valueChange(e);
        },
        onBlur: function onBlur(e) {
          return _this2.inputOnBlur(e);
        }
      }));
    }
  }, {
    key: "formatToDisplayStyle",
    value: function formatToDisplayStyle(value, numPoint, defaultValue) {
      if (value == undefined) return defaultValue;
      if (isNaN(value)) return defaultValue;
      var str = value.toString();
      if (str.trim() === "") return defaultValue;
      if (numPoint > 0 && str.indexOf('.') < 0) return parseFloat(value).toFixed(numPoint);
      if (numPoint > 0) return parseFloat(value).toFixed(numPoint);
      if (str.indexOf('.') > -1 && numPoint == 0) return parseInt(value);
      return value;
    }
  }, {
    key: "validateInputNumber",
    value: function validateInputNumber(value) {
      var numPoint = this.state.numPoint;
      var regu = /^\-?[0-9]+\.?[0-9]*$/;
      if (value == "-") return true;

      if (value != "") {
        if (!regu.test(value)) {
          return false;
        }

        if (isNaN(value)) {
          return false;
        }

        if (numPoint == 0) {
          if (value.indexOf('.') > -1) {
            return false;
          }
        }

        if (value.indexOf('.') > -1) {
          if (value.split('.')[1].length > numPoint) {
            return false;
          }
        }

        if (Number(value) > this.state.max || this.state.isIncludeMaxValue == false && Number(value) == this.state.max) {
          return false;
        }

        if (Number(value) < this.state.min || this.state.isIncludeMinValue == false && Number(value) == this.state.min) {
          return false;
        }
      }

      return true;
    }
  }, {
    key: "inputOnBlur",
    value: function inputOnBlur(e) {
      var value = this.formatToDisplayStyle(this.state.triggerValue, this.state.numPoint, "");
      this.setState({
        value: value
      });
    }
  }, {
    key: "isNotTriggerNum",
    value: function isNotTriggerNum(value) {
      if (value == "-") return true;
      if (value == "-0") return true;
      if (value == "-0.") return true;
      return false;
    }
  }, {
    key: "valueChange",
    value: function valueChange(e) {
      var value = e.target.value;

      if (this.validateInputNumber(value) == true) {
        this.triggerOnChange(value);
        this.setState({
          value: value
        });
      } else {
        this.setState();
      }
    }
  }, {
    key: "triggerOnChange",
    value: function triggerOnChange(value) {
      if (this.props.onChange == undefined) return;
      if (this.isNotTriggerNum(value)) return;
      if (isNaN(parseFloat(value)) && isNaN(parseFloat(this.state.value))) return;
      if (parseFloat(value) == parseFloat(this.state.value)) return;
      this.props.onChange(value);
      this.setState({
        triggerValue: value
      });
    }
  }, {
    key: "componentDidUpdate",
    value: function componentDidUpdate() {}
  }, {
    key: "componentWillUnmount",
    value: function componentWillUnmount() {}
  }, {
    key: "componentWillReceiveProps",
    value: function componentWillReceiveProps(nextProps) {
      var obj = this.setStateByProps(nextProps, false);
      var value = this.state.value;
      if (parseFloat(nextProps.value) != parseFloat(this.state.value)) value = this.formatToDisplayStyle(nextProps.value, this.state.numPoint, "");
      obj = Object.assign(obj, {
        value: value,
        triggerValue: value
      });
      this.setState(obj);
    }
  }]);
  return InputFloatControl;
}(_react["default"].Component);

exports["default"] = InputFloatControl;
//# sourceMappingURL=inputfloat.js.map