@helpdice/ui 1.0.1 → 1.0.2

package/esm/form/FastField.js

@@ -0,0 +1,147 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _possibleConstructorReturn from "@babel/runtime/helpers/esm/possibleConstructorReturn";
+import _getPrototypeOf from "@babel/runtime/helpers/esm/getPrototypeOf";
+import _inherits from "@babel/runtime/helpers/esm/inherits";
+var _excluded = ["validate", "name", "render", "as", "children", "component", "shouldUpdate", "formik"],
+  _excluded2 = ["validate", "validationSchema"],
+  _excluded3 = ["innerRef"],
+  _excluded4 = ["innerRef"];
+function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+import * as React from 'react';
+import invariant from 'tiny-warning';
+import { getIn, isEmptyChildren, isFunction } from './utils';
+import { connect } from './connect';
+/**
+ * Custom Field component for quickly hooking into Formik
+ * context and wiring up forms.
+ */
+var FastFieldInner = /*#__PURE__*/function (_React$Component) {
+  function FastFieldInner(props) {
+    var _this;
+    _classCallCheck(this, FastFieldInner);
+    _this = _callSuper(this, FastFieldInner, [props]);
+    var render = props.render,
+      children = props.children,
+      component = props.component,
+      is = props.as,
+      name = props.name;
+    invariant(!render, "<FastField render> has been deprecated. Please use a child callback function instead: <FastField name={".concat(name, "}>{props => ...}</FastField> instead."));
+    invariant(!(component && render), 'You should not use <FastField component> and <FastField render> in the same <FastField> component; <FastField component> will be ignored');
+    invariant(!(is && children && isFunction(children)), 'You should not use <FastField as> and <FastField children> as a function in the same <FastField> component; <FastField as> will be ignored.');
+    invariant(!(component && children && isFunction(children)), 'You should not use <FastField component> and <FastField children> as a function in the same <FastField> component; <FastField component> will be ignored.');
+    invariant(!(render && children && !isEmptyChildren(children)), 'You should not use <FastField render> and <FastField children> in the same <FastField> component; <FastField children> will be ignored');
+    return _this;
+  }
+  _inherits(FastFieldInner, _React$Component);
+  return _createClass(FastFieldInner, [{
+    key: "shouldComponentUpdate",
+    value: function shouldComponentUpdate(props) {
+      if (this.props.shouldUpdate) {
+        return this.props.shouldUpdate(props, this.props);
+      } else if (props.name !== this.props.name || getIn(props.formik.values, this.props.name) !== getIn(this.props.formik.values, this.props.name) || getIn(props.formik.errors, this.props.name) !== getIn(this.props.formik.errors, this.props.name) || getIn(props.formik.touched, this.props.name) !== getIn(this.props.formik.touched, this.props.name) || Object.keys(this.props).length !== Object.keys(props).length || props.formik.isSubmitting !== this.props.formik.isSubmitting) {
+        return true;
+      } else {
+        return false;
+      }
+    }
+  }, {
+    key: "componentDidMount",
+    value: function componentDidMount() {
+      // Register the Field with the parent Formik. Parent will cycle through
+      // registered Field's validate fns right prior to submit
+      this.props.formik.registerField(this.props.name, {
+        validate: this.props.validate
+      });
+    }
+  }, {
+    key: "componentDidUpdate",
+    value: function componentDidUpdate(prevProps) {
+      if (this.props.name !== prevProps.name) {
+        this.props.formik.unregisterField(prevProps.name);
+        this.props.formik.registerField(this.props.name, {
+          validate: this.props.validate
+        });
+      }
+      if (this.props.validate !== prevProps.validate) {
+        this.props.formik.registerField(this.props.name, {
+          validate: this.props.validate
+        });
+      }
+    }
+  }, {
+    key: "componentWillUnmount",
+    value: function componentWillUnmount() {
+      this.props.formik.unregisterField(this.props.name);
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _ref = this.props,
+        validate = _ref.validate,
+        name = _ref.name,
+        render = _ref.render,
+        is = _ref.as,
+        children = _ref.children,
+        component = _ref.component,
+        shouldUpdate = _ref.shouldUpdate,
+        formik = _ref.formik,
+        props = _objectWithoutProperties(_ref, _excluded);
+      var _validate = formik.validate,
+        _validationSchema = formik.validationSchema,
+        restOfFormik = _objectWithoutProperties(formik, _excluded2);
+      var field = formik.getFieldProps(_extends({
+        name: name
+      }, props));
+      var meta = {
+        value: getIn(formik.values, name),
+        error: getIn(formik.errors, name),
+        touched: !!getIn(formik.touched, name),
+        initialValue: getIn(formik.initialValues, name),
+        initialTouched: !!getIn(formik.initialTouched, name),
+        initialError: getIn(formik.initialErrors, name)
+      };
+      var bag = {
+        field: field,
+        meta: meta,
+        form: restOfFormik
+      };
+      if (render) {
+        return render(bag);
+      }
+      if (isFunction(children)) {
+        return children(bag);
+      }
+      if (component) {
+        // This behavior is backwards compat with earlier Formik 0.9 to 1.x
+        if (typeof component === 'string') {
+          var innerRef = props.innerRef,
+            rest = _objectWithoutProperties(props, _excluded3);
+          return /*#__PURE__*/React.createElement(component, _extends({
+            ref: innerRef
+          }, field, rest), children);
+        }
+        // We don't pass `meta` for backwards compat
+        return /*#__PURE__*/React.createElement(component, _extends({
+          field: field,
+          form: formik
+        }, props), children);
+      }
+
+      // default to input here so we can check for both `as` and `children` above
+      var asElement = is || 'input';
+      if (typeof asElement === 'string') {
+        var _innerRef = props.innerRef,
+          _rest = _objectWithoutProperties(props, _excluded4);
+        return /*#__PURE__*/React.createElement(asElement, _extends({
+          ref: _innerRef
+        }, field, _rest), children);
+      }
+      return /*#__PURE__*/React.createElement(asElement, _extends({}, field, props), children);
+    }
+  }]);
+}(React.Component);
+export var FastField = connect(FastFieldInner);

package/esm/form/Field.d.ts

@@ -0,0 +1,53 @@
+import * as React from 'react';
+import { FormikProps, GenericFieldHTMLAttributes, FieldMetaProps, FieldHelperProps, FieldInputProps, FieldValidator } from "./types";
+export interface FieldProps<V = any, FormValues = any> {
+    field: FieldInputProps<V>;
+    form: FormikProps<FormValues>;
+    meta: FieldMetaProps<V>;
+}
+export interface FieldConfig<V = any> {
+    /**
+     * Field component to render. Can either be a string like 'select' or a component.
+     */
+    component?: string | React.ComponentType<FieldProps<V>> | React.ComponentType | React.ForwardRefExoticComponent<any>;
+    /**
+     * Component to render. Can either be a string e.g. 'select', 'input', or 'textarea', or a component.
+     */
+    as?: React.ComponentType<FieldProps<V>['field']> | string | React.ComponentType | React.ForwardRefExoticComponent<any>;
+    /**
+     * Render prop (works like React router's <Route render={props =>} />)
+     * @deprecated
+     */
+    render?: (props: FieldProps<V>) => React.ReactNode;
+    /**
+     * Children render function <Field name>{props => ...}</Field>)
+     */
+    children?: ((props: FieldProps<V>) => React.ReactNode) | React.ReactNode;
+    /**
+     * Validate a single field value independently
+     */
+    validate?: FieldValidator;
+    /**
+     * Used for 'select' and related input types.
+     */
+    multiple?: boolean;
+    /**
+     * Field name
+     */
+    name: string;
+    /** HTML input type */
+    type?: string;
+    /** Field value */
+    value?: any;
+    /** Inner ref */
+    innerRef?: (instance: any) => void;
+}
+export type FieldAttributes<T> = {
+    className?: string;
+} & GenericFieldHTMLAttributes & FieldConfig<T> & T & {
+    name: string;
+};
+export type FieldHookConfig<T> = GenericFieldHTMLAttributes & FieldConfig<T>;
+export declare function useField<Val = any>(propsOrFieldName: string | FieldHookConfig<Val>): [FieldInputProps<Val>, FieldMetaProps<Val>, FieldHelperProps<Val>];
+export declare function Field({ validate, name, render, children, as: is, // `as` is reserved in typescript lol
+component, className, ...props }: FieldAttributes<any>): any;

package/esm/form/Field.js

@@ -0,0 +1,137 @@
+"use client";
+
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+var _excluded = ["validate", "name", "render", "children", "as", "component", "className"],
+  _excluded2 = ["validate", "validationSchema"],
+  _excluded3 = ["innerRef"],
+  _excluded4 = ["innerRef"];
+import * as React from 'react';
+import { useFormikContext } from './FormikContext';
+import { isFunction, isEmptyChildren, isObject } from './utils';
+import invariant from 'tiny-warning';
+import { __DEV__ } from './constants';
+export function useField(propsOrFieldName) {
+  var formik = useFormikContext();
+  var getFieldProps = formik.getFieldProps,
+    getFieldMeta = formik.getFieldMeta,
+    getFieldHelpers = formik.getFieldHelpers,
+    registerField = formik.registerField,
+    unregisterField = formik.unregisterField;
+  var isAnObject = isObject(propsOrFieldName);
+
+  // Normalize propsOrFieldName to FieldHookConfig<Val>
+  var props = isAnObject ? propsOrFieldName : {
+    name: propsOrFieldName
+  };
+  var fieldName = props.name,
+    validateFn = props.validate;
+  React.useEffect(function () {
+    if (fieldName) {
+      registerField(fieldName, {
+        validate: validateFn
+      });
+    }
+    return function () {
+      if (fieldName) {
+        unregisterField(fieldName);
+      }
+    };
+  }, [registerField, unregisterField, fieldName, validateFn]);
+  if (__DEV__) {
+    invariant(formik, 'useField() / <Field /> must be used underneath a <Formik> component or withFormik() higher order component');
+  }
+  invariant(fieldName, 'Invalid field name. Either pass `useField` a string or an object containing a `name` key.');
+  var fieldHelpers = React.useMemo(function () {
+    return getFieldHelpers(fieldName);
+  }, [getFieldHelpers, fieldName]);
+  return [getFieldProps(props), getFieldMeta(fieldName), fieldHelpers];
+}
+export function Field(_ref) {
+  var validate = _ref.validate,
+    name = _ref.name,
+    render = _ref.render,
+    children = _ref.children,
+    is = _ref.as,
+    component = _ref.component,
+    className = _ref.className,
+    props = _objectWithoutProperties(_ref, _excluded);
+  var _useFormikContext = useFormikContext(),
+    _validate = _useFormikContext.validate,
+    _validationSchema = _useFormikContext.validationSchema,
+    formik = _objectWithoutProperties(_useFormikContext, _excluded2);
+  if (__DEV__) {
+    // eslint-disable-next-line react-hooks/rules-of-hooks
+    React.useEffect(function () {
+      invariant(!render, "<Field render> has been deprecated and will be removed in future versions of Formik. Please use a child callback function instead. To get rid of this warning, replace <Field name=\"".concat(name, "\" render={({field, form}) => ...} /> with <Field name=\"").concat(name, "\">{({field, form, meta}) => ...}</Field>"));
+      invariant(!(is && children && isFunction(children)), 'You should not use <Field as> and <Field children> as a function in the same <Field> component; <Field as> will be ignored.');
+      invariant(!(component && children && isFunction(children)), 'You should not use <Field component> and <Field children> as a function in the same <Field> component; <Field component> will be ignored.');
+      invariant(!(render && children && !isEmptyChildren(children)), 'You should not use <Field render> and <Field children> in the same <Field> component; <Field children> will be ignored');
+      // eslint-disable-next-line
+    }, []);
+  }
+
+  // Register field and field-level validation with parent <Formik>
+  var registerField = formik.registerField,
+    unregisterField = formik.unregisterField;
+  React.useEffect(function () {
+    registerField(name, {
+      validate: validate
+    });
+    return function () {
+      unregisterField(name);
+    };
+  }, [registerField, unregisterField, name, validate]);
+  var field = formik.getFieldProps(_extends({
+    name: name
+  }, props));
+  var meta = formik.getFieldMeta(name);
+  var legacyBag = {
+    field: field,
+    form: formik
+  };
+  if (render) {
+    return render(_extends({}, legacyBag, {
+      meta: meta
+    }));
+  }
+  if (isFunction(children)) {
+    return children(_extends({}, legacyBag, {
+      meta: meta
+    }));
+  }
+  if (component) {
+    // This behavior is backwards compat with earlier Formik 0.9 to 1.x
+    if (typeof component === 'string') {
+      var innerRef = props.innerRef,
+        rest = _objectWithoutProperties(props, _excluded3);
+      return /*#__PURE__*/React.createElement(component, _extends({
+        ref: innerRef
+      }, field, rest, {
+        className: className
+      }), children);
+    }
+    // We don't pass `meta` for backwards compat
+    return /*#__PURE__*/React.createElement(component, _extends({
+      field: field,
+      form: formik
+    }, props, {
+      className: className
+    }), children);
+  }
+
+  // default to input here so we can check for both `as` and `children` above
+  var asElement = is || 'input';
+  if (typeof asElement === 'string') {
+    var _innerRef = props.innerRef,
+      _rest = _objectWithoutProperties(props, _excluded4);
+    return /*#__PURE__*/React.createElement(asElement, _extends({
+      ref: _innerRef
+    }, field, _rest, {
+      className: className
+    }), children);
+  }
+  return /*#__PURE__*/React.createElement(asElement, _extends({}, field, props, {
+    className: className
+  }), children);
+}

package/esm/form/FieldArray.js

@@ -0,0 +1,281 @@
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _possibleConstructorReturn from "@babel/runtime/helpers/esm/possibleConstructorReturn";
+import _getPrototypeOf from "@babel/runtime/helpers/esm/getPrototypeOf";
+import _inherits from "@babel/runtime/helpers/esm/inherits";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+var _excluded = ["validate", "validationSchema"];
+function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+import cloneDeep from 'lodash/cloneDeep';
+import * as React from 'react';
+import isEqual from 'react-fast-compare';
+import { connect } from './connect';
+import { getIn, isEmptyArray, isEmptyChildren, isFunction, isObject, setIn } from './utils';
+/**
+ * Some array helpers!
+ */
+export var move = function move(array, from, to) {
+  var copy = copyArrayLike(array);
+  var value = copy[from];
+  copy.splice(from, 1);
+  copy.splice(to, 0, value);
+  return copy;
+};
+export var swap = function swap(arrayLike, indexA, indexB) {
+  var copy = copyArrayLike(arrayLike);
+  var a = copy[indexA];
+  copy[indexA] = copy[indexB];
+  copy[indexB] = a;
+  return copy;
+};
+export var insert = function insert(arrayLike, index, value) {
+  var copy = copyArrayLike(arrayLike);
+  copy.splice(index, 0, value);
+  return copy;
+};
+export var replace = function replace(arrayLike, index, value) {
+  var copy = copyArrayLike(arrayLike);
+  copy[index] = value;
+  return copy;
+};
+var copyArrayLike = function copyArrayLike(arrayLike) {
+  if (!arrayLike) {
+    return [];
+  } else if (Array.isArray(arrayLike)) {
+    return _toConsumableArray(arrayLike);
+  } else {
+    var maxIndex = Object.keys(arrayLike).map(function (key) {
+      return parseInt(key);
+    }).reduce(function (max, el) {
+      return el > max ? el : max;
+    }, 0);
+    return Array.from(_extends({}, arrayLike, {
+      length: maxIndex + 1
+    }));
+  }
+};
+var createAlterationHandler = function createAlterationHandler(alteration, defaultFunction) {
+  var fn = typeof alteration === 'function' ? alteration : defaultFunction;
+  return function (data) {
+    if (Array.isArray(data) || isObject(data)) {
+      var clone = copyArrayLike(data);
+      return fn(clone);
+    }
+
+    // This can be assumed to be a primitive, which
+    // is a case for top level validation errors
+    return data;
+  };
+};
+var FieldArrayInner = /*#__PURE__*/function (_React$Component) {
+  function FieldArrayInner(props) {
+    var _this;
+    _classCallCheck(this, FieldArrayInner);
+    _this = _callSuper(this, FieldArrayInner, [props]);
+    // We need TypeScript generics on these, so we'll bind them in the constructor
+    // @todo Fix TS 3.2.1
+    _defineProperty(_this, "updateArrayField", function (fn, alterTouched, alterErrors) {
+      var _this$props = _this.props,
+        name = _this$props.name,
+        setFormikState = _this$props.formik.setFormikState;
+      setFormikState(function (prevState) {
+        var updateErrors = createAlterationHandler(alterErrors, fn);
+        var updateTouched = createAlterationHandler(alterTouched, fn);
+
+        // values fn should be executed before updateErrors and updateTouched,
+        // otherwise it causes an error with unshift.
+        var values = setIn(prevState.values, name, fn(getIn(prevState.values, name)));
+        var fieldError = alterErrors ? updateErrors(getIn(prevState.errors, name)) : undefined;
+        var fieldTouched = alterTouched ? updateTouched(getIn(prevState.touched, name)) : undefined;
+        if (isEmptyArray(fieldError)) {
+          fieldError = undefined;
+        }
+        if (isEmptyArray(fieldTouched)) {
+          fieldTouched = undefined;
+        }
+        return _extends({}, prevState, {
+          values: values,
+          errors: alterErrors ? setIn(prevState.errors, name, fieldError) : prevState.errors,
+          touched: alterTouched ? setIn(prevState.touched, name, fieldTouched) : prevState.touched
+        });
+      });
+    });
+    _defineProperty(_this, "push", function (value) {
+      return _this.updateArrayField(function (arrayLike) {
+        return [].concat(_toConsumableArray(copyArrayLike(arrayLike)), [cloneDeep(value)]);
+      }, false, false);
+    });
+    _defineProperty(_this, "handlePush", function (value) {
+      return function () {
+        return _this.push(value);
+      };
+    });
+    _defineProperty(_this, "swap", function (indexA, indexB) {
+      return _this.updateArrayField(function (array) {
+        return swap(array, indexA, indexB);
+      }, true, true);
+    });
+    _defineProperty(_this, "handleSwap", function (indexA, indexB) {
+      return function () {
+        return _this.swap(indexA, indexB);
+      };
+    });
+    _defineProperty(_this, "move", function (from, to) {
+      return _this.updateArrayField(function (array) {
+        return move(array, from, to);
+      }, true, true);
+    });
+    _defineProperty(_this, "handleMove", function (from, to) {
+      return function () {
+        return _this.move(from, to);
+      };
+    });
+    _defineProperty(_this, "insert", function (index, value) {
+      return _this.updateArrayField(function (array) {
+        return insert(array, index, value);
+      }, function (array) {
+        return insert(array, index, null);
+      }, function (array) {
+        return insert(array, index, null);
+      });
+    });
+    _defineProperty(_this, "handleInsert", function (index, value) {
+      return function () {
+        return _this.insert(index, value);
+      };
+    });
+    _defineProperty(_this, "replace", function (index, value) {
+      return _this.updateArrayField(function (array) {
+        return replace(array, index, value);
+      }, false, false);
+    });
+    _defineProperty(_this, "handleReplace", function (index, value) {
+      return function () {
+        return _this.replace(index, value);
+      };
+    });
+    _defineProperty(_this, "unshift", function (value) {
+      var length = -1;
+      _this.updateArrayField(function (array) {
+        var arr = array ? [value].concat(_toConsumableArray(array)) : [value];
+        length = arr.length;
+        return arr;
+      }, function (array) {
+        return array ? [null].concat(_toConsumableArray(array)) : [null];
+      }, function (array) {
+        return array ? [null].concat(_toConsumableArray(array)) : [null];
+      });
+      return length;
+    });
+    _defineProperty(_this, "handleUnshift", function (value) {
+      return function () {
+        return _this.unshift(value);
+      };
+    });
+    _defineProperty(_this, "handleRemove", function (index) {
+      return function () {
+        return _this.remove(index);
+      };
+    });
+    _defineProperty(_this, "handlePop", function () {
+      return function () {
+        return _this.pop();
+      };
+    });
+    _this.remove = _this.remove.bind(_this);
+    _this.pop = _this.pop.bind(_this);
+    return _this;
+  }
+  _inherits(FieldArrayInner, _React$Component);
+  return _createClass(FieldArrayInner, [{
+    key: "componentDidUpdate",
+    value: function componentDidUpdate(prevProps) {
+      if (this.props.validateOnChange && this.props.formik.validateOnChange && !isEqual(getIn(prevProps.formik.values, prevProps.name), getIn(this.props.formik.values, this.props.name))) {
+        this.props.formik.validateForm(this.props.formik.values);
+      }
+    }
+  }, {
+    key: "remove",
+    value: function remove(index) {
+      // We need to make sure we also remove relevant pieces of `touched` and `errors`
+      var result;
+      this.updateArrayField(
+      // so this gets call 3 times
+      function (array) {
+        var copy = array ? copyArrayLike(array) : [];
+        if (!result) {
+          result = copy[index];
+        }
+        if (isFunction(copy.splice)) {
+          copy.splice(index, 1);
+        }
+        // if the array only includes undefined values we have to return an empty array
+        return isFunction(copy.every) ? copy.every(function (v) {
+          return v === undefined;
+        }) ? [] : copy : copy;
+      }, true, true);
+      return result;
+    }
+  }, {
+    key: "pop",
+    value: function pop() {
+      // Remove relevant pieces of `touched` and `errors` too!
+      var result;
+      this.updateArrayField(
+      // so this gets call 3 times
+      function (array) {
+        var tmp = array.slice();
+        if (!result) {
+          result = tmp && tmp.pop && tmp.pop();
+        }
+        return tmp;
+      }, true, true);
+      return result;
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var arrayHelpers = {
+        push: this.push,
+        pop: this.pop,
+        swap: this.swap,
+        move: this.move,
+        insert: this.insert,
+        replace: this.replace,
+        unshift: this.unshift,
+        remove: this.remove,
+        handlePush: this.handlePush,
+        handlePop: this.handlePop,
+        handleSwap: this.handleSwap,
+        handleMove: this.handleMove,
+        handleInsert: this.handleInsert,
+        handleReplace: this.handleReplace,
+        handleUnshift: this.handleUnshift,
+        handleRemove: this.handleRemove
+      };
+      var _this$props2 = this.props,
+        component = _this$props2.component,
+        render = _this$props2.render,
+        children = _this$props2.children,
+        name = _this$props2.name,
+        _this$props2$formik = _this$props2.formik,
+        _validate = _this$props2$formik.validate,
+        _validationSchema = _this$props2$formik.validationSchema,
+        restOfFormik = _objectWithoutProperties(_this$props2$formik, _excluded);
+      var props = _extends({}, arrayHelpers, {
+        form: restOfFormik,
+        name: name
+      });
+      return component ? /*#__PURE__*/React.createElement(component, props) : render ? render(props) : children // children come last, always called
+      ? typeof children === 'function' ? children(props) : !isEmptyChildren(children) ? React.Children.only(children) : null : null;
+    }
+  }]);
+}(React.Component);
+_defineProperty(FieldArrayInner, "defaultProps", {
+  validateOnChange: true
+});
+export var FieldArray = connect(FieldArrayInner);

package/esm/form/Form.js

@@ -0,0 +1,23 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+var _excluded = ["action"];
+import * as React from 'react';
+import { useFormikContext } from './FormikContext';
+// @todo tests
+export var Form = /*#__PURE__*/React.forwardRef(function (props, ref) {
+  // iOS needs an "action" attribute for nice input: https://stackoverflow.com/a/39485162/406725
+  // We default the action to "#" in case the preventDefault fails (just updates the URL hash)
+  var action = props.action,
+    rest = _objectWithoutProperties(props, _excluded);
+  var _action = action !== null && action !== void 0 ? action : '#';
+  var _useFormikContext = useFormikContext(),
+    handleReset = _useFormikContext.handleReset,
+    handleSubmit = _useFormikContext.handleSubmit;
+  return /*#__PURE__*/React.createElement("form", _extends({
+    onSubmit: handleSubmit,
+    ref: ref,
+    onReset: handleReset,
+    action: _action
+  }, rest));
+});
+Form.displayName = 'Form';