@helpdice/ui 1.0.1 → 1.0.2

package/esm/form/FormikContext.d.ts

@@ -0,0 +1,6 @@
+import * as React from 'react';
+import { FormikContextType } from "./types";
+export declare const FormikContext: React.Context<FormikContextType<any>>;
+export declare const FormikProvider: React.Provider<FormikContextType<any>>;
+export declare const FormikConsumer: React.Consumer<FormikContextType<any>>;
+export declare function useFormikContext<Values>(): FormikContextType<Values>;

package/esm/form/FormikContext.js

@@ -0,0 +1,11 @@
+import * as React from 'react';
+import invariant from 'tiny-warning';
+export var FormikContext = /*#__PURE__*/React.createContext(undefined);
+FormikContext.displayName = 'FormikContext';
+export var FormikProvider = FormikContext.Provider;
+export var FormikConsumer = FormikContext.Consumer;
+export function useFormikContext() {
+  var formik = React.useContext(FormikContext);
+  invariant(!!formik, "Formik context is undefined, please verify you are calling useFormikContext() as child of a <Formik> component.");
+  return formik;
+}

package/esm/form/connect.d.ts

@@ -0,0 +1,12 @@
+import * as React from 'react';
+import hoistNonReactStatics from 'hoist-non-react-statics';
+import { FormikContextType } from "./types";
+/**
+ * Connect any component to Formik context, and inject as a prop called `formik`;
+ * @param Comp React Component
+ */
+export default function connect<OuterProps, Values = {}>(Comp: React.ComponentType<OuterProps & {
+    formik: FormikContextType<Values>;
+}>): React.FC<OuterProps> & hoistNonReactStatics.NonReactStatics<React.ComponentClass<OuterProps & {
+    formik: FormikContextType<Values>;
+}, any>, {}>;

package/esm/form/connect.js

@@ -0,0 +1,30 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import * as React from 'react';
+import hoistNonReactStatics from 'hoist-non-react-statics';
+import { FormikConsumer } from './FormikContext';
+import invariant from 'tiny-warning';
+
+/**
+ * Connect any component to Formik context, and inject as a prop called `formik`;
+ * @param Comp React Component
+ */
+export default function connect(Comp) {
+  var C = function C(props) {
+    return /*#__PURE__*/React.createElement(FormikConsumer, null, function (formik) {
+      invariant(!!formik, "Formik context is undefined, please verify you are rendering <Form>, <Field>, <FastField>, <FieldArray>, or your custom context-using component as a child of a <Formik> component. Component name: ".concat(Comp.name));
+      return /*#__PURE__*/React.createElement(Comp, _extends({}, props, {
+        formik: formik
+      }));
+    });
+  };
+  var componentDisplayName = Comp.displayName || Comp.name || Comp.constructor && Comp.constructor.name || 'Component';
+
+  // Assign Comp to C.WrappedComponent so we can access the inner component in tests
+  // For example, <Field.WrappedComponent /> gets us <FieldInner/>
+  C.WrappedComponent = Comp;
+  C.displayName = "FormikConnect(".concat(componentDisplayName, ")");
+  return hoistNonReactStatics(C, Comp
+
+  // cast type to ComponentClass (even if SFC)
+  );
+}

package/esm/form/constants.d.ts

@@ -0,0 +1 @@
+export declare const __DEV__ = true;

package/esm/form/constants.js

@@ -0,0 +1 @@
+export var __DEV__ = true;

package/esm/form/index.d.ts

@@ -0,0 +1,9 @@
+import connect from "./connect";
+import { FormWrapper, useFormik, yupToFormErrors, validateYupSchema, prepareDataForValidation } from "./FormWrapper";
+import withFormik from "./withFormik";
+import { isEmptyArray, isEmptyChildren, isInputEvent, isInteger, isObject, isPromise, isFunction, isNaN, isString, getActiveElement, getIn, setIn, setNestedObjectValues } from "./utils";
+import ErrorMessage from "./ErrorMessage";
+import { FormikContext, FormikProvider, FormikConsumer, useFormikContext } from "./FormikContext";
+import { FieldHelperProps, FieldInputProps, FieldMetaProps, FieldValidator, FormikComputedProps, FormikConfig, FormikContextType, FormikErrors, FormikHandlers, FormikHelpers, FormikProps, FormikRegistration, FormikSharedConfig, FormikState, FormikTouched, FormikValues, GenericFieldHTMLAttributes } from "./types";
+export type { FormikValues, FormikErrors, FormikTouched, FormikState, FormikComputedProps, FormikHelpers, FormikHandlers, FormikSharedConfig, FormikConfig, FormikProps, FormikRegistration, FormikContextType, GenericFieldHTMLAttributes, FieldMetaProps, FieldHelperProps, FieldInputProps, FieldValidator };
+export { FormikContext, FormikProvider, FormikConsumer, useFormikContext, ErrorMessage, FormWrapper, useFormik, yupToFormErrors, validateYupSchema, prepareDataForValidation, connect, withFormik, isEmptyArray, isEmptyChildren, isInputEvent, isInteger, isObject, isPromise, isFunction, isNaN, isString, getActiveElement, getIn, setIn, setNestedObjectValues };

package/esm/form/index.js

@@ -0,0 +1,15 @@
+"use client";
+
+import connect from './connect';
+import { FormWrapper, useFormik, yupToFormErrors, validateYupSchema, prepareDataForValidation } from './FormWrapper';
+// export * from './Field';
+// export * from './Form';
+import withFormik from './withFormik';
+// import * as FieldArray from './FieldArray';
+import { isEmptyArray, isEmptyChildren, isInputEvent, isInteger, isObject, isPromise, isFunction, isNaN, isString, getActiveElement, getIn, setIn, setNestedObjectValues } from './utils';
+import ErrorMessage from './ErrorMessage';
+import { FormikContext, FormikProvider, FormikConsumer, useFormikContext } from './FormikContext';
+
+// export * from './FastField';
+
+export { FormikContext, FormikProvider, FormikConsumer, useFormikContext, ErrorMessage, FormWrapper, useFormik, yupToFormErrors, validateYupSchema, prepareDataForValidation, connect, withFormik, isEmptyArray, isEmptyChildren, isInputEvent, isInteger, isObject, isPromise, isFunction, isNaN, isString, getActiveElement, getIn, setIn, setNestedObjectValues };

package/esm/form/types.d.ts

@@ -0,0 +1,249 @@
+import * as React from 'react';
+import { FieldConfig } from "./Field";
+/**
+ * Values of fields in the form
+ */
+export interface FormikValues {
+    [field: string]: any;
+}
+/**
+ * An object containing error messages whose keys correspond to FormikValues.
+ * Should always be an object of strings, but any is allowed to support i18n libraries.
+ */
+export type FormikErrors<Values> = {
+    [K in keyof Values]?: Values[K] extends any[] ? Values[K][number] extends object ? FormikErrors<Values[K][number]>[] | string | string[] : string | string[] : Values[K] extends object ? FormikErrors<Values[K]> : string;
+};
+/**
+ * An object containing touched state of the form whose keys correspond to FormikValues.
+ */
+export type FormikTouched<Values> = {
+    [K in keyof Values]?: Values[K] extends any[] ? Values[K][number] extends object ? FormikTouched<Values[K][number]>[] : boolean : Values[K] extends object ? FormikTouched<Values[K]> : boolean;
+};
+/**
+ * Formik state tree
+ */
+export interface FormikState<Values> {
+    /** Form values */
+    values: Values;
+    /** map of field names to specific error for that field */
+    errors: FormikErrors<Values>;
+    /** map of field names to whether the field has been touched */
+    touched: FormikTouched<Values>;
+    /** whether the form is currently submitting */
+    isSubmitting: boolean;
+    /** whether the form is currently validating (prior to submission) */
+    isValidating: boolean;
+    /** Top level status state, in case you need it */
+    status?: any;
+    /** Number of times user tried to submit the form */
+    submitCount: number;
+}
+/**
+ * Formik computed properties. These are read-only.
+ */
+export interface FormikComputedProps<Values> {
+    /** True if any input has been touched. False otherwise. */
+    readonly dirty: boolean;
+    /** True if state.errors is empty */
+    readonly isValid: boolean;
+    /** The initial values of the form */
+    readonly initialValues: Values;
+    /** The initial errors of the form */
+    readonly initialErrors: FormikErrors<Values>;
+    /** The initial visited fields of the form */
+    readonly initialTouched: FormikTouched<Values>;
+    /** The initial status of the form */
+    readonly initialStatus?: any;
+}
+/**
+ * Formik state helpers
+ */
+export interface FormikHelpers<Values> {
+    /** Manually set top level status. */
+    setStatus: (status?: any) => void;
+    /** Manually set errors object */
+    setErrors: (errors: FormikErrors<Values>) => void;
+    /** Manually set isSubmitting */
+    setSubmitting: (isSubmitting: boolean) => void;
+    /** Manually set touched object */
+    setTouched: (touched: FormikTouched<Values>, shouldValidate?: boolean) => Promise<void | FormikErrors<Values>>;
+    /** Manually set values object  */
+    setValues: (values: React.SetStateAction<Values>, shouldValidate?: boolean) => Promise<void | FormikErrors<Values>>;
+    /** Set value of form field directly */
+    setFieldValue: (field: string, value: any, shouldValidate?: boolean) => Promise<void | FormikErrors<Values>>;
+    /** Set error message of a form field directly */
+    setFieldError: (field: string, message: string | undefined) => void;
+    /** Set whether field has been touched directly */
+    setFieldTouched: (field: string, isTouched?: boolean, shouldValidate?: boolean) => Promise<void | FormikErrors<Values>>;
+    /** Validate form values */
+    validateForm: (values?: any) => Promise<FormikErrors<Values>>;
+    /** Validate field value */
+    validateField: (field: string) => Promise<void> | Promise<string | undefined>;
+    /** Reset form */
+    resetForm: (nextState?: Partial<FormikState<Values>>) => void;
+    /** Submit the form imperatively */
+    submitForm: () => Promise<void>;
+    /** Set Formik state, careful! */
+    setFormikState: (f: FormikState<Values> | ((prevState: FormikState<Values>) => FormikState<Values>), cb?: () => void) => void;
+}
+/**
+ * Formik form event handlers
+ */
+export interface FormikHandlers {
+    /** Form submit handler */
+    handleSubmit: (e?: React.FormEvent<HTMLFormElement>) => void;
+    /** Reset form event handler  */
+    handleReset: (e?: React.SyntheticEvent<any>) => void;
+    handleBlur: {
+        /** Classic React blur handler, keyed by input name */
+        (e: React.FocusEvent<any>): void;
+        /** Preact-like linkState. Will return a handleBlur function. */
+        <T = string | any>(fieldOrEvent: T): T extends string ? (e: any) => void : void;
+    };
+    handleChange: {
+        /** Classic React change handler, keyed by input name */
+        (e: React.ChangeEvent<any>): void;
+        /** Preact-like linkState. Will return a handleChange function.  */
+        <T = string | React.ChangeEvent<any>>(field: T): T extends React.ChangeEvent<any> ? void : (e: string | React.ChangeEvent<any>) => void;
+    };
+    getFieldProps: <Value = any>(props: string | FieldConfig<Value>) => FieldInputProps<Value>;
+    getFieldMeta: <Value>(name: string) => FieldMetaProps<Value>;
+    getFieldHelpers: <Value = any>(name: string) => FieldHelperProps<Value>;
+}
+/**
+ * Base formik configuration/props shared between the HoC and Component.
+ */
+export interface FormikSharedConfig<Props = {}> {
+    /** Tells Formik to validate the form on each input's onChange event */
+    validateOnChange?: boolean;
+    /** Tells Formik to validate the form on each input's onBlur event */
+    validateOnBlur?: boolean;
+    /** Tells Formik to validate upon mount */
+    validateOnMount?: boolean;
+    /** Tell Formik if initial form values are valid or not on first render */
+    isInitialValid?: boolean | ((props: Props) => boolean);
+    /** Should Formik reset the form when new initialValues change */
+    enableReinitialize?: boolean;
+}
+/**
+ * <Formik /> props
+ */
+export interface FormikConfig<Values> extends FormikSharedConfig {
+    /**
+     * Form component to render
+     */
+    component?: React.ComponentType<FormikProps<Values>>;
+    /**
+     * Render prop (works like React router's <Route render={props =>} />)
+     * @deprecated
+     */
+    render?: (props: FormikProps<Values>) => React.ReactNode;
+    /**
+     * React children or child render callback
+     */
+    children?: ((props: FormikProps<Values>) => React.ReactNode) | React.ReactNode;
+    /**
+     * Initial values of the form
+     */
+    initialValues: Values;
+    /**
+     * Initial status
+     */
+    initialStatus?: any;
+    /** Initial object map of field names to specific error for that field */
+    initialErrors?: FormikErrors<Values>;
+    /** Initial object map of field names to whether the field has been touched */
+    initialTouched?: FormikTouched<Values>;
+    /**
+     * Reset handler
+     */
+    onReset?: (values: Values, formikHelpers: FormikHelpers<Values>) => void;
+    /**
+     * Submission handler
+     */
+    onSubmit: (values: Values, formikHelpers: FormikHelpers<Values>) => void | Promise<any>;
+    /**
+     * A Yup Schema or a function that returns a Yup schema
+     */
+    validationSchema?: any | (() => any);
+    /**
+     * Validation function. Must return an error object or promise that
+     * throws an error object where that object keys map to corresponding value.
+     */
+    validate?: (values: Values) => void | object | Promise<FormikErrors<Values>>;
+    /** Inner ref */
+    innerRef?: React.Ref<FormikProps<Values>>;
+}
+/**
+ * State, handlers, and helpers made available to form component or render prop
+ * of <Formik/>.
+ */
+export type FormikProps<Values> = FormikSharedConfig & FormikState<Values> & FormikHelpers<Values> & FormikHandlers & FormikComputedProps<Values> & FormikRegistration & {
+    submitForm: () => Promise<any>;
+};
+/** Internal Formik registration methods that get passed down as props */
+export interface FormikRegistration {
+    registerField: (name: string, fns: {
+        validate?: FieldValidator;
+    }) => void;
+    unregisterField: (name: string) => void;
+}
+/**
+ * State, handlers, and helpers made available to Formik's primitive components through context.
+ */
+export type FormikContextType<Values> = FormikProps<Values> & Pick<FormikConfig<Values>, 'validate' | 'validationSchema'>;
+export interface SharedRenderProps<T> {
+    /**
+     * Field component to render. Can either be a string like 'select' or a component.
+     */
+    component?: keyof JSX.IntrinsicElements | React.ComponentType<T | void>;
+    /**
+     * Render prop (works like React router's <Route render={props =>} />)
+     */
+    render?: (props: T) => React.ReactNode;
+    /**
+     * Children render function <Field name>{props => ...}</Field>)
+     */
+    children?: (props: T) => React.ReactNode;
+}
+export type GenericFieldHTMLAttributes = JSX.IntrinsicElements['input'] | JSX.IntrinsicElements['select'] | JSX.IntrinsicElements['textarea'];
+/** Field metadata */
+export interface FieldMetaProps<Value> {
+    /** Value of the field */
+    value: Value;
+    /** Error message of the field */
+    error?: string;
+    /** Has the field been visited? */
+    touched: boolean;
+    /** Initial value of the field */
+    initialValue?: Value;
+    /** Initial touched state of the field */
+    initialTouched: boolean;
+    /** Initial error message of the field */
+    initialError?: string;
+}
+/** Imperative handles to change a field's value, error and touched */
+export interface FieldHelperProps<Value> {
+    /** Set the field's value */
+    setValue: (value: Value, shouldValidate?: boolean) => Promise<void | FormikErrors<Value>>;
+    /** Set the field's touched value */
+    setTouched: (value: boolean, shouldValidate?: boolean) => Promise<void | FormikErrors<Value>>;
+    /** Set the field's error value */
+    setError: (value: string | undefined) => void;
+}
+/** Field input value, name, and event handlers */
+export interface FieldInputProps<Value> {
+    /** Value of the field */
+    value: Value;
+    /** Name of the field */
+    name: string;
+    /** Multiple select? */
+    multiple?: boolean;
+    /** Is the field checked? */
+    checked?: boolean;
+    /** Change event handler */
+    onChange: FormikHandlers['handleChange'];
+    /** Blur event handler */
+    onBlur: FormikHandlers['handleBlur'];
+}
+export type FieldValidator = (value: any) => string | void | Promise<string | void>;

package/esm/form/types.js

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

package/esm/form/utils.d.ts

@@ -0,0 +1,68 @@
+import * as React from 'react';
+/** @private is the value an empty array? */
+export declare const isEmptyArray: (value?: any) => boolean;
+/** @private is the given object a Function? */
+export declare const isFunction: (obj: any) => obj is Function;
+/** @private is the given object an Object? */
+export declare const isObject: (obj: any) => obj is Object;
+/** @private is the given object an integer? */
+export declare const isInteger: (obj: any) => boolean;
+/** @private is the given object a string? */
+export declare const isString: (obj: any) => obj is string;
+/** @private is the given object a NaN? */
+export declare const isNaN: (obj: any) => boolean;
+/** @private Does a React component have exactly 0 children? */
+export declare const isEmptyChildren: (children: any) => boolean;
+/** @private is the given object/value a promise? */
+export declare const isPromise: (value: any) => value is PromiseLike<any>;
+/** @private is the given object/value a type of synthetic event? */
+export declare const isInputEvent: (value: any) => value is React.SyntheticEvent<any, Event>;
+/**
+ * Same as document.activeElement but wraps in a try-catch block. In IE it is
+ * not safe to call document.activeElement if there is nothing focused.
+ *
+ * The activeElement will be null only if the document or document body is not
+ * yet defined.
+ *
+ * @param {?Document} doc Defaults to current document.
+ * @return {Element | null}
+ * @see https://github.com/facebook/fbjs/blob/master/packages/fbjs/src/core/dom/getActiveElement.js
+ */
+export declare function getActiveElement(doc?: Document): Element | null;
+/**
+ * Deeply get a value from an object via its path.
+ */
+export declare function getIn(obj: any, key: string | string[], def?: any, p?: number): any;
+/**
+ * Deeply set a value from in object via it's path. If the value at `path`
+ * has changed, return a shallow copy of obj with `value` set at `path`.
+ * If `value` has not changed, return the original `obj`.
+ *
+ * Existing objects / arrays along `path` are also shallow copied. Sibling
+ * objects along path retain the same internal js reference. Since new
+ * objects / arrays are only created along `path`, we can test if anything
+ * changed in a nested structure by comparing the object's reference in
+ * the old and new object, similar to how russian doll cache invalidation
+ * works.
+ *
+ * In earlier versions of this function, which used cloneDeep, there were
+ * issues whereby settings a nested value would mutate the parent
+ * instead of creating a new object. `clone` avoids that bug making a
+ * shallow copy of the objects along the update path
+ * so no object is mutated in place.
+ *
+ * Before changing this function, please read through the following
+ * discussions.
+ *
+ * @see https://github.com/developit/linkstate
+ * @see https://github.com/jaredpalmer/formik/pull/123
+ */
+export declare function setIn(obj: any, path: string, value: any): any;
+/**
+ * Recursively a set the same value for all keys and arrays nested object, cloning
+ * @param object
+ * @param value
+ * @param visited
+ * @param response
+ */
+export declare function setNestedObjectValues<T>(object: any, value: any, visited?: any, response?: any): T;

package/esm/form/utils.js

@@ -0,0 +1,179 @@
+import _typeof from "@babel/runtime/helpers/esm/typeof";
+import clone from 'lodash/clone';
+import toPath from 'lodash/toPath';
+import * as React from 'react';
+
+// Assertions
+
+/** @private is the value an empty array? */
+export var isEmptyArray = function isEmptyArray(value) {
+  return Array.isArray(value) && value.length === 0;
+};
+
+/** @private is the given object a Function? */
+export var isFunction = function isFunction(obj) {
+  return typeof obj === 'function';
+};
+
+/** @private is the given object an Object? */
+export var isObject = function isObject(obj) {
+  return obj !== null && _typeof(obj) === 'object';
+};
+
+/** @private is the given object an integer? */
+export var isInteger = function isInteger(obj) {
+  return String(Math.floor(Number(obj))) === obj;
+};
+
+/** @private is the given object a string? */
+export var isString = function isString(obj) {
+  return Object.prototype.toString.call(obj) === '[object String]';
+};
+
+/** @private is the given object a NaN? */
+// eslint-disable-next-line no-self-compare
+export var isNaN = function isNaN(obj) {
+  return obj !== obj;
+};
+
+/** @private Does a React component have exactly 0 children? */
+export var isEmptyChildren = function isEmptyChildren(children) {
+  return React.Children.count(children) === 0;
+};
+
+/** @private is the given object/value a promise? */
+export var isPromise = function isPromise(value) {
+  return isObject(value) && isFunction(value.then);
+};
+
+/** @private is the given object/value a type of synthetic event? */
+export var isInputEvent = function isInputEvent(value) {
+  return value && isObject(value) && isObject(value.target);
+};
+
+/**
+ * Same as document.activeElement but wraps in a try-catch block. In IE it is
+ * not safe to call document.activeElement if there is nothing focused.
+ *
+ * The activeElement will be null only if the document or document body is not
+ * yet defined.
+ *
+ * @param {?Document} doc Defaults to current document.
+ * @return {Element | null}
+ * @see https://github.com/facebook/fbjs/blob/master/packages/fbjs/src/core/dom/getActiveElement.js
+ */
+export function getActiveElement(doc) {
+  doc = doc || (typeof document !== 'undefined' ? document : undefined);
+  if (typeof doc === 'undefined') {
+    return null;
+  }
+  try {
+    return doc.activeElement || doc.body;
+  } catch (e) {
+    return doc.body;
+  }
+}
+
+/**
+ * Deeply get a value from an object via its path.
+ */
+export function getIn(obj, key, def) {
+  var p = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;
+  var path = toPath(key);
+  while (obj && p < path.length) {
+    obj = obj[path[p++]];
+  }
+
+  // check if path is not in the end
+  if (p !== path.length && !obj) {
+    return def;
+  }
+  return obj === undefined ? def : obj;
+}
+
+/**
+ * Deeply set a value from in object via it's path. If the value at `path`
+ * has changed, return a shallow copy of obj with `value` set at `path`.
+ * If `value` has not changed, return the original `obj`.
+ *
+ * Existing objects / arrays along `path` are also shallow copied. Sibling
+ * objects along path retain the same internal js reference. Since new
+ * objects / arrays are only created along `path`, we can test if anything
+ * changed in a nested structure by comparing the object's reference in
+ * the old and new object, similar to how russian doll cache invalidation
+ * works.
+ *
+ * In earlier versions of this function, which used cloneDeep, there were
+ * issues whereby settings a nested value would mutate the parent
+ * instead of creating a new object. `clone` avoids that bug making a
+ * shallow copy of the objects along the update path
+ * so no object is mutated in place.
+ *
+ * Before changing this function, please read through the following
+ * discussions.
+ *
+ * @see https://github.com/developit/linkstate
+ * @see https://github.com/jaredpalmer/formik/pull/123
+ */
+export function setIn(obj, path, value) {
+  var res = clone(obj); // this keeps inheritance when obj is a class
+  var resVal = res;
+  var i = 0;
+  var pathArray = toPath(path);
+  for (; i < pathArray.length - 1; i++) {
+    var currentPath = pathArray[i];
+    var currentObj = getIn(obj, pathArray.slice(0, i + 1));
+    if (currentObj && (isObject(currentObj) || Array.isArray(currentObj))) {
+      resVal = resVal[currentPath] = clone(currentObj);
+    } else {
+      var nextPath = pathArray[i + 1];
+      resVal = resVal[currentPath] = isInteger(nextPath) && Number(nextPath) >= 0 ? [] : {};
+    }
+  }
+
+  // Return original object if new value is the same as current
+  if ((i === 0 ? obj : resVal)[pathArray[i]] === value) {
+    return obj;
+  }
+  if (value === undefined) {
+    delete resVal[pathArray[i]];
+  } else {
+    resVal[pathArray[i]] = value;
+  }
+
+  // If the path array has a single element, the loop did not run.
+  // Deleting on `resVal` had no effect in this scenario, so we delete on the result instead.
+  if (i === 0 && value === undefined) {
+    delete res[pathArray[i]];
+  }
+  return res;
+}
+
+/**
+ * Recursively a set the same value for all keys and arrays nested object, cloning
+ * @param object
+ * @param value
+ * @param visited
+ * @param response
+ */
+export function setNestedObjectValues(object, value) {
+  var visited = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : new WeakMap();
+  var response = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+  for (var _i = 0, _Object$keys = Object.keys(object); _i < _Object$keys.length; _i++) {
+    var k = _Object$keys[_i];
+    var val = object[k];
+    if (isObject(val)) {
+      if (!visited.get(val)) {
+        visited.set(val, true);
+        // In order to keep array values consistent for both dot path  and
+        // bracket syntax, we need to check if this is an array so that
+        // this will output  { friends: [true] } and not { friends: { "0": true } }
+        response[k] = Array.isArray(val) ? [] : {};
+        setNestedObjectValues(val, value, visited, response[k]);
+      }
+    } else {
+      response[k] = value;
+    }
+  }
+  return response;
+}

package/esm/form/withFormik.d.ts

@@ -0,0 +1,68 @@
+import * as React from 'react';
+import { FormikHelpers, FormikProps, FormikSharedConfig, FormikValues, FormikTouched, FormikErrors } from "./types";
+/**
+ * State, handlers, and helpers injected as props into the wrapped form component.
+ * Used with withFormik()
+ *
+ * @deprecated  Use `OuterProps & FormikProps<Values>` instead.
+ */
+export type InjectedFormikProps<Props, Values> = Props & FormikProps<Values>;
+/**
+ * Formik helpers + { props }
+ */
+export type FormikBag<P, V> = {
+    props: P;
+} & FormikHelpers<V>;
+/**
+ * withFormik() configuration options. Backwards compatible.
+ */
+export interface WithFormikConfig<Props, Values extends FormikValues = FormikValues, DeprecatedPayload = Values> extends FormikSharedConfig<Props> {
+    /**
+     * Set the display name of the component. Useful for React DevTools.
+     */
+    displayName?: string;
+    /**
+     * Submission handler
+     */
+    handleSubmit: (values: Values, formikBag: FormikBag<Props, Values>) => void;
+    /**
+     * Map props to the form values
+     */
+    mapPropsToValues?: (props: Props) => Values;
+    /**
+     * Map props to the form status
+     */
+    mapPropsToStatus?: (props: Props) => any;
+    /**
+     * Map props to the form touched state
+     */
+    mapPropsToTouched?: (props: Props) => FormikTouched<Values>;
+    /**
+     * Map props to the form errors state
+     */
+    mapPropsToErrors?: (props: Props) => FormikErrors<Values>;
+    /**
+     * @deprecated in 0.9.0 (but needed to break TS types)
+     */
+    mapValuesToPayload?: (values: Values) => DeprecatedPayload;
+    /**
+     * A Yup Schema or a function that returns a Yup schema
+     */
+    validationSchema?: any | ((props: Props) => any);
+    /**
+     * Validation function. Must return an error object or promise that
+     * throws an error object where that object keys map to corresponding value.
+     */
+    validate?: (values: Values, props: Props) => void | object | Promise<any>;
+}
+export type CompositeComponent<P> = React.ComponentClass<P> | React.FunctionComponent<P>;
+export interface ComponentDecorator<TOwnProps, TMergedProps> {
+    (component: CompositeComponent<TMergedProps>): React.ComponentType<TOwnProps>;
+}
+export interface InferableComponentDecorator<TOwnProps> {
+    <T extends CompositeComponent<TOwnProps>>(component: T): T;
+}
+/**
+ * A public higher-order component to access the imperative API
+ */
+export default function withFormik<OuterProps extends object, Values extends FormikValues, Payload = Values>({ mapPropsToValues, ...config }: WithFormikConfig<OuterProps, Values, Payload>): ComponentDecorator<OuterProps, OuterProps & FormikProps<Values>>;