shineout 1.12.2 → 1.12.3

package/esm/Form/formButton.js

@@ -0,0 +1,69 @@
+import _extends from "@babel/runtime/helpers/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/objectWithoutPropertiesLoose";
+import _inheritsLoose from "@babel/runtime/helpers/inheritsLoose";
+import _assertThisInitialized from "@babel/runtime/helpers/assertThisInitialized";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import React, { PureComponent } from 'react';
+import PropTypes from 'prop-types';
+import Button from '../Button';
+import { getParent, dispatchEvent } from '../utils/dom/element';
+import { formConsumer } from './formContext';
+export default (function (htmlType) {
+  var _class, _temp;
+
+  return formConsumer(['disabled'], (_temp = _class =
+  /*#__PURE__*/
+  function (_PureComponent) {
+    _inheritsLoose(FormButton, _PureComponent);
+
+    function FormButton(props) {
+      var _this;
+
+      _this = _PureComponent.call(this, props) || this;
+
+      _defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), "button", void 0);
+
+      _this.bindElement = _this.bindElement.bind(_assertThisInitialized(_assertThisInitialized(_this)));
+      _this.handleClick = _this.handleClick.bind(_assertThisInitialized(_assertThisInitialized(_this)));
+      return _this;
+    }
+
+    var _proto = FormButton.prototype;
+
+    _proto.bindElement = function bindElement(el) {
+      this.button = el;
+    };
+
+    _proto.handleClick = function handleClick(e) {
+      if (htmlType === 'button') {
+        var form = getParent(this.button, 'form');
+        dispatchEvent(form, 'submit', e.target);
+      }
+
+      if (this.props.onClick) this.props.onClick();
+    };
+
+    _proto.render = function render() {
+      var _this$props = this.props,
+          children = _this$props.children,
+          onClick = _this$props.onClick,
+          other = _objectWithoutPropertiesLoose(_this$props, ["children", "onClick"]);
+
+      var type = this.props.type || (htmlType === 'reset' ? 'default' : 'primary');
+      return React.createElement(Button, _extends({}, other, {
+        type: type,
+        htmlType: htmlType,
+        onRef: this.bindElement,
+        onClick: this.handleClick
+      }), children);
+    };
+
+    return FormButton;
+  }(PureComponent), _defineProperty(_class, "propTypes", {
+    children: PropTypes.any,
+    disabled: PropTypes.bool,
+    loading: PropTypes.bool,
+    onClick: PropTypes.func,
+    type: PropTypes.string
+  }), _temp));
+});

package/esm/Form/formContext.d.ts

@@ -0,0 +1,9 @@
+import React, { ComponentType } from 'react';
+import { FormContextValue, FormProviderProps, GetFormProviderProps } from './Props';
+export declare const Provider: React.Provider<FormContextValue>;
+export declare const Consumer: React.Consumer<FormContextValue>;
+export declare const formProvider: <FormValue, U extends FormProviderProps<FormValue>>(Origin: React.ComponentType<U>) => React.ComponentType<GetFormProviderProps<U, FormValue>>;
+export interface FormConsumerProps {
+    disabled?: boolean | ((...args: any) => boolean);
+}
+export declare const formConsumer: import("../utils/curry").CurriedFunction3<unknown, unknown, unknown, JSX.Element>;

package/esm/Form/formContext.js

@@ -0,0 +1,103 @@
+import _extends from "@babel/runtime/helpers/extends";
+import _inheritsLoose from "@babel/runtime/helpers/inheritsLoose";
+import _assertThisInitialized from "@babel/runtime/helpers/assertThisInitialized";
+import React, { PureComponent } from 'react';
+import createReactContext from '../context';
+import { deepGet } from '../utils/objects';
+import { isObject, isArray } from '../utils/is';
+import { curry3 } from '../utils/func'; // 去掉独有的属性
+
+var context = createReactContext({}); // eslint-disable-next-line
+
+export var Provider = context.Provider; // eslint-disable-next-line
+
+export var Consumer = context.Consumer;
+export var formProvider = function formProvider(Origin) {
+  var FormProvider =
+  /*#__PURE__*/
+  function (_PureComponent) {
+    _inheritsLoose(FormProvider, _PureComponent);
+
+    function FormProvider(props) {
+      var _this;
+
+      _this = _PureComponent.call(this, props) || this;
+      _this.combineRules = _this.combineRules.bind(_assertThisInitialized(_assertThisInitialized(_this))); // this.groupValidate = this.groupValidate.bind(this)
+
+      return _this;
+    }
+
+    var _proto = FormProvider.prototype;
+
+    _proto.combineRules = function combineRules(name, propRules) {
+      var rules = this.props.rules;
+      var newRules = [];
+
+      if (isObject(rules) && name) {
+        newRules = deepGet(rules, name) || [];
+      } else if (isArray(rules)) {
+        newRules = rules;
+      }
+
+      if (isArray(propRules)) {
+        newRules = newRules.concat(propRules);
+      }
+
+      return newRules;
+    } // groupValidate(name) {
+    // not implement...
+    // }
+    ;
+
+    _proto.render = function render() {
+      var _this$props = this.props,
+          datum = _this$props.datum,
+          labelAlign = _this$props.labelAlign,
+          labelVerticalAlign = _this$props.labelVerticalAlign,
+          labelWidth = _this$props.labelWidth,
+          disabled = _this$props.disabled,
+          pending = _this$props.pending,
+          mode = _this$props.mode,
+          size = _this$props.size,
+          keepErrorHeight = _this$props.keepErrorHeight;
+      var value = {
+        formDatum: datum,
+        formMode: mode,
+        disabled: !!(disabled || pending),
+        labelAlign: labelAlign,
+        labelVerticalAlign: labelVerticalAlign,
+        labelWidth: labelWidth,
+        size: size,
+        combineRules: this.combineRules,
+        // groupValidate: this.groupValidate,
+        keepErrorHeight: keepErrorHeight
+      };
+      return React.createElement(Provider, {
+        value: value
+      }, React.createElement(Origin, this.props));
+    };
+
+    return FormProvider;
+  }(PureComponent);
+
+  return FormProvider;
+};
+export var formConsumer = curry3(function (keys, Origin, props) {
+  var filterProps = function filterProps(value) {
+    var cps = {};
+    if (!value) return cps;
+    if (!keys) return value;
+    keys.forEach(function (k) {
+      var val = value[k];
+      if (val !== undefined) cps[k] = val;
+    });
+    return cps;
+  };
+
+  return React.createElement(Consumer, null, function (value) {
+    var formProps = filterProps(value);
+    return React.createElement(Origin, _extends({}, formProps, props, {
+      disabled: formProps.disabled || props.disabled
+    }));
+  });
+});

package/esm/Form/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: typeof import("./Props").Form;
+export default _default;

package/esm/Form/index.js

@@ -0,0 +1,35 @@
+import { compose } from '../utils/func';
+import Datum from '../Datum';
+import { consumer as cardConsumer } from '../Card/context';
+import inputable from './inputable';
+import Form from './Form';
+import Item from './Item';
+import Field from './Field';
+import Flow from './Flow';
+import FieldSet from './FieldSet';
+import formButton from './formButton';
+import { formProvider, formConsumer } from './formContext';
+import useMode from './mode';
+var formCardConsumerKey = ['setFormStatus'];
+var formDatumKey = ['removeUndefined', 'error'];
+var formItemWithFormConsumerKeys = ['formDatum', 'labelWidth', 'labelAlign', 'labelVerticalAlign', 'keepErrorHeight'];
+var formFlowWithFormConsumerKeys = ['formDatum'];
+var exportForm = compose(Datum.hoc({
+  type: 'form',
+  bindProps: formDatumKey
+}), formProvider)(cardConsumer(Form, formCardConsumerKey));
+exportForm.Item = formConsumer(formItemWithFormConsumerKeys)(Item);
+exportForm.Field = inputable(Field);
+exportForm.Flow = formConsumer(formFlowWithFormConsumerKeys)(Flow);
+exportForm.FieldSet = formConsumer(['formDatum'])(FieldSet);
+exportForm.Submit = formButton('submit');
+exportForm.Reset = formButton('reset');
+exportForm.Button = formButton('button');
+exportForm.formConsumer = formConsumer;
+exportForm.useMode = useMode;
+exportForm.displayName = 'ShineoutForm';
+exportForm.Item.displayName = 'ShineoutFormItem';
+exportForm.Field.displayName = 'ShineoutFormField';
+exportForm.Flow.displayName = 'ShineoutFormFlow';
+exportForm.FieldSet.displayName = 'ShineoutFormFieldSet';
+export default exportForm;

package/esm/Form/inputable.d.ts

@@ -0,0 +1,4 @@
+import React, { ComponentType } from 'react';
+import { BaseInputProps, GetInputableProps } from './Props';
+declare const _default: <Value, U extends BaseInputProps, Item = any>(Origin: React.ComponentType<U>) => React.ComponentType<GetInputableProps<U, Value>>;
+export default _default;

package/esm/Form/inputable.js

@@ -0,0 +1,411 @@
+import _extends from "@babel/runtime/helpers/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/objectWithoutPropertiesLoose";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _inheritsLoose from "@babel/runtime/helpers/inheritsLoose";
+import _assertThisInitialized from "@babel/runtime/helpers/assertThisInitialized";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import React from 'react';
+import immer from 'immer';
+import { Component } from '../component';
+import { promiseAll, isSameError } from '../utils/errors';
+import shallowEqual from '../utils/shallowEqual';
+import { filterProps } from '../utils/objects';
+import { getUidStr } from '../utils/uid';
+import { isArray } from '../utils/is';
+import _validate from '../utils/validate';
+import { FORCE_PASS, ERROR_TYPE, IGNORE_VALIDATE, errorSubscribe, IGNORE_BIND } from '../Datum/types';
+import { formConsumer } from './formContext';
+import { itemConsumer } from './Item';
+import { fieldSetConsumer } from './FieldSet';
+var types = ['formDatum', 'disabled', 'combineRules', 'size'];
+
+var tryValue = function tryValue(val, def) {
+  return val === undefined ? def : val;
+};
+
+var beforeValueChange = function beforeValueChange(fn) {
+  return function (value, datum) {
+    if (!fn) return value;
+    var newValue = fn(value, datum);
+    return newValue === undefined ? value : newValue;
+  };
+};
+
+export default (function (Origin) {
+  var InputableInner =
+  /*#__PURE__*/
+  function (_Component) {
+    _inheritsLoose(InputableInner, _Component);
+
+    function InputableInner(props) {
+      var _this;
+
+      _this = _Component.call(this, props) || this;
+
+      _defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), "itemName", void 0);
+
+      _defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), "lastValue", void 0);
+
+      _defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), "updateTimer", void 0);
+
+      _defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), "datum", void 0);
+
+      _defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), "lastError", void 0);
+
+      _defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), "errorChange", void 0);
+
+      _defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), "customValidate", void 0);
+
+      var formDatum = props.formDatum,
+          name = props.name,
+          defaultValue = props.defaultValue;
+      _this.state = {
+        error: undefined,
+        value: props.value || defaultValue
+      };
+      _this.itemName = getUidStr();
+      _this.handleChange = _this.handleChange.bind(_assertThisInitialized(_assertThisInitialized(_this)));
+      _this.handleUpdate = _this.handleUpdate.bind(_assertThisInitialized(_assertThisInitialized(_this)));
+      _this.handleDatumBind = _this.handleDatumBind.bind(_assertThisInitialized(_assertThisInitialized(_this)));
+      _this.handleError = _this.handleError.bind(_assertThisInitialized(_assertThisInitialized(_this)));
+      _this.validate = _this.validate.bind(_assertThisInitialized(_assertThisInitialized(_this)));
+      _this.validateHook = _this.validateHook.bind(_assertThisInitialized(_assertThisInitialized(_this)));
+      _this.lastValue = formDatum && name ? formDatum.get(name) || {} : {};
+      return _this;
+    }
+
+    var _proto = InputableInner.prototype;
+
+    _proto.componentDidMount = function componentDidMount() {
+      var _this2 = this;
+
+      _Component.prototype.componentDidMount.call(this); // @ts-ignore
+
+
+      var readOnly = this.props.readOnly;
+      var _this$props = this.props,
+          onChange = _this$props.onChange,
+          disabled = _this$props.disabled;
+
+      if ('value' in this.props && !onChange && disabled !== true && readOnly !== true) {
+        console.error('warning: You provided a `value` prop to a form field without an `onChange` handler. This will render a read-only field. If the field should be mutable use `defaultValue`. Otherwise, set either `onChange` or `readOnly` or `disabled`');
+      }
+
+      var _this$props2 = this.props,
+          formDatum = _this$props2.formDatum,
+          name = _this$props2.name,
+          defaultValue = _this$props2.defaultValue,
+          bindInputToItem = _this$props2.bindInputToItem,
+          popover = _this$props2.popover;
+
+      if (formDatum && name) {
+        if (Array.isArray(name)) {
+          var dv = defaultValue || [];
+          name.forEach(function (n, i) {
+            return formDatum.bind(n, _this2.handleUpdate, dv[i], _this2.validate);
+          }); // @ts-ignore
+
+          this.state.value = name.map(function (n) {
+            return formDatum.get(n);
+          });
+          formDatum.subscribe(errorSubscribe(this.errorName), this.handleUpdate);
+        } else {
+          formDatum.bind(name, this.handleUpdate, defaultValue, this.validate); // @ts-ignore
+
+          this.state.value = formDatum.get(name);
+        }
+
+        this.lastValue = this.state.value;
+      }
+
+      if (bindInputToItem && name && !popover) bindInputToItem(this.errorName);
+    };
+
+    _proto.shouldComponentUpdate = function shouldComponentUpdate(nextProps, nextState) {
+      var skip = [].concat(this.props.scuSkip || [], ['formDatum']);
+      var isFormDatum = this.props.formDatum && this.props.name;
+      if (isFormDatum) skip.push('value');
+      var options = {
+        skip: skip,
+        deep: ['data', 'defaultValue', 'datum', 'name', 'rule', 'style']
+      };
+      if (!isFormDatum && !shallowEqual(this.getValue(), nextState.value)) return true;
+      return !(shallowEqual(nextProps, this.props, options) && shallowEqual(nextState, this.state));
+    };
+
+    _proto.componentWillUnmount = function componentWillUnmount() {
+      _Component.prototype.componentWillUnmount.call(this);
+
+      var _this$props3 = this.props,
+          formDatum = _this$props3.formDatum,
+          name = _this$props3.name,
+          unbindInputFromItem = _this$props3.unbindInputFromItem,
+          reserveAble = _this$props3.reserveAble;
+      clearTimeout(this.updateTimer);
+
+      if (formDatum && name) {
+        formDatum.unbind(name, this.handleUpdate, reserveAble);
+
+        if (Array.isArray(name)) {
+          formDatum.unsubscribe(errorSubscribe(this.errorName), this.handleUpdate);
+          formDatum.setError(this.errorName);
+        }
+      }
+
+      if (unbindInputFromItem && name) unbindInputFromItem(this.errorName);
+    };
+
+    _proto.getValue = function getValue() {
+      var _this$props4 = this.props,
+          formDatum = _this$props4.formDatum,
+          name = _this$props4.name,
+          value = _this$props4.value,
+          defaultValue = _this$props4.defaultValue;
+
+      if (formDatum && name) {
+        if (Array.isArray(name)) {
+          var dv = defaultValue || [];
+          return name.map(function (n, i) {
+            return tryValue(formDatum.get(n), dv[i]);
+          });
+        }
+
+        return tryValue(formDatum.get(name), defaultValue);
+      }
+
+      var hasValue = 'value' in this.props || 'checked' in this.props;
+      return !hasValue ? this.state.value : value;
+    };
+
+    _proto.getError = function getError() {
+      var _this$props5 = this.props,
+          formDatum = _this$props5.formDatum,
+          name = _this$props5.name,
+          error = _this$props5.error;
+
+      if ('error' in this.props) {
+        return error;
+      }
+
+      if (formDatum && name) {
+        return formDatum.getError(this.errorName);
+      }
+
+      return this.state.error;
+    };
+
+    _proto.handleDatumBind = function handleDatumBind(datum) {
+      this.datum = datum;
+    };
+
+    _proto.handleError = function handleError(error) {
+      var _this$props6 = this.props,
+          formDatum = _this$props6.formDatum,
+          name = _this$props6.name,
+          onItemError = _this$props6.onItemError,
+          onError = _this$props6.onError;
+
+      if (formDatum && name) {
+        if (!isSameError(error, formDatum.getError(this.errorName, true))) {
+          formDatum.setError(this.errorName, error, true);
+        }
+      } else {
+        this.setState({
+          error: error
+        });
+      }
+
+      var hasError = error !== undefined;
+      this.errorChange = hasError !== this.lastError;
+      this.lastError = hasError;
+      if (onError) onError(error);
+      if (onItemError && !name) onItemError(this.itemName, error);
+    };
+
+    _proto.validateHook = function validateHook(customValidate) {
+      this.customValidate = customValidate;
+    };
+
+    _proto.validate = function validate(value, data, type) {
+      var _this3 = this;
+
+      var _this$props7 = this.props,
+          name = _this$props7.name,
+          formDatum = _this$props7.formDatum,
+          combineRules = _this$props7.combineRules,
+          bind = _this$props7.bind;
+      var names = Array.isArray(name) ? name : [name];
+      var validates = [];
+      var validateProps = filterProps(this.props, function (v) {
+        return typeof v === 'string' || typeof v === 'number';
+      });
+
+      if (this.datum) {
+        var datumValue = this.datum.formatValue(value);
+        value = this.datum.limit === 1 ? datumValue[0] : datumValue; // @ts-ignore
+
+        validateProps.type = 'array';
+      }
+
+      if (type === FORCE_PASS || value === FORCE_PASS) {
+        this.handleError();
+        return Promise.resolve(true);
+      }
+
+      if (value === undefined || Array.isArray(name)) value = this.getValue();
+      if (!Array.isArray(name)) value = [value];
+      if (this.customValidate) validates.push(this.customValidate());
+
+      if (formDatum && bind && type !== IGNORE_BIND) {
+        // console.error(new Error('Use "bind" props to combine validate is not recommend. Use Form "groups" props instead.'))
+        formDatum.validateFields(bind, IGNORE_BIND).catch(function () {});
+      }
+
+      if (!data && formDatum) data = formDatum.getValue();
+      var rules = this.props.rules;
+      names.forEach(function (n, i) {
+        if (formDatum && combineRules) {
+          rules = combineRules(n, rules);
+        }
+
+        if (isArray(rules) && rules.length > 0) {
+          validates.push(_validate(value[i], data, rules, validateProps));
+        }
+      });
+      return promiseAll(validates).then(function (res) {
+        _this3.handleError(res === true ? undefined : res);
+
+        return res;
+      }).catch(function (e) {
+        _this3.handleError(e);
+
+        return e;
+      });
+    };
+
+    _proto.handleChange = function handleChange(value) {
+      var _this4 = this;
+
+      var _this$props8 = this.props,
+          formDatum = _this$props8.formDatum,
+          name = _this$props8.name,
+          fieldSetValidate = _this$props8.fieldSetValidate,
+          onChange = _this$props8.onChange,
+          filterSameChange = _this$props8.filterSameChange;
+      var currentValue = this.getValue();
+
+      for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+        args[_key - 1] = arguments[_key];
+      }
+
+      if ((args.length === 0 || filterSameChange) && shallowEqual(value, currentValue)) {
+        return;
+      }
+
+      var beforeChange = beforeValueChange(this.props.beforeChange);
+
+      if (formDatum && name) {
+        value = beforeChange(value, formDatum);
+        formDatum.set(name, value);
+        formDatum.removeFormError(this.errorName);
+      } else {
+        value = beforeChange(value, undefined);
+        this.setState({
+          value: value
+        }, function () {
+          _this4.validate(value).catch(function () {});
+        });
+      }
+
+      if (onChange) onChange.apply(void 0, [value].concat(args));
+      if (fieldSetValidate) fieldSetValidate(true);
+    };
+
+    _proto.handleUpdate = function handleUpdate(value, sn, type) {
+      var _this5 = this;
+
+      if (type === ERROR_TYPE) {
+        if (!isSameError(value, this.state.error)) this.setState({
+          error: value
+        });
+        return;
+      }
+
+      var _this$props9 = this.props,
+          name = _this$props9.name,
+          onChange = _this$props9.onChange,
+          forceChangeOnValueSet = _this$props9.forceChangeOnValueSet;
+      var newValue = !Array.isArray(name) ? value : immer(this.getValue(), function (draft) {
+        name.forEach(function (n, i) {
+          if (n === sn) draft[i] = value;
+        });
+      });
+      if (!this.errorChange && shallowEqual(newValue, this.lastValue)) return;
+      this.lastValue = newValue;
+
+      if (type === FORCE_PASS) {
+        this.handleError();
+        this.setState({
+          error: undefined
+        });
+        this.forceUpdate();
+        return;
+      }
+
+      if (onChange && forceChangeOnValueSet) onChange(newValue);
+
+      if (type !== IGNORE_VALIDATE) {
+        if (this.updateTimer) clearTimeout(this.updateTimer);
+        this.updateTimer = setTimeout(function () {
+          _this5.validate(newValue, undefined, type).catch(function () {});
+        }, 0);
+      }
+
+      this.forceUpdate();
+    };
+
+    _proto.render = function render() {
+      var _this$props10 = this.props,
+          formDatum = _this$props10.formDatum,
+          value = _this$props10.value,
+          required = _this$props10.required,
+          bind = _this$props10.bind,
+          onItemError = _this$props10.onItemError,
+          bindInputToItem = _this$props10.bindInputToItem,
+          unbindInputFromItem = _this$props10.unbindInputFromItem,
+          scuSkip = _this$props10.scuSkip,
+          defaultValue = _this$props10.defaultValue,
+          reserveAble = _this$props10.reserveAble,
+          other = _objectWithoutPropertiesLoose(_this$props10, ["formDatum", "value", "required", "bind", "onItemError", "bindInputToItem", "unbindInputFromItem", "scuSkip", "defaultValue", "reserveAble"]);
+
+      return React.createElement(Origin, _extends({}, other, {
+        formDatum: formDatum,
+        error: this.getError(),
+        value: this.getValue(),
+        onChange: this.handleChange,
+        onDatumBind: this.handleDatumBind,
+        validateHook: this.validateHook
+      }));
+    };
+
+    _createClass(InputableInner, [{
+      key: "errorName",
+      get: function get() {
+        var name = this.props.name;
+        return Array.isArray(name) ? name.join('|') : name;
+      }
+    }]);
+
+    return InputableInner;
+  }(Component);
+
+  _defineProperty(InputableInner, "defaultProps", {
+    rules: [],
+    scuSkip: ['onChange', 'rules']
+  });
+
+  var WithFiledSetConsumer = fieldSetConsumer(InputableInner);
+  var WidthItemConsumer = itemConsumer(WithFiledSetConsumer);
+  var WidthFormConsumer = formConsumer(types)(WidthItemConsumer);
+  return WidthFormConsumer;
+});

package/esm/Form/interface.d.ts

@@ -0,0 +1 @@
+export { FormProps as Props, FormItemProps as ItemProps, FormFieldProps as FieldProps, FormFieldSetProps as FieldSetProps, FormButtonProps as SubmitProps, FormButtonProps as ResetProps, FormRef as Ref, FieldSetChildrenFunc, FieldChildrenFunc, } from './Props';

package/esm/Form/interface.js

@@ -0,0 +1 @@
+export {};

package/esm/Form/mode.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (...args: string[]) => any[];
+export default _default;

package/esm/Form/mode.js

@@ -0,0 +1,16 @@
+import { formConsumer } from './formContext';
+import { memoize } from '../utils/func';
+var createMode = memoize(function (mode) {
+  return formConsumer(['formMode'], function (props) {
+    var isMatch = mode === props.formMode;
+    if (props.reverse) isMatch = !isMatch;
+    return isMatch ? props.children : true;
+  });
+});
+export default (function () {
+  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+    args[_key] = arguments[_key];
+  }
+
+  return args.map(createMode);
+});