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

package/dist/index.modern.js

@@ -1,4 +1,4 @@
-import React, { forwardRef, useState, useRef, useEffect, useMemo, useCallback } from 'react';
+import React, { forwardRef, useState, useRef, useEffect, useMemo, useCallback, useImperativeHandle } from 'react';
 import PropTypes from 'prop-types';
 import classnames from 'classnames';
 import ReactForm__default, { preset as preset$1, useSubmit, useReset } from '@kne/react-form';
@@ -49,7 +49,7 @@ function _objectWithoutPropertiesLoose(source, excluded) {
   return target;
 }
 
-const _excluded$6 = ["className", "cache", "enterSubmit", "scrollToError", "scrollProps", "type", "size", "children"];
+const _excluded$7 = ["className", "cache", "enterSubmit", "scrollToError", "scrollProps", "type", "size", "children"];
 const {
   ScrollToError,
   EnterSubmit,
@@ -68,7 +68,7 @@ const Form = forwardRef((_ref, ref) => {
     size,
     children
   } = _ref,
-      props = _objectWithoutPropertiesLoose(_ref, _excluded$6);
+      props = _objectWithoutPropertiesLoose(_ref, _excluded$7);
 
   let computedClass = 'react-form';
 
@@ -433,17 +433,23 @@ const {
 } = DatePicker$1;
 
 const _DatePicker = props => {
-  const render = useOnChange$8(props);
+  const render = useOnChange$8(Object.assign({
+    placeholder: `请选择${props.label}`
+  }, props));
   return render(DatePicker$1);
 };
 
 const _MonthPicker = props => {
-  const render = useOnChange$8(props);
+  const render = useOnChange$8(Object.assign({
+    placeholder: `请选择${props.label}`
+  }, props));
   return render(MonthPicker);
 };
 
 const _RangePicker$1 = props => {
-  const render = useOnChange$8(props); // if(props.selectToday){
+  const render = useOnChange$8(Object.assign({
+    placeholder: `请选择${props.label}`
+  }, props)); // if(props.selectToday){
   //     return render(RangePickerToday);
   // }
 
@@ -451,7 +457,9 @@ const _RangePicker$1 = props => {
 };
 
 const _WeekPicker = props => {
-  const render = useOnChange$8(props);
+  const render = useOnChange$8(Object.assign({
+    placeholder: `请选择${props.label}`
+  }, props));
   return render(WeekPicker);
 };
 
@@ -459,11 +467,17 @@ _DatePicker.MonthPicker = _MonthPicker;
 _DatePicker.RangePicker = _RangePicker$1;
 _DatePicker.WeekPicker = _WeekPicker;
 
+const _excluded$6 = ["soFarButtonText"];
 const {
   useOnChange: useOnChange$7
 } = hooks;
 
-const PickerToday = props => {
+const PickerToday = _ref => {
+  let {
+    soFarButtonText
+  } = _ref,
+      props = _objectWithoutPropertiesLoose(_ref, _excluded$6);
+
   // console.log('>>>>data', data);
   const [data, onChange] = useControlValue(props);
   const ref_d = useRef();
@@ -505,7 +519,7 @@ const PickerToday = props => {
         ref_d.current.blur();
         onChange([newData.start || '', '至今']);
       }
-    }, "\u81F3\u4ECA");
+    }, soFarButtonText || '至今');
   };
 
   return /*#__PURE__*/React.createElement("div", {
@@ -559,7 +573,9 @@ const {
 } = hooks;
 
 const InputField = props => {
-  const render = useDecorator$2(props);
+  const render = useDecorator$2(Object.assign({
+    placeholder: `请输入${props.label}`
+  }, props));
   return render(Input$1);
 };
 
@@ -572,7 +588,9 @@ const {
 } = hooks;
 
 const InputNumberField = props => {
-  const render = useDecorator$1(props);
+  const render = useDecorator$1(Object.assign({
+    placeholder: `请输入${props.label}`
+  }, props));
   return render(InputNumber$1);
 };
 
@@ -611,14 +629,548 @@ const {
 } = hooks;
 
 const _Select = props => {
-  const render = useOnChange$5(props);
+  const render = useOnChange$5(Object.assign({
+    placeholder: `请选择${props.label}`
+  }, props));
   return render(Select$1);
 };
 
 _Select.Option = Select$1.Option;
 _Select.OptGroup = Select$1.OptGroup;
 
-const _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 = useRef(debug);
+  return 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)
+    };
+  }, []);
+};
+
+const _excluded$4 = ["data", "setData", "refresh", "reload", "emitter", "isLoading", "children"];
 const {
   useOnChange: useOnChange$4
 } = hooks;
@@ -628,11 +1180,29 @@ const _SelectFetch = withFetch(_ref => {
     data,
     setData,
     refresh,
+    reload,
+    emitter,
     isLoading,
     children
   } = _ref,
       props = _objectWithoutPropertiesLoose(_ref, _excluded$4);
 
+  const refreshRef = useRef(refresh);
+  refreshRef.current = refresh;
+  const reloadRef = useRef(reload);
+  reloadRef.current = reload;
+  const setDataRef = useRef(setData);
+  setDataRef.current = setData;
+  useEffect(() => {
+    const token1 = emitter.addListener('select-fetch-refresh', () => refreshRef.current());
+    const token2 = emitter.addListener('select-fetch-reload', () => reloadRef.current());
+    const token3 = emitter.addListener('select-fetch-set-data', () => setDataRef.current());
+    return () => {
+      token1 && token1.remove();
+      token2 && token2.remove();
+      token3 && token3.remove();
+    };
+  }, [emitter]);
   return /*#__PURE__*/React.createElement(Select$1, props, children({
     data,
     refresh,
@@ -641,11 +1211,22 @@ const _SelectFetch = withFetch(_ref => {
   }));
 });
 
-const SelectFetch$1 = props => {
-  const render = useOnChange$4(props);
+const SelectFetch$1 = forwardRef((props, ref) => {
+  const emitter = useEvent();
+  useImperativeHandle(ref, () => {
+    return {
+      refresh: () => emitter.emit('select-fetch-refresh'),
+      reload: () => emitter.emit('select-fetch-reload'),
+      setData: data => emitter.emit('select-fetch-set-data', data)
+    };
+  }, [emitter]);
+  const render = useOnChange$4(Object.assign({
+    placeholder: `请选择${props.label}`
+  }, props, {
+    emitter
+  }));
   return render(_SelectFetch);
-};
-
+});
 SelectFetch$1.Option = Select$1.Option;
 SelectFetch$1.OptGroup = Select$1.OptGroup;
 
@@ -669,7 +1250,9 @@ const {
 } = hooks;
 
 const TextArea$1 = props => {
-  const render = useDecorator(props);
+  const render = useDecorator(Object.assign({
+    placeholder: `请输入${props.label}`
+  }, props));
   return render(Input$1.TextArea);
 };
 
@@ -681,12 +1264,16 @@ const {
 } = TimePicker$1;
 
 const _TimePicker = props => {
-  const render = useOnChange$2(props);
+  const render = useOnChange$2(Object.assign({
+    placeholder: `请选择${props.label}`
+  }, props));
   return render(TimePicker$1);
 };
 
 const _RangePicker = props => {
-  const render = useOnChange$2(props);
+  const render = useOnChange$2(Object.assign({
+    placeholder: `请选择${props.label}`
+  }, props));
   return render(RangePicker);
 };
 
@@ -697,7 +1284,9 @@ const {
 } = hooks;
 
 const _TreeSelect = props => {
-  const render = useOnChange$1(props);
+  const render = useOnChange$1(Object.assign({
+    placeholder: `请选择${props.label}`
+  }, props));
   return render(TreeSelect$1);
 };
 
@@ -861,22 +1450,32 @@ const UploadInput = props => {
 
 UploadInput.field = _Upload;
 
-const _excluded$2 = ["isPass", "isLoading"];
+const _excluded$2 = ["realTime", "disabled"],
+      _excluded2$1 = ["isPass", "isLoading"];
+
+const SubmitButton = _ref => {
+  let {
+    realTime,
+    disabled
+  } = _ref,
+      props = _objectWithoutPropertiesLoose(_ref, _excluded$2);
 
-const SubmitButton = props => {
   const _useSubmit = useSubmit(props),
         {
+    isPass,
     isLoading
   } = _useSubmit,
-        submitProps = _objectWithoutPropertiesLoose(_useSubmit, _excluded$2);
+        submitProps = _objectWithoutPropertiesLoose(_useSubmit, _excluded2$1);
 
   return /*#__PURE__*/React.createElement(Button, _extends({
-    loading: isLoading
+    loading: isLoading,
+    disabled: disabled || (realTime ? !isPass : false)
   }, submitProps, props));
 };
 
 SubmitButton.defaultProps = {
-  type: 'primary'
+  type: 'primary',
+  disabled: false
 };
 
 const ResetButton = props => {