envoc-form 3.2.0 → 4.0.1-1

package/es/FieldArray/FieldArray.js

@@ -0,0 +1,80 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import classNames from 'classnames';
+import Field from '../Field/Field';
+import { FieldNameContext } from '../Field/FieldNameContext';
+import useStandardFormInput from '../Field/useStandardField';
+export default function FieldArray(_a) {
+    var name = _a.name, label = _a.label, validate = _a.validate, disabled = _a.disabled, children = _a.children, rest = __rest(_a, ["name", "label", "validate", "disabled", "children"]);
+    var _b = useStandardFormInput({
+        name: String(name),
+        validate: validate,
+        disabled: disabled,
+    }), input = _b[0], meta = _b[1];
+    var values = !input.value
+        ? []
+        : Array.isArray(input.value)
+            ? input.value
+            : [];
+    return (_jsxs("div", __assign({ className: "field-array" }, { children: [_jsxs("div", __assign({ className: "field-array-header" }, { children: [_jsx("div", __assign({ className: "field-array-title" }, { children: label })), _jsx("button", __assign({ className: classNames('add-array-item-button', { disabled: disabled }), title: "Add Item", type: "button", onClick: addItem }, { children: "+" }))] })), _jsx("div", __assign({ className: "field-array-body" }, { children: values.map(function (value, index) {
+                    var itemName = "".concat(input.name, "[").concat(index, "]");
+                    return (_jsxs("div", __assign({ className: classNames('field-array-item', {
+                            removed: value.isDeleted,
+                        }), role: "listitem" }, { children: [_jsx(FieldNameContext.Provider, __assign({ value: itemName }, { children: children({
+                                    Field: Field,
+                                    FieldArray: FieldArray,
+                                }) })), _jsx("button", __assign({ className: classNames('remove-array-item-button', { disabled: disabled }), type: "button", title: "Remove Item", onClick: function () { return removeItem(value); } }, { children: "-" }))] }), (value && value['form-input-array-key']) ||
+                        (value && value['id']) ||
+                        itemName));
+                }) }))] })));
+    function addItem() {
+        if (disabled) {
+            return;
+        }
+        input.onChange(__spreadArray(__spreadArray([], values, true), [{}], false));
+    }
+    function removeItem(item) {
+        if (disabled) {
+            return;
+        }
+        // assumes anything from the server has an 'id' value sent
+        if (!item.id) {
+            input.onChange(values.filter(function (x) { return x !== item; }));
+            return;
+        }
+        var mapped = values.map(function (x) {
+            return x !== item ? x : Object.assign({}, x, { isDeleted: true });
+        });
+        input.onChange(mapped);
+    }
+}

package/es/File/FileGroup.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import { InjectedFieldProps } from '../Field/InjectedFieldProps';
+import { GroupProps } from '../Group';
+export interface FileGroupProps extends InjectedFieldProps<any | undefined>, Omit<GroupProps, keyof InjectedFieldProps<any> | 'children'>, Omit<React.HTMLProps<HTMLInputElement>, keyof InjectedFieldProps<any> | 'children' | 'className' | 'label'> {
+    multiple?: boolean | undefined;
+}
+declare const FileGroupWithRef: React.ComponentType<FileGroupProps>;
+export default FileGroupWithRef;

package/es/File/FileGroup.js

@@ -0,0 +1,50 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import React from 'react';
+import classNames from 'classnames';
+import FileList from './FileList';
+import Group from '../Group';
+function FileGroup(_a, ref) {
+    var input = _a.input, meta = _a.meta, label = _a.label, helpText = _a.helpText, className = _a.className, multiple = _a.multiple, rest = __rest(_a, ["input", "meta", "label", "helpText", "className", "multiple"]);
+    return (_jsxs(Group, __assign({ input: input, meta: meta, label: label, helpText: helpText, className: classNames(className, { multiple: multiple }, 'file-group') }, { children: [_jsx("input", __assign({}, input, rest, { multiple: multiple, onChange: function (e) {
+                    var _a, _b;
+                    if (!((_b = (_a = e === null || e === void 0 ? void 0 : e.target) === null || _a === void 0 ? void 0 : _a.files) === null || _b === void 0 ? void 0 : _b.length)) {
+                        input.onChange(undefined);
+                    }
+                    else {
+                        var files = [];
+                        for (var i = 0; i < e.target.files.length; i++) {
+                            files.push(e.target.files[i]);
+                        }
+                        if (!multiple) {
+                            input.onChange(files[0]);
+                        }
+                        else {
+                            input.onChange(files);
+                        }
+                    }
+                }, value: undefined, ref: ref, type: "file", className: classNames(className, 'file-group') })), _jsx(FileList, { files: input.value })] })));
+}
+var FileGroupWithRef = React.forwardRef(FileGroup);
+export default FileGroupWithRef;

package/es/File/FileList.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="react" />
+export interface FileListProps {
+    files?: File | File[] | undefined;
+    rejectedFiles?: File | File[] | undefined;
+}
+export default function FileList({ files, rejectedFiles }: FileListProps): JSX.Element;

package/es/File/FileList.js

@@ -0,0 +1,20 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+import { jsx as _jsx } from "react/jsx-runtime";
+export default function FileList(_a) {
+    var files = _a.files, rejectedFiles = _a.rejectedFiles;
+    return (_jsx("div", __assign({ className: "file-list" }, { children: !files ? null : Array.isArray(files) ? (files.map(function (x, i) { return _jsx(File, { file: x }, i); })) : (_jsx(File, { file: files })) })));
+}
+function File(_a) {
+    var file = _a.file;
+    return null;
+}

package/es/File/humanFileSize.d.ts

@@ -0,0 +1 @@
+export declare function humanFileSize(size: number): string;

package/es/File/humanFileSize.js

@@ -0,0 +1,6 @@
+export function humanFileSize(size) {
+    var i = Math.floor(Math.log(size) / Math.log(1024));
+    return ((size / Math.pow(1024, i)).toFixed(2) +
+        ' ' +
+        ['B', 'KB', 'MB', 'GB', 'TB'][i]);
+}

package/es/Form/FocusError.d.ts

@@ -0,0 +1,5 @@
+import { ServerErrorContextProps } from './ServerErrorContext';
+export interface FocusErrorProps {
+    serverErrors: ServerErrorContextProps;
+}
+export default function FocusError(props: FocusErrorProps): null;

package/es/Form/FocusError.js

@@ -1,53 +1,41 @@
-import { useEffect } from 'react';
-import { useFormikContext } from 'formik';
-import smoothscroll from 'smoothscroll-polyfill';
-export default function FocusError(props) {
-  var _useFormikContext = useFormikContext(),
-      errors = _useFormikContext.errors,
-      isSubmitting = _useFormikContext.isSubmitting,
-      isValidating = _useFormikContext.isValidating;
-
-  smoothscroll.polyfill();
-  useEffect(function () {
-    if (!isSubmitting || isValidating) {
-      return;
-    } //This block handles any front-end input validation errors
-    //e.g. required fields, max characters, etc
-
-
-    var keys = Object.keys(errors);
-
-    if (keys.length > 0) {
-      return scrollToErrorElement(keys);
-    } //This block handles any input-specific server-side errors
-    //e.g. improper email formatting, invalid phone number, etc.
-
-
-    if (props.serverErrors.errors && Object.values(props.serverErrors.errors).some(function (x) {
-      return !!x;
-    })) {
-      var names = Object.keys(props.serverErrors.errors);
-      return scrollToErrorElement(names);
-    }
-  }, [errors, isSubmitting, isValidating, props]);
-  return null;
-}
-
-var scrollToErrorElement = function scrollToErrorElement(keys) {
-  var firstErrorElement = document.getElementById("".concat(keys[0].toLowerCase(), "-error-scroll-target"));
-
-  if (firstErrorElement == null || firstErrorElement.parentNode == null) {
-    return;
-  }
-
-  firstErrorElement = firstErrorElement.parentNode;
-  var headerOffset = -110;
-  var y = firstErrorElement.getBoundingClientRect().top + window.pageYOffset + headerOffset;
-  window.scrollTo({
-    top: y,
-    behavior: 'smooth'
-  });
-  setTimeout(function () {
-    firstErrorElement.focus();
-  }, 500);
-};
+import { useEffect } from 'react';
+import { useFormikContext } from 'formik';
+import smoothscroll from 'smoothscroll-polyfill';
+export default function FocusError(props) {
+    var _a = useFormikContext(), errors = _a.errors, isSubmitting = _a.isSubmitting, isValidating = _a.isValidating;
+    smoothscroll.polyfill();
+    useEffect(function () {
+        if (!isSubmitting || isValidating) {
+            return;
+        }
+        //This block handles any front-end input validation errors
+        //e.g. required fields, max characters, etc
+        var keys = Object.keys(errors);
+        if (keys.length > 0) {
+            return scrollToErrorElement(keys);
+        }
+        //This block handles any input-specific server-side errors
+        //e.g. improper email formatting, invalid phone number, etc.
+        if (props.serverErrors.errors &&
+            Object.values(props.serverErrors.errors).some(function (x) { return !!x; })) {
+            var names = Object.keys(props.serverErrors.errors);
+            return scrollToErrorElement(names);
+        }
+    }, [errors, isSubmitting, isValidating, props]);
+    return null;
+}
+var scrollToErrorElement = function (keys) {
+    var firstErrorElement = document.getElementById("".concat(keys[0].toLowerCase(), "-error-scroll-target"));
+    if (!firstErrorElement || !firstErrorElement.parentNode) {
+        return;
+    }
+    firstErrorElement = firstErrorElement.parentNode;
+    var headerOffset = -110;
+    var y = firstErrorElement.getBoundingClientRect().top +
+        window.pageYOffset +
+        headerOffset;
+    window.scrollTo({ top: y, behavior: 'smooth' });
+    setTimeout(function () {
+        firstErrorElement === null || firstErrorElement === void 0 ? void 0 : firstErrorElement.focus();
+    }, 500);
+};

package/es/Form/Form.d.ts

@@ -0,0 +1,22 @@
+import { CSSProperties, ElementType } from 'react';
+import { FormikHelpers } from 'formik';
+import { FieldProps } from '../Field/Field';
+import { FieldArrayProps } from '../FieldArray/FieldArray';
+import { ValidatedApiResult } from '../Validation/ValidatedApiResult';
+export declare type FormBuilderProp<TForm extends object> = {
+    Field: <TProp extends keyof TForm, TRenderComponent extends ElementType>(props: FieldProps<TForm, TProp, TRenderComponent>) => JSX.Element;
+    FieldArray: <TProp extends keyof TForm>(props: FieldArrayProps<TForm, TProp>) => JSX.Element;
+};
+export interface FormProps<TForm extends object> {
+    children: (formBuilder: FormBuilderProp<TForm>) => JSX.Element;
+    onSubmit: (formValues: FormData | TForm, formikBag: FormikHelpers<TForm>) => Promise<ValidatedApiResult>;
+    className?: string;
+    style?: CSSProperties;
+    ignoreLostChanges?: boolean;
+    initialValues?: TForm;
+}
+declare function Form<TForm extends object>({ children, className, style, ignoreLostChanges, onSubmit, initialValues, ...props }: FormProps<TForm>): JSX.Element;
+declare namespace Form {
+    var DisplayFormState: () => JSX.Element;
+}
+export default Form;

package/es/Form/Form.js

@@ -1,125 +1,111 @@
-import _extends from "@babel/runtime/helpers/esm/extends";
-import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
-import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
-import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
-var _excluded = ["children", "className", "style", "ignoreLostChanges", "onSubmit", "initialValues"];
-import React, { useState, useMemo, useContext } from 'react';
-import PropTypes from 'prop-types';
-import FocusError from './FocusError';
-import { Formik, Form as FormikFormWrapper, useFormikContext } from 'formik';
-import FormBasedPreventNavigation from './FormBasedPreventNavigation';
-import ServerErrorContext from './ServerErrorContext';
-import { objectToFormData, objectContainsNonSerializableProperty } from '../utils';
-export default function Form(_ref) {
-  var children = _ref.children,
-      className = _ref.className,
-      style = _ref.style,
-      ignoreLostChanges = _ref.ignoreLostChanges,
-      onSubmit = _ref.onSubmit,
-      initialValues = _ref.initialValues,
-      props = _objectWithoutProperties(_ref, _excluded);
-
-  // formik resets all error on each blur (with our settings)
-  // this means that ALL errors from the server disappear when any one field is blurred
-  // So, we have to store server errors ourselves
-  // Since we only use useStandardFormInput, that means there is only one consumer
-  var _useState = useState(null),
-      _useState2 = _slicedToArray(_useState, 2),
-      serverErrors = _useState2[0],
-      setServerErrors = _useState2[1];
-
-  var serverErrorContextValue = useMemo(function () {
-    return {
-      errors: serverErrors,
-      getError: function getError(path) {
-        var lowered = path.toLowerCase();
-        return serverErrors && serverErrors[lowered];
-      },
-      setError: function setError(path, errorMessage) {
-        var lowered = path.toLowerCase();
-        setServerErrors(Object.assign({}, serverErrors, _defineProperty({}, lowered, !errorMessage ? undefined : errorMessage)));
-      }
-    };
-  }, [serverErrors]);
-  return /*#__PURE__*/React.createElement(Formik, _extends({
-    validateOnChange: false,
-    validateOnBlur: true,
-    validateOnMount: false,
-    initialValues: initialValues || {},
-    onSubmit: handleSubmit
-  }, props), /*#__PURE__*/React.createElement(ServerErrorContext.Provider, {
-    value: serverErrorContextValue
-  }, /*#__PURE__*/React.createElement(FormikFormWrapper, {
-    className: className,
-    style: style
-  }, /*#__PURE__*/React.createElement(FocusError, {
-    serverErrors: serverErrorContextValue
-  }), /*#__PURE__*/React.createElement(FormBasedPreventNavigation, {
-    ignoreLostChanges: ignoreLostChanges
-  }), typeof children === 'function' ? children(props) : children)));
-
-  function handleSubmit(values, formikBag) {
-    var formData = null;
-
-    if (objectContainsNonSerializableProperty(values)) {
-      formData = objectToFormData(values, {
-        indices: true,
-        dotNotation: true,
-        allowEmptyArrays: true,
-        noFileListBrackets: true
-      });
-    }
-
-    return Promise.resolve(onSubmit(formData || values)).then(function (response) {
-      return response;
-    })["catch"](function (err) {
-      //this is an http error
-      if (err && err.response && err.response.data && err.response.data.validationFailures) {
-        try {
-          var _serverErrors = err.response.data.validationFailures.map(function (error) {
-            return {
-              // case insensitive path
-              path: error.propertyName.toLowerCase(),
-              errorMessage: error.errorMessage
-            };
-          }).reduce(function (acc, value) {
-            // for simplicity, just keep it to one server error at a time per path
-            acc[value.path] = value.errorMessage;
-            return acc;
-          }, {});
-
-          setServerErrors(_serverErrors);
-        } catch (err) {
-          console.error('Failure to getErrorObject');
-          console.error(err);
-          throw err;
-        }
-      }
-
-      throw err;
-    });
-  }
-}
-Form.DisplayFormState = DisplayFormState;
-
-function DisplayFormState() {
-  var formState = useFormikContext();
-  var serverErrorContext = useContext(ServerErrorContext);
-  return /*#__PURE__*/React.createElement("div", {
-    style: {
-      margin: '1rem 0'
-    }
-  }, /*#__PURE__*/React.createElement("pre", {
-    style: {
-      background: '#f6f8fa',
-      fontSize: '.65rem',
-      padding: '.5rem'
-    }
-  }, serverErrorContext && serverErrorContext.errors && /*#__PURE__*/React.createElement("div", null, /*#__PURE__*/React.createElement("strong", null, "serverErrors = "), JSON.stringify(serverErrorContext.errors, null, 2)), /*#__PURE__*/React.createElement("strong", null, "formState = "), JSON.stringify(formState, null, 2)));
-}
-
-Form.propTypes = {
-  ignoreLostChanges: PropTypes.bool,
-  onSubmit: PropTypes.func.isRequired,
-  initialValues: PropTypes.object
-};
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useContext, useMemo, useState, } from 'react';
+import { Form as FormikFormWrapper, Formik, useFormikContext, } from 'formik';
+import FocusError from './FocusError';
+import FormBasedPreventNavigation from './FormBasedPreventNavigation';
+import { ServerErrorContext, } from './ServerErrorContext';
+import Field from '../Field/Field';
+import FieldArray from '../FieldArray/FieldArray';
+import objectContainsNonSerializableProperty from '../utils/objectContainsNonSerializableProperty';
+import objectToFormData from '../utils/objectToFormData';
+export default function Form(_a) {
+    var children = _a.children, className = _a.className, style = _a.style, ignoreLostChanges = _a.ignoreLostChanges, onSubmit = _a.onSubmit, initialValues = _a.initialValues, props = __rest(_a, ["children", "className", "style", "ignoreLostChanges", "onSubmit", "initialValues"]);
+    // formik resets all error on each blur (with our settings)
+    // this means that ALL errors from the server disappear when any one field is blurred
+    // So, we have to store server errors ourselves
+    // Since we only use useStandardFormInput, that means there is only one consumer
+    var _b = useState({}), serverErrors = _b[0], setServerErrors = _b[1];
+    var serverErrorContextValue = useMemo(function () { return ({
+        errors: serverErrors,
+        getError: function (path) {
+            var lowered = path.toLowerCase();
+            return serverErrors && serverErrors[lowered];
+        },
+        setError: function (path, errorMessage) {
+            var _a;
+            var lowered = path.toLowerCase();
+            setServerErrors(Object.assign({}, serverErrors, (_a = {},
+                _a[lowered] = !errorMessage ? undefined : errorMessage,
+                _a)));
+        },
+    }); }, [serverErrors]);
+    return (_jsx(Formik, __assign({ validateOnChange: false, validateOnBlur: true, validateOnMount: false, initialValues: initialValues || {}, onSubmit: handleSubmit }, props, { children: _jsx(ServerErrorContext.Provider, __assign({ value: serverErrorContextValue }, { children: _jsxs(FormikFormWrapper, __assign({ className: className, style: style }, { children: [_jsx(FocusError, { serverErrors: serverErrorContextValue }), _jsx(FormBasedPreventNavigation, { ignoreLostChanges: ignoreLostChanges }), children({
+                        // hack for ref forwarding
+                        Field: Field,
+                        FieldArray: FieldArray,
+                    })] })) })) })));
+    function handleSubmit(values, formikBag) {
+        var formData = undefined;
+        if (objectContainsNonSerializableProperty(values)) {
+            formData = objectToFormData(values, {
+                indices: true,
+                dotNotation: true,
+                allowEmptyArrays: true,
+                noFileListBrackets: true,
+            });
+        }
+        return onSubmit(formData !== null && formData !== void 0 ? formData : values, formikBag)
+            .then(function (response) {
+            return response;
+        })
+            .catch(function (err) {
+            //this is an http error
+            if (err &&
+                err.response &&
+                err.response.data &&
+                err.response.data.validationFailures) {
+                try {
+                    var serverErrors_1 = err.response.data.validationFailures.reduce(function (acc, value) {
+                        var _a;
+                        // for simplicity, just keep it to one server error at a time per path
+                        // don't care of the property name case changes
+                        var path = (_a = value.propertyName) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+                        if (!!path && !!value.errorMessage) {
+                            acc[path] = value.errorMessage;
+                        }
+                        return acc;
+                    }, {});
+                    setServerErrors(serverErrors_1);
+                }
+                catch (err) {
+                    console.error('Failure to getErrorObject');
+                    console.error(err);
+                    throw err;
+                }
+            }
+            throw err;
+        });
+    }
+}
+Form.DisplayFormState = DisplayFormState;
+function DisplayFormState() {
+    var formState = useFormikContext();
+    var serverErrorContext = useContext(ServerErrorContext);
+    return (_jsx("div", __assign({ style: { margin: '1rem 0' } }, { children: _jsxs("pre", __assign({ style: {
+                background: '#f6f8fa',
+                fontSize: '.65rem',
+                padding: '.5rem',
+            } }, { children: [serverErrorContext && serverErrorContext.errors && (_jsxs("div", { children: [_jsx("strong", { children: "serverErrors = " }), JSON.stringify(serverErrorContext.errors, null, 2)] })), _jsx("strong", { children: "formState = " }), JSON.stringify(formState, null, 2)] })) })));
+}

package/es/Form/FormBasedPreventNavigation.d.ts

@@ -0,0 +1,5 @@
+export interface FormBasedPreventNavigationProps {
+    ignoreLostChanges?: boolean;
+    promptMessage?: string;
+}
+export default function FormBasedPreventNavigation({ ignoreLostChanges, promptMessage, }: FormBasedPreventNavigationProps): null;