@kne/react-form-antd 2.0.14 → 2.0.17-alpha.0.0

package/dist/index.js

@@ -61,7 +61,7 @@ function _objectWithoutPropertiesLoose(source, excluded) {
   return target;
 }
 
-var _excluded$6 = ["className", "cache", "enterSubmit", "scrollToError", "scrollProps", "type", "size", "children"];
+var _excluded$7 = ["className", "cache", "enterSubmit", "scrollToError", "scrollProps", "type", "size", "children"];
 var ScrollToError = reactFormHelper.widget.ScrollToError,
     EnterSubmit = reactFormHelper.widget.EnterSubmit,
     FormStore = reactFormHelper.widget.FormStore,
@@ -76,7 +76,7 @@ var Form = React.forwardRef(function (_ref, ref) {
       type = _ref.type,
       size = _ref.size,
       children = _ref.children,
-      props = _objectWithoutPropertiesLoose(_ref, _excluded$6);
+      props = _objectWithoutPropertiesLoose(_ref, _excluded$7);
 
   var computedClass = 'react-form';
 
@@ -446,17 +446,23 @@ var MonthPicker = antd.DatePicker.MonthPicker,
     WeekPicker = antd.DatePicker.WeekPicker;
 
 var _DatePicker = function _DatePicker(props) {
-  var render = useOnChange$8(props);
+  var render = useOnChange$8(Object.assign({
+    placeholder: "\u8BF7\u9009\u62E9" + props.label
+  }, props));
   return render(antd.DatePicker);
 };
 
 var _MonthPicker = function _MonthPicker(props) {
-  var render = useOnChange$8(props);
+  var render = useOnChange$8(Object.assign({
+    placeholder: "\u8BF7\u9009\u62E9" + props.label
+  }, props));
   return render(MonthPicker);
 };
 
 var _RangePicker$1 = function _RangePicker(props) {
-  var render = useOnChange$8(props); // if(props.selectToday){
+  var render = useOnChange$8(Object.assign({
+    placeholder: "\u8BF7\u9009\u62E9" + props.label
+  }, props)); // if(props.selectToday){
   //     return render(RangePickerToday);
   // }
 
@@ -464,7 +470,9 @@ var _RangePicker$1 = function _RangePicker(props) {
 };
 
 var _WeekPicker = function _WeekPicker(props) {
-  var render = useOnChange$8(props);
+  var render = useOnChange$8(Object.assign({
+    placeholder: "\u8BF7\u9009\u62E9" + props.label
+  }, props));
   return render(WeekPicker);
 };
 
@@ -472,9 +480,13 @@ _DatePicker.MonthPicker = _MonthPicker;
 _DatePicker.RangePicker = _RangePicker$1;
 _DatePicker.WeekPicker = _WeekPicker;
 
+var _excluded$6 = ["soFarButtonText"];
 var useOnChange$7 = reactFormHelper.hooks.useOnChange;
 
-var PickerToday = function PickerToday(props) {
+var PickerToday = function PickerToday(_ref) {
+  var soFarButtonText = _ref.soFarButtonText,
+      props = _objectWithoutPropertiesLoose(_ref, _excluded$6);
+
   // console.log('>>>>data', data);
   var _useControlValue = useControlValue__default["default"](props),
       data = _useControlValue[0],
@@ -519,7 +531,7 @@ var PickerToday = function PickerToday(props) {
         ref_d.current.blur();
         onChange([newData.start || '', '至今']);
       }
-    }, "\u81F3\u4ECA");
+    }, soFarButtonText || '至今');
   };
 
   return /*#__PURE__*/React__default["default"].createElement("div", {
@@ -571,7 +583,9 @@ RangePickerToday.field = PickerToday;
 var useDecorator$2 = reactFormHelper.hooks.useDecorator;
 
 var InputField = function InputField(props) {
-  var render = useDecorator$2(props);
+  var render = useDecorator$2(Object.assign({
+    placeholder: "\u8BF7\u8F93\u5165" + props.label
+  }, props));
   return render(antd.Input);
 };
 
@@ -582,7 +596,9 @@ InputField.defaultProps = {
 var useDecorator$1 = reactFormHelper.hooks.useDecorator;
 
 var InputNumberField = function InputNumberField(props) {
-  var render = useDecorator$1(props);
+  var render = useDecorator$1(Object.assign({
+    placeholder: "\u8BF7\u8F93\u5165" + props.label
+  }, props));
   return render(antd.InputNumber);
 };
 
@@ -615,24 +631,582 @@ _RadioGroup.Radio = antd.Radio;
 var useOnChange$5 = reactFormHelper.hooks.useOnChange;
 
 var _Select = function _Select(props) {
-  var render = useOnChange$5(props);
+  var render = useOnChange$5(Object.assign({
+    placeholder: "\u8BF7\u9009\u62E9" + props.label
+  }, props));
   return render(antd.Select);
 };
 
 _Select.Option = antd.Select.Option;
 _Select.OptGroup = antd.Select.OptGroup;
 
-var _excluded$4 = ["data", "setData", "refresh", "isLoading", "children"];
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ *
+ * @providesModule EventSubscription
+ * @typechecks
+ */
+/**
+ * EventSubscription represents a subscription to a particular event. It can
+ * remove its own subscription.
+ */
+
+var EventSubscription = /*#__PURE__*/function () {
+  /**
+   * @param {EventSubscriptionVendor} subscriber the subscriber that controls
+   *   this subscription.
+   */
+  function EventSubscription(subscriber) {
+    this.subscriber = subscriber;
+  }
+  /**
+   * Removes this subscription from the subscriber that controls it.
+   */
+
+
+  var _proto = EventSubscription.prototype;
+
+  _proto.remove = function remove() {
+    if (this.subscriber) {
+      this.subscriber.removeSubscription(this);
+      this.subscriber = null;
+    }
+  };
+
+  return EventSubscription;
+}();
+
+var EventSubscription_1 = EventSubscription;
+
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ *
+ * @providesModule EmitterSubscription
+ * @typechecks
+ */
+
+function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; subClass.__proto__ = superClass; }
+
+
+/**
+ * EmitterSubscription represents a subscription with listener and context data.
+ */
+
+
+var EmitterSubscription = /*#__PURE__*/function (_EventSubscription) {
+  _inheritsLoose(EmitterSubscription, _EventSubscription);
+
+  /**
+   * @param {EventSubscriptionVendor} subscriber - The subscriber that controls
+   *   this subscription
+   * @param {function} listener - Function to invoke when the specified event is
+   *   emitted
+   * @param {*} context - Optional context object to use when invoking the
+   *   listener
+   */
+  function EmitterSubscription(subscriber, listener, context) {
+    var _this;
+
+    _this = _EventSubscription.call(this, subscriber) || this;
+    _this.listener = listener;
+    _this.context = context;
+    return _this;
+  }
+
+  return EmitterSubscription;
+}(EventSubscription_1);
+
+var EmitterSubscription_1 = EmitterSubscription;
+
+/**
+ * Copyright (c) 2013-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ */
+
+var validateFormat = process.env.NODE_ENV !== "production" ? function (format) {
+  if (format === undefined) {
+    throw new Error('invariant(...): Second argument must be a string.');
+  }
+} : function (format) {};
+/**
+ * Use invariant() to assert state which your program assumes to be true.
+ *
+ * Provide sprintf-style format (only %s is supported) and arguments to provide
+ * information about what broke and what you were expecting.
+ *
+ * The invariant message will be stripped in production, but the invariant will
+ * remain to ensure logic does not differ in production.
+ */
+
+function invariant(condition, format) {
+  for (var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
+    args[_key - 2] = arguments[_key];
+  }
+
+  validateFormat(format);
+
+  if (!condition) {
+    var error;
+
+    if (format === undefined) {
+      error = new Error('Minified exception occurred; use the non-minified dev environment ' + 'for the full error message and additional helpful warnings.');
+    } else {
+      var argIndex = 0;
+      error = new Error(format.replace(/%s/g, function () {
+        return String(args[argIndex++]);
+      }));
+      error.name = 'Invariant Violation';
+    }
+
+    error.framesToPop = 1; // Skip invariant's own stack frame.
+
+    throw error;
+  }
+}
+
+var invariant_1 = invariant;
+
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ *
+ * @providesModule EventSubscriptionVendor
+ * @typechecks
+ */
+
+
+/**
+ * EventSubscriptionVendor stores a set of EventSubscriptions that are
+ * subscribed to a particular event type.
+ */
+
+
+var EventSubscriptionVendor = /*#__PURE__*/function () {
+  function EventSubscriptionVendor() {
+    this._subscriptionsForType = {};
+    this._currentSubscription = null;
+  }
+  /**
+   * Adds a subscription keyed by an event type.
+   *
+   * @param {string} eventType
+   * @param {EventSubscription} subscription
+   */
+
+
+  var _proto = EventSubscriptionVendor.prototype;
+
+  _proto.addSubscription = function addSubscription(eventType, subscription) {
+    !(subscription.subscriber === this) ? process.env.NODE_ENV !== "production" ? invariant_1(false, 'The subscriber of the subscription is incorrectly set.') : invariant_1(false) : void 0;
+
+    if (!this._subscriptionsForType[eventType]) {
+      this._subscriptionsForType[eventType] = [];
+    }
+
+    var key = this._subscriptionsForType[eventType].length;
+
+    this._subscriptionsForType[eventType].push(subscription);
+
+    subscription.eventType = eventType;
+    subscription.key = key;
+    return subscription;
+  }
+  /**
+   * Removes a bulk set of the subscriptions.
+   *
+   * @param {?string} eventType - Optional name of the event type whose
+   *   registered supscriptions to remove, if null remove all subscriptions.
+   */
+  ;
+
+  _proto.removeAllSubscriptions = function removeAllSubscriptions(eventType) {
+    if (eventType === undefined) {
+      this._subscriptionsForType = {};
+    } else {
+      delete this._subscriptionsForType[eventType];
+    }
+  }
+  /**
+   * Removes a specific subscription. Instead of calling this function, call
+   * `subscription.remove()` directly.
+   *
+   * @param {object} subscription
+   */
+  ;
+
+  _proto.removeSubscription = function removeSubscription(subscription) {
+    var eventType = subscription.eventType;
+    var key = subscription.key;
+    var subscriptionsForType = this._subscriptionsForType[eventType];
+
+    if (subscriptionsForType) {
+      delete subscriptionsForType[key];
+    }
+  }
+  /**
+   * Returns the array of subscriptions that are currently registered for the
+   * given event type.
+   *
+   * Note: This array can be potentially sparse as subscriptions are deleted
+   * from it when they are removed.
+   *
+   * TODO: This returns a nullable array. wat?
+   *
+   * @param {string} eventType
+   * @return {?array}
+   */
+  ;
+
+  _proto.getSubscriptionsForType = function getSubscriptionsForType(eventType) {
+    return this._subscriptionsForType[eventType];
+  };
+
+  return EventSubscriptionVendor;
+}();
+
+var EventSubscriptionVendor_1 = EventSubscriptionVendor;
+
+/**
+ * Copyright (c) 2013-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ */
+function makeEmptyFunction(arg) {
+  return function () {
+    return arg;
+  };
+}
+/**
+ * This function accepts and discards inputs; it has no side effects. This is
+ * primarily useful idiomatically for overridable function endpoints which
+ * always need to be callable, since JS lacks a null-call idiom ala Cocoa.
+ */
+
+
+var emptyFunction = function emptyFunction() {};
+
+emptyFunction.thatReturns = makeEmptyFunction;
+emptyFunction.thatReturnsFalse = makeEmptyFunction(false);
+emptyFunction.thatReturnsTrue = makeEmptyFunction(true);
+emptyFunction.thatReturnsNull = makeEmptyFunction(null);
+
+emptyFunction.thatReturnsThis = function () {
+  return this;
+};
+
+emptyFunction.thatReturnsArgument = function (arg) {
+  return arg;
+};
+
+var emptyFunction_1 = emptyFunction;
+
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ *
+ * @providesModule BaseEventEmitter
+ * @typechecks
+ */
+
+
+
+
+
+
+
+/**
+ * @class BaseEventEmitter
+ * @description
+ * An EventEmitter is responsible for managing a set of listeners and publishing
+ * events to them when it is told that such events happened. In addition to the
+ * data for the given event it also sends a event control object which allows
+ * the listeners/handlers to prevent the default behavior of the given event.
+ *
+ * The emitter is designed to be generic enough to support all the different
+ * contexts in which one might want to emit events. It is a simple multicast
+ * mechanism on top of which extra functionality can be composed. For example, a
+ * more advanced emitter may use an EventHolder and EventFactory.
+ */
+
+
+var BaseEventEmitter = /*#__PURE__*/function () {
+  /**
+   * @constructor
+   */
+  function BaseEventEmitter() {
+    this._subscriber = new EventSubscriptionVendor_1();
+    this._currentSubscription = null;
+  }
+  /**
+   * Adds a listener to be invoked when events of the specified type are
+   * emitted. An optional calling context may be provided. The data arguments
+   * emitted will be passed to the listener function.
+   *
+   * TODO: Annotate the listener arg's type. This is tricky because listeners
+   *       can be invoked with varargs.
+   *
+   * @param {string} eventType - Name of the event to listen to
+   * @param {function} listener - Function to invoke when the specified event is
+   *   emitted
+   * @param {*} context - Optional context object to use when invoking the
+   *   listener
+   */
+
+
+  var _proto = BaseEventEmitter.prototype;
+
+  _proto.addListener = function addListener(eventType, listener, context) {
+    return this._subscriber.addSubscription(eventType, new EmitterSubscription_1(this._subscriber, listener, context));
+  }
+  /**
+   * Similar to addListener, except that the listener is removed after it is
+   * invoked once.
+   *
+   * @param {string} eventType - Name of the event to listen to
+   * @param {function} listener - Function to invoke only once when the
+   *   specified event is emitted
+   * @param {*} context - Optional context object to use when invoking the
+   *   listener
+   */
+  ;
+
+  _proto.once = function once(eventType, listener, context) {
+    var emitter = this;
+    return this.addListener(eventType, function () {
+      emitter.removeCurrentListener();
+      listener.apply(context, arguments);
+    });
+  }
+  /**
+   * Removes all of the registered listeners, including those registered as
+   * listener maps.
+   *
+   * @param {?string} eventType - Optional name of the event whose registered
+   *   listeners to remove
+   */
+  ;
+
+  _proto.removeAllListeners = function removeAllListeners(eventType) {
+    this._subscriber.removeAllSubscriptions(eventType);
+  }
+  /**
+   * Provides an API that can be called during an eventing cycle to remove the
+   * last listener that was invoked. This allows a developer to provide an event
+   * object that can remove the listener (or listener map) during the
+   * invocation.
+   *
+   * If it is called when not inside of an emitting cycle it will throw.
+   *
+   * @throws {Error} When called not during an eventing cycle
+   *
+   * @example
+   *   var subscription = emitter.addListenerMap({
+   *     someEvent: function(data, event) {
+   *       console.log(data);
+   *       emitter.removeCurrentListener();
+   *     }
+   *   });
+   *
+   *   emitter.emit('someEvent', 'abc'); // logs 'abc'
+   *   emitter.emit('someEvent', 'def'); // does not log anything
+   */
+  ;
+
+  _proto.removeCurrentListener = function removeCurrentListener() {
+    !!!this._currentSubscription ? process.env.NODE_ENV !== "production" ? invariant_1(false, 'Not in an emitting cycle; there is no current subscription') : invariant_1(false) : void 0;
+
+    this._subscriber.removeSubscription(this._currentSubscription);
+  }
+  /**
+   * Returns an array of listeners that are currently registered for the given
+   * event.
+   *
+   * @param {string} eventType - Name of the event to query
+   * @return {array}
+   */
+  ;
+
+  _proto.listeners = function listeners(eventType)
+  /* TODO: Array<EventSubscription> */
+  {
+    var subscriptions = this._subscriber.getSubscriptionsForType(eventType);
+
+    return subscriptions ? subscriptions.filter(emptyFunction_1.thatReturnsTrue).map(function (subscription) {
+      return subscription.listener;
+    }) : [];
+  }
+  /**
+   * Emits an event of the given type with the given data. All handlers of that
+   * particular type will be notified.
+   *
+   * @param {string} eventType - Name of the event to emit
+   * @param {*} Arbitrary arguments to be passed to each registered listener
+   *
+   * @example
+   *   emitter.addListener('someEvent', function(message) {
+   *     console.log(message);
+   *   });
+   *
+   *   emitter.emit('someEvent', 'abc'); // logs 'abc'
+   */
+  ;
+
+  _proto.emit = function emit(eventType) {
+    var subscriptions = this._subscriber.getSubscriptionsForType(eventType);
+
+    if (subscriptions) {
+      var keys = Object.keys(subscriptions);
+
+      for (var ii = 0; ii < keys.length; ii++) {
+        var key = keys[ii];
+        var subscription = subscriptions[key]; // The subscription may have been removed during this event loop.
+
+        if (subscription) {
+          this._currentSubscription = subscription;
+
+          this.__emitToSubscription.apply(this, [subscription].concat(Array.prototype.slice.call(arguments)));
+        }
+      }
+
+      this._currentSubscription = null;
+    }
+  }
+  /**
+   * Provides a hook to override how the emitter emits an event to a specific
+   * subscription. This allows you to set up logging and error boundaries
+   * specific to your environment.
+   *
+   * @param {EmitterSubscription} subscription
+   * @param {string} eventType
+   * @param {*} Arbitrary arguments to be passed to each registered listener
+   */
+  ;
+
+  _proto.__emitToSubscription = function __emitToSubscription(subscription, eventType) {
+    var args = Array.prototype.slice.call(arguments, 2);
+    subscription.listener.apply(subscription.context, args);
+  };
+
+  return BaseEventEmitter;
+}();
+
+var BaseEventEmitter_1 = BaseEventEmitter;
+
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+var fbemitter = {
+  EventEmitter: BaseEventEmitter_1,
+  EmitterSubscription : EmitterSubscription_1
+};
+
+var fbemitter_1 = fbemitter;
+
+const {
+  EventEmitter
+} = fbemitter_1;
+
+class FormEventEmitter extends EventEmitter {
+  constructor(options) {
+    super();
+    const {
+      debug,
+      name = 'event'
+    } = Object.assign({}, options);
+    this.debug = debug;
+    this.name = name;
+  }
+
+  emit(...args) {
+    if (this.debug) {
+      console.log(`[${this.name}][debug]:`, ...args);
+    }
+
+    super.emit(...args);
+  }
+
+}
+
+const useEvent = debug => {
+  const debugRef = React.useRef(debug);
+  return React.useMemo(() => {
+    const emitter = new FormEventEmitter(debugRef.current);
+    return {
+      addListener: (...args) => emitter.addListener(...args),
+      emit: (...args) => emitter.emit(...args),
+      removeAllListeners: (...args) => emitter.removeAllListeners(...args),
+      listeners: (...args) => emitter.listeners(...args),
+      once: (...args) => emitter.once(...args)
+    };
+  }, []);
+};
+
+var _excluded$4 = ["data", "setData", "refresh", "reload", "emitter", "isLoading", "children"];
 var useOnChange$4 = reactFormHelper.hooks.useOnChange;
 
 var _SelectFetch = reactFetch.withFetch(function (_ref) {
   var data = _ref.data,
       setData = _ref.setData,
       refresh = _ref.refresh,
+      reload = _ref.reload,
+      emitter = _ref.emitter,
       isLoading = _ref.isLoading,
       children = _ref.children,
       props = _objectWithoutPropertiesLoose(_ref, _excluded$4);
 
+  var refreshRef = React.useRef(refresh);
+  refreshRef.current = refresh;
+  var reloadRef = React.useRef(reload);
+  reloadRef.current = reload;
+  var setDataRef = React.useRef(setData);
+  setDataRef.current = setData;
+  React.useEffect(function () {
+    var token1 = emitter.addListener('select-fetch-refresh', function () {
+      return refreshRef.current();
+    });
+    var token2 = emitter.addListener('select-fetch-reload', function () {
+      return reloadRef.current();
+    });
+    var token3 = emitter.addListener('select-fetch-set-data', function () {
+      return setDataRef.current();
+    });
+    return function () {
+      token1 && token1.remove();
+      token2 && token2.remove();
+      token3 && token3.remove();
+    };
+  }, [emitter]);
   return /*#__PURE__*/React__default["default"].createElement(antd.Select, props, children({
     data: data,
     refresh: refresh,
@@ -641,11 +1215,28 @@ var _SelectFetch = reactFetch.withFetch(function (_ref) {
   }));
 });
 
-var SelectFetch$1 = function SelectFetch(props) {
-  var render = useOnChange$4(props);
+var SelectFetch$1 = React.forwardRef(function (props, ref) {
+  var emitter = useEvent();
+  React.useImperativeHandle(ref, function () {
+    return {
+      refresh: function refresh() {
+        return emitter.emit('select-fetch-refresh');
+      },
+      reload: function reload() {
+        return emitter.emit('select-fetch-reload');
+      },
+      setData: function setData(data) {
+        return emitter.emit('select-fetch-set-data', data);
+      }
+    };
+  }, [emitter]);
+  var render = useOnChange$4(Object.assign({
+    placeholder: "\u8BF7\u9009\u62E9" + props.label
+  }, props, {
+    emitter: emitter
+  }));
   return render(_SelectFetch);
-};
-
+});
 SelectFetch$1.Option = antd.Select.Option;
 SelectFetch$1.OptGroup = antd.Select.OptGroup;
 
@@ -663,7 +1254,9 @@ var Switch$1 = function Switch(props) {
 var useDecorator = reactFormHelper.hooks.useDecorator;
 
 var TextArea$1 = function TextArea(props) {
-  var render = useDecorator(props);
+  var render = useDecorator(Object.assign({
+    placeholder: "\u8BF7\u8F93\u5165" + props.label
+  }, props));
   return render(antd.Input.TextArea);
 };
 
@@ -671,12 +1264,16 @@ var useOnChange$2 = reactFormHelper.hooks.useOnChange;
 var RangePicker = antd.TimePicker.RangePicker;
 
 var _TimePicker = function _TimePicker(props) {
-  var render = useOnChange$2(props);
+  var render = useOnChange$2(Object.assign({
+    placeholder: "\u8BF7\u9009\u62E9" + props.label
+  }, props));
   return render(antd.TimePicker);
 };
 
 var _RangePicker = function _RangePicker(props) {
-  var render = useOnChange$2(props);
+  var render = useOnChange$2(Object.assign({
+    placeholder: "\u8BF7\u9009\u62E9" + props.label
+  }, props));
   return render(RangePicker);
 };
 
@@ -685,7 +1282,9 @@ _TimePicker.RangePicker = _RangePicker;
 var useOnChange$1 = reactFormHelper.hooks.useOnChange;
 
 var _TreeSelect = function _TreeSelect(props) {
-  var render = useOnChange$1(props);
+  var render = useOnChange$1(Object.assign({
+    placeholder: "\u8BF7\u9009\u62E9" + props.label
+  }, props));
   return render(antd.TreeSelect);
 };
 
@@ -861,20 +1460,28 @@ var UploadInput = function UploadInput(props) {
 
 UploadInput.field = _Upload;
 
-var _excluded$2 = ["isPass", "isLoading"];
+var _excluded$2 = ["realTime", "disabled"],
+    _excluded2$1 = ["isPass", "isLoading"];
+
+var SubmitButton = function SubmitButton(_ref) {
+  var realTime = _ref.realTime,
+      disabled = _ref.disabled,
+      props = _objectWithoutPropertiesLoose(_ref, _excluded$2);
 
-var SubmitButton = function SubmitButton(props) {
   var _useSubmit = ReactForm.useSubmit(props),
+      isPass = _useSubmit.isPass,
       isLoading = _useSubmit.isLoading,
-      submitProps = _objectWithoutPropertiesLoose(_useSubmit, _excluded$2);
+      submitProps = _objectWithoutPropertiesLoose(_useSubmit, _excluded2$1);
 
   return /*#__PURE__*/React__default["default"].createElement(antd.Button, _extends({
-    loading: isLoading
+    loading: isLoading,
+    disabled: disabled || (realTime ? !isPass : false)
   }, submitProps, props));
 };
 
 SubmitButton.defaultProps = {
-  type: 'primary'
+  type: 'primary',
+  disabled: false
 };
 
 var ResetButton = function ResetButton(props) {