@paragrav/rhf-utils 0.0.19 → 0.0.21

package/dist/cjs/errors/getFlatFieldErrors.d.ts

@@ -14,3 +14,11 @@ export type FlatFieldErrors = Record<string, FieldError>;
  */
 declare const getFlatFieldErrors: (errors: FieldErrors) => FlatFieldErrors;
 export default getFlatFieldErrors;
+/**
+ * Regular expression to maybe match the end of a leaf node path.
+ *
+ * i.e., `name.type`, `address.street.message`
+ *
+ * iow: dot [?: non-capturing]("type" | "message")[\b word boundary][$ end of string]
+ */
+export declare const regexMaybeFieldErrorLeafNode: RegExp;

package/dist/cjs/errors/getFlatFieldErrors.js

@@ -3,6 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.regexMaybeFieldErrorLeafNode = void 0;
 const react_hook_form_1 = require("react-hook-form");
 const flattenFieldErrors_1 = __importDefault(require("./flattenFieldErrors"));
 /**
@@ -23,7 +24,7 @@ const getFlatFieldErrors = (errors) => {
     return Object.fromEntries(keys.reduce((entries, key) => {
         // look for leaf node, which would have required `type` prop (e.g., `name.type`, `address.street.type`)
         // remove `regexEndsWithType` suffix to get flat field path (e.g., `name`, `address.street`)
-        const path = key.replace(regexEndsWithType, '');
+        const path = key.replace(exports.regexMaybeFieldErrorLeafNode, '');
         // if nothing replaced, then it's not a leaf node
         if (path === key)
             return entries;
@@ -37,4 +38,12 @@ const getFlatFieldErrors = (errors) => {
     }, []));
 };
 exports.default = getFlatFieldErrors;
-const regexEndsWithType = /\.type$/;
+//
+/**
+ * Regular expression to maybe match the end of a leaf node path.
+ *
+ * i.e., `name.type`, `address.street.message`
+ *
+ * iow: dot [?: non-capturing]("type" | "message")[\b word boundary][$ end of string]
+ */
+exports.regexMaybeFieldErrorLeafNode = /\.(?:type|message)\b$/;

package/dist/cjs/errors/nonfield/FormNonFieldErrorMarker.d.ts

@@ -4,7 +4,7 @@ type Props = {
     path: string;
 };
 /**
- * Empty, hidden marker to indicate a non-field error is presented to user.
+ * Empty, hidden marker to indicate a non-field/non-root error is being displayed to user.
  */
 declare const FormNonFieldErrorMarker: React.FC<Props>;
 export default FormNonFieldErrorMarker;

package/dist/cjs/errors/nonfield/FormNonFieldErrorMarker.js

@@ -1,13 +1,16 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 const jsx_runtime_1 = require("react/jsx-runtime");
-const FormNonFieldErrorMarker_utils_1 = require("./FormNonFieldErrorMarker.utils");
+const FormNonFieldErrorMarker_utils_1 = __importDefault(require("./FormNonFieldErrorMarker.utils"));
 /**
- * Empty, hidden marker to indicate a non-field error is presented to user.
+ * Empty, hidden marker to indicate a non-field/non-root error is being displayed to user.
  */
 const FormNonFieldErrorMarker = ({ path }) => {
     const dataAttribute = {
-        [FormNonFieldErrorMarker_utils_1.FormNonFieldErrorMarkerHtmlAttribute]: path,
+        [FormNonFieldErrorMarker_utils_1.default]: path,
     };
     return ((0, jsx_runtime_1.jsx)("div", { role: "alert", "aria-hidden": "true" // hide from screen readers
         , style: { display: 'none' }, ...dataAttribute }));

package/dist/cjs/errors/nonfield/FormNonFieldErrorMarker.utils.d.ts

@@ -1,6 +1,7 @@
 /**
  * HTML data attribute for {@link FormNonFieldErrorMarker}.
  */
-export declare const FormNonFieldErrorMarkerHtmlAttribute = "data-paragrav-rhf-utils-nonfield-error-marker-path";
+declare const FormNonFieldErrorMarkerHtmlAttribute = "data-paragrav-rhf-utils-nonfield-error-marker-path";
+export default FormNonFieldErrorMarkerHtmlAttribute;
 export declare const getFormNonFieldErrorMarkerQuerySelector: (path: string) => string;
 export declare const hasNonFieldErrorMarkerInDOM: (path: string, parentElement: Pick<HTMLElement, 'querySelector'>) => Element | null;

package/dist/cjs/errors/nonfield/FormNonFieldErrorMarker.utils.js

@@ -1,11 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.hasNonFieldErrorMarkerInDOM = exports.getFormNonFieldErrorMarkerQuerySelector = exports.FormNonFieldErrorMarkerHtmlAttribute = void 0;
+exports.hasNonFieldErrorMarkerInDOM = exports.getFormNonFieldErrorMarkerQuerySelector = void 0;
 /**
  * HTML data attribute for {@link FormNonFieldErrorMarker}.
  */
-exports.FormNonFieldErrorMarkerHtmlAttribute = 'data-paragrav-rhf-utils-nonfield-error-marker-path';
-const getFormNonFieldErrorMarkerQuerySelector = (path) => `[role="alert"][${exports.FormNonFieldErrorMarkerHtmlAttribute}="${path}"]`;
+const FormNonFieldErrorMarkerHtmlAttribute = 'data-paragrav-rhf-utils-nonfield-error-marker-path';
+exports.default = FormNonFieldErrorMarkerHtmlAttribute;
+// utils
+const getFormNonFieldErrorMarkerQuerySelector = (path) => `[role="alert"][${FormNonFieldErrorMarkerHtmlAttribute}="${path}"]`;
 exports.getFormNonFieldErrorMarkerQuerySelector = getFormNonFieldErrorMarkerQuerySelector;
 const hasNonFieldErrorMarkerInDOM = (path, parentElement) => parentElement.querySelector((0, exports.getFormNonFieldErrorMarkerQuerySelector)(path));
 exports.hasNonFieldErrorMarkerInDOM = hasNonFieldErrorMarkerInDOM;

package/dist/cjs/errors/nonfield/utils.d.ts

@@ -12,6 +12,6 @@ import type { FieldError } from 'react-hook-form';
  *   - Orphan (undisplayed), which are typically caused by one of the following cases:
  *      - The input is missing.
  *      - The schema is incorrect.
- *      - The non-field error is not displayed to user with `FormErrorNonFieldMarker`.
+ *      - The error is not displayed to user with `FormErrorNonFieldMarker`.
  */
 export declare const isNonFieldError: (error: FieldError) => boolean;

package/dist/cjs/errors/nonfield/utils.js

@@ -14,7 +14,7 @@ exports.isNonFieldError = void 0;
  *   - Orphan (undisplayed), which are typically caused by one of the following cases:
  *      - The input is missing.
  *      - The schema is incorrect.
- *      - The non-field error is not displayed to user with `FormErrorNonFieldMarker`.
+ *      - The error is not displayed to user with `FormErrorNonFieldMarker`.
  */
 const isNonFieldError = (error) => !error.ref;
 exports.isNonFieldError = isNonFieldError;

package/dist/cjs/errors/orphan/useFormErrorsHasOnlyOrphans.d.ts

@@ -0,0 +1,2 @@
+declare const useFormErrorsHasOnlyOrphans: (formRef: React.RefObject<HTMLFormElement>) => boolean;
+export default useFormErrorsHasOnlyOrphans;

package/dist/cjs/errors/orphan/useFormErrorsHasOnlyOrphans.js

@@ -0,0 +1,19 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@/utils");
+const useFormFlatFieldErrors_1 = __importDefault(require("../useFormFlatFieldErrors"));
+const useOrphanFormErrors_1 = __importDefault(require("./useOrphanFormErrors"));
+const useFormErrorsHasOnlyOrphans = (formRef) => {
+    // get flat field errors of orphans and all errors
+    const orphans = (0, useOrphanFormErrors_1.default)(formRef);
+    const errors = (0, useFormFlatFieldErrors_1.default)();
+    // if either empty, early return
+    if ([orphans, errors].some(utils_1.isEmptyObject))
+        return false;
+    // equal length
+    return Object.keys(orphans).length === Object.keys(errors).length;
+};
+exports.default = useFormErrorsHasOnlyOrphans;

package/dist/cjs/errors/{orphans/useFormOrphanErrors.d.ts → orphan/useOrphanFormErrors.d.ts}

@@ -1,3 +1,3 @@
 import React from 'react';
-declare const useFormOrphanErrors: (formRef: React.RefObject<HTMLFormElement>) => import("@/errors/getFlatFieldErrors").FlatFieldErrors;
-export default useFormOrphanErrors;
+declare const useOrphanFormErrors: (formRef: React.RefObject<HTMLFormElement>) => import("@/errors/getFlatFieldErrors").FlatFieldErrors;
+export default useOrphanFormErrors;

package/dist/cjs/errors/{orphans/useFormOrphanErrors.js → orphan/useOrphanFormErrors.js}

@@ -6,14 +6,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const utils_1 = require("@/utils");
 const useFormErrorsOnChange_1 = __importDefault(require("../useFormErrorsOnChange"));
 const utils_2 = require("./utils");
-const useFormOrphanErrors = (formRef) => (0, useFormErrorsOnChange_1.default)((errors) => {
+const useOrphanFormErrors = (formRef) => (0, useFormErrorsOnChange_1.default)((errors) => {
     // if no errors, return early
     if ((0, utils_1.isEmptyObject)(errors))
         return {};
-    if (!formRef.current) {
-        console.error(errors);
-        throw new Error('This should not happen.');
-    }
-    return (0, utils_2.getRootFlatFieldErrors)(errors, formRef.current);
+    // this should never happen
+    if (!formRef.current)
+        throw new Error();
+    return (0, utils_2.getOrphanFlatFieldErrors)(errors, formRef.current);
 });
-exports.default = useFormOrphanErrors;
+exports.default = useOrphanFormErrors;

package/dist/cjs/errors/orphan/useOrphanFormErrorsToConsoleError.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+/**
+ * Outputs orphan errors to `console.error` all errors with `ref: undefined` that do not begin with `root(.*)`.
+ * Sentry (or equivalent) should capture.
+ */
+declare const useOrphanFormErrorsToConsoleError: (formRef: React.RefObject<HTMLFormElement>) => void;
+export default useOrphanFormErrorsToConsoleError;

package/dist/cjs/errors/{orphans/useFormErrorOrphansToConsoleError.js → orphan/useOrphanFormErrorsToConsoleError.js}

@@ -5,25 +5,23 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const react_1 = __importDefault(require("react"));
 const react_hook_form_1 = require("react-hook-form");
-const useFormOrphanErrors_1 = __importDefault(require("./useFormOrphanErrors"));
+const useOrphanFormErrors_1 = __importDefault(require("./useOrphanFormErrors"));
 /**
- * Orphans are field errors that do not have a ref.
- * (Most commonly `root(.*)`, but these are filtered out. They are handled by `useFormRootFieldErrors`.)
- * Outputs to `console.error` all errors with `ref: undefined` that do not begin with `root(.*)`.
+ * Outputs orphan errors to `console.error` all errors with `ref: undefined` that do not begin with `root(.*)`.
  * Sentry (or equivalent) should capture.
  */
-const useFormErrorOrphansToConsoleError = (formRef) => {
+const useOrphanFormErrorsToConsoleError = (formRef) => {
     const { getValues } = (0, react_hook_form_1.useFormContext)();
     const { errors } = (0, react_hook_form_1.useFormState)();
-    const orphans = (0, useFormOrphanErrors_1.default)(formRef);
+    const orphans = (0, useOrphanFormErrors_1.default)(formRef);
     react_1.default.useEffect(() => {
         if (!Object.keys(orphans).length)
             return;
-        console.error('useFormErrorOrphansToConsoleError', {
+        console.error('useOrphanFormErrorsToConsoleError', {
             location: window.location,
             values: getValues(),
             orphans,
         });
     }, [errors, getValues, orphans]);
 };
-exports.default = useFormErrorOrphansToConsoleError;
+exports.default = useOrphanFormErrorsToConsoleError;

package/dist/cjs/errors/orphan/utils.d.ts

@@ -0,0 +1,3 @@
+import type { FieldErrors } from 'react-hook-form';
+import type { FlatFieldErrors } from '../getFlatFieldErrors';
+export declare const getOrphanFlatFieldErrors: (errors: FieldErrors, parentElement: Pick<HTMLElement, 'querySelector'>) => FlatFieldErrors;

package/dist/cjs/errors/{orphans → orphan}/utils.js

@@ -3,12 +3,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getRootFlatFieldErrors = void 0;
+exports.getOrphanFlatFieldErrors = void 0;
 const getFlatFieldErrors_1 = __importDefault(require("../getFlatFieldErrors"));
 const FormNonFieldErrorMarker_utils_1 = require("../nonfield/FormNonFieldErrorMarker.utils");
 const utils_1 = require("../nonfield/utils");
 const utils_2 = require("../root/utils");
-const getRootFlatFieldErrors = (errors, parentElement) => {
+const getOrphanFlatFieldErrors = (errors, parentElement) => {
     const flatFieldErrors = (0, getFlatFieldErrors_1.default)(errors);
     return Object.fromEntries(Object.entries(flatFieldErrors).filter(([path, error]) => 
     // not root path
@@ -18,4 +18,4 @@ const getRootFlatFieldErrors = (errors, parentElement) => {
         // does not have marker
         !(0, FormNonFieldErrorMarker_utils_1.hasNonFieldErrorMarkerInDOM)(path, parentElement)));
 };
-exports.getRootFlatFieldErrors = getRootFlatFieldErrors;
+exports.getOrphanFlatFieldErrors = getOrphanFlatFieldErrors;

package/dist/cjs/errors/root/{useFormRootFieldErrors.d.ts → useRootFormFieldErrors.d.ts}

@@ -2,5 +2,5 @@
  * Root field errors from form.
  * These are typically displayed at the bottom of the form.
  */
-declare const useFormRootFieldErrors: () => import("@/errors/getFlatFieldErrors").FlatFieldErrors;
-export default useFormRootFieldErrors;
+declare const useRootFormFieldErrors: () => import("@/errors/getFlatFieldErrors").FlatFieldErrors;
+export default useRootFormFieldErrors;

package/dist/cjs/errors/root/{useFormRootFieldErrors.js → useRootFormFieldErrors.js}

@@ -9,5 +9,5 @@ const utils_1 = require("./utils");
  * Root field errors from form.
  * These are typically displayed at the bottom of the form.
  */
-const useFormRootFieldErrors = () => (0, useFormErrorsOnChange_1.default)(utils_1.getRootFlatFieldErrors);
-exports.default = useFormRootFieldErrors;
+const useRootFormFieldErrors = () => (0, useFormErrorsOnChange_1.default)(utils_1.getRootFlatFieldErrors);
+exports.default = useRootFormFieldErrors;

package/dist/cjs/errors/useFormErrorConsoleDebug.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const useFormContextErrorsIfAny_1 = __importDefault(require("./useFormContextErrorsIfAny"));
+const useFormErrorsIfAny_1 = __importDefault(require("./useFormErrorsIfAny"));
 /**
  * Output form errors to console.debug() for easier debugging for certain condition.
  * (e.g., in dev/staging environments or certain users)
@@ -11,7 +11,7 @@ const useFormContextErrorsIfAny_1 = __importDefault(require("./useFormContextErr
  * `console.debug()` is unlikely to trigger any automated console capture reporting.
  */
 const useFormErrorConsoleDebug = (condition) => {
-    const errors = (0, useFormContextErrorsIfAny_1.default)();
+    const errors = (0, useFormErrorsIfAny_1.default)();
     if (!condition)
         return;
     if (!errors)

package/dist/cjs/errors/useFormErrorsIfAny.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Returns errors only if there are errors.
+ * Allows simple typeguard without `isEmpty` dependency.
+ */
+declare const useFormErrorsIfAny: () => false | import("react-hook-form").FieldErrors<import("react-hook-form").FieldValues>;
+export default useFormErrorsIfAny;

package/dist/cjs/errors/{useFormContextErrorsIfAny.js → useFormErrorsIfAny.js}

@@ -6,8 +6,8 @@ const utils_1 = require("@/utils");
  * Returns errors only if there are errors.
  * Allows simple typeguard without `isEmpty` dependency.
  */
-const useFormContextErrorsIfAny = () => {
+const useFormErrorsIfAny = () => {
     const { errors } = (0, react_hook_form_1.useFormState)();
     return (0, utils_1.isEmptyObject)(errors) ? false : errors;
 };
-exports.default = useFormContextErrorsIfAny;
+exports.default = useFormErrorsIfAny;

package/dist/cjs/errors/useFormFlatFieldErrors.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Use {@link FieldErrors} as {@link FlatFieldErrors}.
+ */
+declare const useFormFlatFieldErrors: () => import("./getFlatFieldErrors").FlatFieldErrors;
+export default useFormFlatFieldErrors;

package/dist/cjs/errors/useFormFlatFieldErrors.js

@@ -0,0 +1,12 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const getFlatFieldErrors_1 = __importDefault(require("./getFlatFieldErrors"));
+const useFormErrorsOnChange_1 = __importDefault(require("./useFormErrorsOnChange"));
+/**
+ * Use {@link FieldErrors} as {@link FlatFieldErrors}.
+ */
+const useFormFlatFieldErrors = () => (0, useFormErrorsOnChange_1.default)(getFlatFieldErrors_1.default);
+exports.default = useFormFlatFieldErrors;

package/dist/cjs/main.d.ts

@@ -1,9 +1,14 @@
 export { default as FormNonFieldErrorMarker } from './errors/nonfield/FormNonFieldErrorMarker';
-export { FormNonFieldErrorMarkerHtmlAttribute } from './errors/nonfield/FormNonFieldErrorMarker.utils';
-export { default as useFormErrorOrphansToConsoleError } from './errors/orphans/useFormErrorOrphansToConsoleError';
-export { default as useFormOrphanErrors } from './errors/orphans/useFormOrphanErrors';
-export { default as useFormRootFieldErrors } from './errors/root/useFormRootFieldErrors';
+export { default as FormNonFieldErrorMarkerHtmlAttribute } from './errors/nonfield/FormNonFieldErrorMarker.utils';
+export { default as useFormErrorsHasOnlyOrphans } from './errors/orphan/useFormErrorsHasOnlyOrphans';
+export { default as useOrphanFormErrors } from './errors/orphan/useOrphanFormErrors';
+export { default as useOrphanFormErrorsToConsoleError } from './errors/orphan/useOrphanFormErrorsToConsoleError';
+export { default as useRootFormFieldErrors } from './errors/root/useRootFormFieldErrors';
 export { default as useFormErrorConsoleDebug } from './errors/useFormErrorConsoleDebug';
 export { default as useFormErrorsEffect } from './errors/useFormErrorsEffect';
+export { default as useFormErrorsIfAny } from './errors/useFormErrorsIfAny';
 export { default as useFormErrorsOnChange } from './errors/useFormErrorsOnChange';
 export { default as useFormRequestSubmit } from './errors/useFormRequestSubmit';
+export { default as useFormOnSubmitSuccessful } from './submit/useFormOnSubmitSuccessful';
+export { default as useFormOnSubmitSuccessfulAndReset } from './submit/useFormOnSubmitSuccessfulAndReset';
+export { default as useResetFormAfterSubmitSuccessful } from './submit/useResetFormOnSubmitSuccessful';

package/dist/cjs/main.js

@@ -3,22 +3,32 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.useFormRequestSubmit = exports.useFormErrorsOnChange = exports.useFormErrorsEffect = exports.useFormErrorConsoleDebug = exports.useFormRootFieldErrors = exports.useFormOrphanErrors = exports.useFormErrorOrphansToConsoleError = exports.FormNonFieldErrorMarkerHtmlAttribute = exports.FormNonFieldErrorMarker = void 0;
+exports.useResetFormAfterSubmitSuccessful = exports.useFormOnSubmitSuccessfulAndReset = exports.useFormOnSubmitSuccessful = exports.useFormRequestSubmit = exports.useFormErrorsOnChange = exports.useFormErrorsIfAny = exports.useFormErrorsEffect = exports.useFormErrorConsoleDebug = exports.useRootFormFieldErrors = exports.useOrphanFormErrorsToConsoleError = exports.useOrphanFormErrors = exports.useFormErrorsHasOnlyOrphans = exports.FormNonFieldErrorMarkerHtmlAttribute = exports.FormNonFieldErrorMarker = void 0;
 var FormNonFieldErrorMarker_1 = require("./errors/nonfield/FormNonFieldErrorMarker");
 Object.defineProperty(exports, "FormNonFieldErrorMarker", { enumerable: true, get: function () { return __importDefault(FormNonFieldErrorMarker_1).default; } });
 var FormNonFieldErrorMarker_utils_1 = require("./errors/nonfield/FormNonFieldErrorMarker.utils");
-Object.defineProperty(exports, "FormNonFieldErrorMarkerHtmlAttribute", { enumerable: true, get: function () { return FormNonFieldErrorMarker_utils_1.FormNonFieldErrorMarkerHtmlAttribute; } });
-var useFormErrorOrphansToConsoleError_1 = require("./errors/orphans/useFormErrorOrphansToConsoleError");
-Object.defineProperty(exports, "useFormErrorOrphansToConsoleError", { enumerable: true, get: function () { return __importDefault(useFormErrorOrphansToConsoleError_1).default; } });
-var useFormOrphanErrors_1 = require("./errors/orphans/useFormOrphanErrors");
-Object.defineProperty(exports, "useFormOrphanErrors", { enumerable: true, get: function () { return __importDefault(useFormOrphanErrors_1).default; } });
-var useFormRootFieldErrors_1 = require("./errors/root/useFormRootFieldErrors");
-Object.defineProperty(exports, "useFormRootFieldErrors", { enumerable: true, get: function () { return __importDefault(useFormRootFieldErrors_1).default; } });
+Object.defineProperty(exports, "FormNonFieldErrorMarkerHtmlAttribute", { enumerable: true, get: function () { return __importDefault(FormNonFieldErrorMarker_utils_1).default; } });
+var useFormErrorsHasOnlyOrphans_1 = require("./errors/orphan/useFormErrorsHasOnlyOrphans");
+Object.defineProperty(exports, "useFormErrorsHasOnlyOrphans", { enumerable: true, get: function () { return __importDefault(useFormErrorsHasOnlyOrphans_1).default; } });
+var useOrphanFormErrors_1 = require("./errors/orphan/useOrphanFormErrors");
+Object.defineProperty(exports, "useOrphanFormErrors", { enumerable: true, get: function () { return __importDefault(useOrphanFormErrors_1).default; } });
+var useOrphanFormErrorsToConsoleError_1 = require("./errors/orphan/useOrphanFormErrorsToConsoleError");
+Object.defineProperty(exports, "useOrphanFormErrorsToConsoleError", { enumerable: true, get: function () { return __importDefault(useOrphanFormErrorsToConsoleError_1).default; } });
+var useRootFormFieldErrors_1 = require("./errors/root/useRootFormFieldErrors");
+Object.defineProperty(exports, "useRootFormFieldErrors", { enumerable: true, get: function () { return __importDefault(useRootFormFieldErrors_1).default; } });
 var useFormErrorConsoleDebug_1 = require("./errors/useFormErrorConsoleDebug");
 Object.defineProperty(exports, "useFormErrorConsoleDebug", { enumerable: true, get: function () { return __importDefault(useFormErrorConsoleDebug_1).default; } });
 var useFormErrorsEffect_1 = require("./errors/useFormErrorsEffect");
 Object.defineProperty(exports, "useFormErrorsEffect", { enumerable: true, get: function () { return __importDefault(useFormErrorsEffect_1).default; } });
+var useFormErrorsIfAny_1 = require("./errors/useFormErrorsIfAny");
+Object.defineProperty(exports, "useFormErrorsIfAny", { enumerable: true, get: function () { return __importDefault(useFormErrorsIfAny_1).default; } });
 var useFormErrorsOnChange_1 = require("./errors/useFormErrorsOnChange");
 Object.defineProperty(exports, "useFormErrorsOnChange", { enumerable: true, get: function () { return __importDefault(useFormErrorsOnChange_1).default; } });
 var useFormRequestSubmit_1 = require("./errors/useFormRequestSubmit");
 Object.defineProperty(exports, "useFormRequestSubmit", { enumerable: true, get: function () { return __importDefault(useFormRequestSubmit_1).default; } });
+var useFormOnSubmitSuccessful_1 = require("./submit/useFormOnSubmitSuccessful");
+Object.defineProperty(exports, "useFormOnSubmitSuccessful", { enumerable: true, get: function () { return __importDefault(useFormOnSubmitSuccessful_1).default; } });
+var useFormOnSubmitSuccessfulAndReset_1 = require("./submit/useFormOnSubmitSuccessfulAndReset");
+Object.defineProperty(exports, "useFormOnSubmitSuccessfulAndReset", { enumerable: true, get: function () { return __importDefault(useFormOnSubmitSuccessfulAndReset_1).default; } });
+var useResetFormOnSubmitSuccessful_1 = require("./submit/useResetFormOnSubmitSuccessful");
+Object.defineProperty(exports, "useResetFormAfterSubmitSuccessful", { enumerable: true, get: function () { return __importDefault(useResetFormOnSubmitSuccessful_1).default; } });

package/dist/cjs/submit/useFormOnSubmitSuccessful.d.ts

@@ -0,0 +1,2 @@
+declare const useFormOnSubmitSuccessful: (callback?: () => void) => void;
+export default useFormOnSubmitSuccessful;

package/dist/cjs/submit/useFormOnSubmitSuccessful.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = __importDefault(require("react"));
+const react_hook_form_1 = require("react-hook-form");
+const useFormOnSubmitSuccessful = (callback) => {
+    const { isSubmitSuccessful } = (0, react_hook_form_1.useFormState)();
+    react_1.default.useEffect(() => {
+        if (!callback)
+            return;
+        if (isSubmitSuccessful)
+            callback();
+    }, [callback, isSubmitSuccessful]);
+};
+exports.default = useFormOnSubmitSuccessful;

package/dist/cjs/submit/useFormOnSubmitSuccessfulAndReset.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Calls a callback after a successful submit and after a form reset.
+ *
+ * Using RHF and following its rules, we are not able to get the state `isSubmitSuccessful=true` and `isDirty=false`.
+ * So, this has to keep track of previous state.
+ *
+ * SubmitSuccessfulAndReset = was `isSubmitSuccessful` and now `!isSubmitSuccessful && !isDirty`
+ */
+declare const useFormOnSubmitSuccessfulAndReset: (callback?: () => void) => void;
+export default useFormOnSubmitSuccessfulAndReset;

package/dist/cjs/submit/useFormOnSubmitSuccessfulAndReset.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = __importDefault(require("react"));
+const react_hook_form_1 = require("react-hook-form");
+const useFormOnSubmitSuccessful_1 = __importDefault(require("./useFormOnSubmitSuccessful"));
+/**
+ * Calls a callback after a successful submit and after a form reset.
+ *
+ * Using RHF and following its rules, we are not able to get the state `isSubmitSuccessful=true` and `isDirty=false`.
+ * So, this has to keep track of previous state.
+ *
+ * SubmitSuccessfulAndReset = was `isSubmitSuccessful` and now `!isSubmitSuccessful && !isDirty`
+ */
+const useFormOnSubmitSuccessfulAndReset = (callback) => {
+    const { isSubmitSuccessful, isDirty } = (0, react_hook_form_1.useFormState)();
+    /** Tracks whether form has been successfully submitted. (Ref as it should not trigger re-render.) */
+    const wasSubmittedSuccessfully = react_1.default.useRef(false);
+    // mark as submitted successfully
+    (0, useFormOnSubmitSuccessful_1.default)(() => {
+        wasSubmittedSuccessfully.current = true;
+    });
+    react_1.default.useEffect(() => {
+        if (!callback)
+            return;
+        // if hasn't been submitted successfully (to distinguish from initial load)
+        if (!wasSubmittedSuccessfully.current)
+            return;
+        // after resetting (and on initial load), both state vars are `false`
+        if (!isSubmitSuccessful && !isDirty) {
+            callback();
+            // reset ref
+            wasSubmittedSuccessfully.current = false;
+        }
+    }, [isSubmitSuccessful, isDirty]); // eslint-disable-line react-hooks/exhaustive-deps
+};
+exports.default = useFormOnSubmitSuccessfulAndReset;

package/dist/cjs/submit/useResetFormOnSubmitSuccessful.d.ts

@@ -0,0 +1,11 @@
+import type { KeepStateOptions } from 'react-hook-form';
+type Options = {
+    enabled?: boolean;
+} & KeepStateOptions;
+/**
+ * Handle resetting after successful submit with no server validation errors.
+ * See `Rules` section: https://react-hook-form.com/api/useform/reset/
+ * Specifically: "- It's recommended to reset inside useEffect after submission."
+ */
+declare const useResetFormAfterSubmitSuccessful: (options?: Options) => void;
+export default useResetFormAfterSubmitSuccessful;

package/dist/cjs/submit/useResetFormOnSubmitSuccessful.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_hook_form_1 = require("react-hook-form");
+const useFormOnSubmitSuccessful_1 = __importDefault(require("./useFormOnSubmitSuccessful"));
+/**
+ * Handle resetting after successful submit with no server validation errors.
+ * See `Rules` section: https://react-hook-form.com/api/useform/reset/
+ * Specifically: "- It's recommended to reset inside useEffect after submission."
+ */
+const useResetFormAfterSubmitSuccessful = (options) => {
+    const { reset } = (0, react_hook_form_1.useFormContext)();
+    (0, useFormOnSubmitSuccessful_1.default)(() => {
+        if (!(options === null || options === void 0 ? void 0 : options.enabled))
+            return;
+        reset(undefined, options);
+    });
+};
+exports.default = useResetFormAfterSubmitSuccessful;

package/dist/esm/errors/getFlatFieldErrors.mjs

@@ -1,21 +1,22 @@
-import { get as f } from "react-hook-form";
-import d from "./flattenFieldErrors.mjs";
-const i = (e) => {
-  const c = d(e), s = Object.keys(c);
+import { get as l } from "react-hook-form";
+import n from "./flattenFieldErrors.mjs";
+const d = (t) => {
+  const a = n(t), c = Object.keys(a);
   return Object.fromEntries(
-    s.reduce(
-      (t, o) => {
-        const r = o.replace(l, "");
-        if (r === o)
-          return t;
-        const n = f(e, r, void 0);
-        return n && t.push([r, n]), t;
+    c.reduce(
+      (r, o) => {
+        const e = o.replace(f, "");
+        if (e === o)
+          return r;
+        const s = l(t, e, void 0);
+        return s && r.push([e, s]), r;
       },
       []
       // entries
     )
   );
-}, l = /\.type$/;
+}, u = d, f = /\.(?:type|message)\b$/;
 export {
-  i as default
+  u as default,
+  f as regexMaybeFieldErrorLeafNode
 };

package/dist/esm/errors/nonfield/FormNonFieldErrorMarker.mjs

@@ -1,5 +1,5 @@
 import { jsx as t } from "react/jsx-runtime";
-import { FormNonFieldErrorMarkerHtmlAttribute as e } from "./FormNonFieldErrorMarker.utils.mjs";
+import e from "./FormNonFieldErrorMarker.utils.mjs";
 const a = ({ path: r }) => {
   const o = {
     [e]: r

package/dist/esm/errors/nonfield/FormNonFieldErrorMarker.utils.mjs

@@ -1,6 +1,6 @@
-const o = "data-paragrav-rhf-utils-nonfield-error-marker-path", t = (r) => `[role="alert"][${o}="${r}"]`, a = (r, e) => e.querySelector(t(r));
+const e = "data-paragrav-rhf-utils-nonfield-error-marker-path", a = e, t = (r) => `[role="alert"][${e}="${r}"]`, l = (r, o) => o.querySelector(t(r));
 export {
-  o as FormNonFieldErrorMarkerHtmlAttribute,
+  a as default,
   t as getFormNonFieldErrorMarkerQuerySelector,
-  a as hasNonFieldErrorMarkerInDOM
+  l as hasNonFieldErrorMarkerInDOM
 };

package/dist/esm/errors/orphan/useFormErrorsHasOnlyOrphans.mjs

@@ -0,0 +1,10 @@
+import { isEmptyObject as e } from "../../utils.mjs";
+import t from "../useFormFlatFieldErrors.mjs";
+import n from "./useOrphanFormErrors.mjs";
+const m = (o) => {
+  const r = n(o), s = t();
+  return [r, s].some(e) ? !1 : Object.keys(r).length === Object.keys(s).length;
+}, O = m;
+export {
+  O as default
+};

package/dist/esm/errors/orphan/useOrphanFormErrors.mjs

@@ -0,0 +1,14 @@
+import "react";
+import { isEmptyObject as t } from "../../utils.mjs";
+import e from "../useFormErrorsOnChange.mjs";
+import { getOrphanFlatFieldErrors as n } from "./utils.mjs";
+const m = (r) => e((o) => {
+  if (t(o))
+    return {};
+  if (!r.current)
+    throw new Error();
+  return n(o, r.current);
+}), a = m;
+export {
+  a as default
+};

package/dist/esm/errors/{orphans/useFormErrorOrphansToConsoleError.mjs → orphan/useOrphanFormErrorsToConsoleError.mjs}

@@ -1,10 +1,10 @@
 import t from "react";
 import { useFormContext as n, useFormState as a } from "react-hook-form";
-import m from "./useFormOrphanErrors.mjs";
+import m from "./useOrphanFormErrors.mjs";
 const c = (e) => {
   const { getValues: o } = n(), { errors: s } = a(), r = m(e);
   t.useEffect(() => {
-    Object.keys(r).length && console.error("useFormErrorOrphansToConsoleError", {
+    Object.keys(r).length && console.error("useOrphanFormErrorsToConsoleError", {
       location: window.location,
       values: o(),
       orphans: r

package/dist/esm/errors/{orphans → orphan}/utils.mjs

@@ -16,5 +16,5 @@ const d = (o, t) => {
   );
 };
 export {
-  d as getRootFlatFieldErrors
+  d as getOrphanFlatFieldErrors
 };

package/dist/esm/errors/useFormErrorConsoleDebug.mjs

@@ -1,8 +1,8 @@
-import e from "./useFormContextErrorsIfAny.mjs";
+import e from "./useFormErrorsIfAny.mjs";
 const s = (o) => {
   const r = e();
   o && r && console.debug("useFormErrorConsoleDebug", r);
-}, u = s;
+}, n = s;
 export {
-  u as default
+  n as default
 };

package/dist/esm/errors/useFormErrorsIfAny.mjs

@@ -0,0 +1,9 @@
+import { useFormState as o } from "react-hook-form";
+import { isEmptyObject as s } from "../utils.mjs";
+const t = () => {
+  const { errors: r } = o();
+  return s(r) ? !1 : r;
+}, f = t;
+export {
+  f as default
+};

package/dist/esm/errors/useFormFlatFieldErrors.mjs

@@ -0,0 +1,6 @@
+import r from "./getFlatFieldErrors.mjs";
+import o from "./useFormErrorsOnChange.mjs";
+const s = () => o(r);
+export {
+  s as default
+};

package/dist/esm/main.mjs

@@ -1,20 +1,30 @@
 import { default as e } from "./errors/nonfield/FormNonFieldErrorMarker.mjs";
-import { FormNonFieldErrorMarkerHtmlAttribute as s } from "./errors/nonfield/FormNonFieldErrorMarker.utils.mjs";
-import { default as m } from "./errors/orphans/useFormErrorOrphansToConsoleError.mjs";
-import { default as u } from "./errors/orphans/useFormOrphanErrors.mjs";
-import { default as F } from "./errors/root/useFormRootFieldErrors.mjs";
-import { default as p } from "./errors/useFormErrorConsoleDebug.mjs";
-import { default as x } from "./errors/useFormErrorsEffect.mjs";
-import { default as i } from "./errors/useFormErrorsOnChange.mjs";
-import { default as h } from "./errors/useFormRequestSubmit.mjs";
+import { default as t } from "./errors/nonfield/FormNonFieldErrorMarker.utils.mjs";
+import { default as a } from "./errors/orphan/useFormErrorsHasOnlyOrphans.mjs";
+import { default as m } from "./errors/orphan/useOrphanFormErrors.mjs";
+import { default as d } from "./errors/orphan/useOrphanFormErrorsToConsoleError.mjs";
+import { default as F } from "./errors/root/useRootFormFieldErrors.mjs";
+import { default as x } from "./errors/useFormErrorConsoleDebug.mjs";
+import { default as i } from "./errors/useFormErrorsEffect.mjs";
+import { default as O } from "./errors/useFormErrorsIfAny.mjs";
+import { default as b } from "./errors/useFormErrorsOnChange.mjs";
+import { default as A } from "./errors/useFormRequestSubmit.mjs";
+import { default as C } from "./submit/useFormOnSubmitSuccessful.mjs";
+import { default as k } from "./submit/useFormOnSubmitSuccessfulAndReset.mjs";
+import { default as H } from "./submit/useResetFormOnSubmitSuccessful.mjs";
 export {
   e as FormNonFieldErrorMarker,
-  s as FormNonFieldErrorMarkerHtmlAttribute,
-  p as useFormErrorConsoleDebug,
-  m as useFormErrorOrphansToConsoleError,
-  x as useFormErrorsEffect,
-  i as useFormErrorsOnChange,
-  u as useFormOrphanErrors,
-  h as useFormRequestSubmit,
-  F as useFormRootFieldErrors
+  t as FormNonFieldErrorMarkerHtmlAttribute,
+  x as useFormErrorConsoleDebug,
+  i as useFormErrorsEffect,
+  a as useFormErrorsHasOnlyOrphans,
+  O as useFormErrorsIfAny,
+  b as useFormErrorsOnChange,
+  C as useFormOnSubmitSuccessful,
+  k as useFormOnSubmitSuccessfulAndReset,
+  A as useFormRequestSubmit,
+  m as useOrphanFormErrors,
+  d as useOrphanFormErrorsToConsoleError,
+  H as useResetFormAfterSubmitSuccessful,
+  F as useRootFormFieldErrors
 };

package/dist/esm/submit/useFormOnSubmitSuccessful.mjs

@@ -0,0 +1,11 @@
+import u from "react";
+import { useFormState as e } from "react-hook-form";
+const o = (s) => {
+  const { isSubmitSuccessful: t } = e();
+  u.useEffect(() => {
+    s && t && s();
+  }, [s, t]);
+}, r = o;
+export {
+  r as default
+};

package/dist/esm/submit/useFormOnSubmitSuccessfulAndReset.mjs

@@ -0,0 +1,14 @@
+import r from "react";
+import { useFormState as c } from "react-hook-form";
+import f from "./useFormOnSubmitSuccessful.mjs";
+const m = (s) => {
+  const { isSubmitSuccessful: t, isDirty: u } = c(), e = r.useRef(!1);
+  f(() => {
+    e.current = !0;
+  }), r.useEffect(() => {
+    s && e.current && !t && !u && (s(), e.current = !1);
+  }, [t, u]);
+}, S = m;
+export {
+  S as default
+};

package/dist/esm/submit/useResetFormOnSubmitSuccessful.mjs

@@ -0,0 +1,11 @@
+import { useFormContext as r } from "react-hook-form";
+import t from "./useFormOnSubmitSuccessful.mjs";
+const s = (e) => {
+  const { reset: u } = r();
+  t(() => {
+    e != null && e.enabled && u(void 0, e);
+  });
+}, f = s;
+export {
+  f as default
+};

package/dist/types/errors/getFlatFieldErrors.d.ts

@@ -15,3 +15,11 @@ export type FlatFieldErrors = Record<string, FieldError>;
  */
 declare const getFlatFieldErrors: (errors: FieldErrors) => FlatFieldErrors;
 export default getFlatFieldErrors;
+/**
+ * Regular expression to maybe match the end of a leaf node path.
+ *
+ * i.e., `name.type`, `address.street.message`
+ *
+ * iow: dot [?: non-capturing]("type" | "message")[\b word boundary][$ end of string]
+ */
+export declare const regexMaybeFieldErrorLeafNode: RegExp;

package/dist/types/errors/nonfield/FormNonFieldErrorMarker.d.ts

@@ -4,7 +4,7 @@ type Props = {
     path: string;
 };
 /**
- * Empty, hidden marker to indicate a non-field error is presented to user.
+ * Empty, hidden marker to indicate a non-field/non-root error is being displayed to user.
  */
 declare const FormNonFieldErrorMarker: React.FC<Props>;
 export default FormNonFieldErrorMarker;

package/dist/types/errors/nonfield/FormNonFieldErrorMarker.utils.d.ts

@@ -1,6 +1,7 @@
 /**
  * HTML data attribute for {@link FormNonFieldErrorMarker}.
  */
-export declare const FormNonFieldErrorMarkerHtmlAttribute = "data-paragrav-rhf-utils-nonfield-error-marker-path";
+declare const FormNonFieldErrorMarkerHtmlAttribute = "data-paragrav-rhf-utils-nonfield-error-marker-path";
+export default FormNonFieldErrorMarkerHtmlAttribute;
 export declare const getFormNonFieldErrorMarkerQuerySelector: (path: string) => string;
 export declare const hasNonFieldErrorMarkerInDOM: (path: string, parentElement: Pick<HTMLElement, 'querySelector'>) => Element | null;

package/dist/types/errors/nonfield/utils.d.ts

@@ -13,6 +13,6 @@ import { FieldError } from 'react-hook-form';
  *   - Orphan (undisplayed), which are typically caused by one of the following cases:
  *      - The input is missing.
  *      - The schema is incorrect.
- *      - The non-field error is not displayed to user with `FormErrorNonFieldMarker`.
+ *      - The error is not displayed to user with `FormErrorNonFieldMarker`.
  */
 export declare const isNonFieldError: (error: FieldError) => boolean;

package/dist/types/errors/orphan/useFormErrorsHasOnlyOrphans.d.ts

@@ -0,0 +1,2 @@
+declare const useFormErrorsHasOnlyOrphans: (formRef: React.RefObject<HTMLFormElement>) => boolean;
+export default useFormErrorsHasOnlyOrphans;

package/dist/types/errors/{orphans/useFormOrphanErrors.d.ts → orphan/useOrphanFormErrors.d.ts}

@@ -1,4 +1,4 @@
 import { default as React } from 'react';
 
-declare const useFormOrphanErrors: (formRef: React.RefObject<HTMLFormElement>) => import('../getFlatFieldErrors').FlatFieldErrors;
-export default useFormOrphanErrors;
+declare const useOrphanFormErrors: (formRef: React.RefObject<HTMLFormElement>) => import('../getFlatFieldErrors').FlatFieldErrors;
+export default useOrphanFormErrors;

package/dist/types/errors/orphan/useOrphanFormErrorsToConsoleError.d.ts

@@ -0,0 +1,8 @@
+import { default as React } from 'react';
+
+/**
+ * Outputs orphan errors to `console.error` all errors with `ref: undefined` that do not begin with `root(.*)`.
+ * Sentry (or equivalent) should capture.
+ */
+declare const useOrphanFormErrorsToConsoleError: (formRef: React.RefObject<HTMLFormElement>) => void;
+export default useOrphanFormErrorsToConsoleError;

package/dist/types/errors/orphan/utils.d.ts

@@ -0,0 +1,4 @@
+import { FlatFieldErrors } from '../getFlatFieldErrors';
+import { FieldErrors } from 'react-hook-form';
+
+export declare const getOrphanFlatFieldErrors: (errors: FieldErrors, parentElement: Pick<HTMLElement, 'querySelector'>) => FlatFieldErrors;

package/dist/types/errors/root/{useFormRootFieldErrors.d.ts → useRootFormFieldErrors.d.ts}

@@ -2,5 +2,5 @@
  * Root field errors from form.
  * These are typically displayed at the bottom of the form.
  */
-declare const useFormRootFieldErrors: () => import('../getFlatFieldErrors').FlatFieldErrors;
-export default useFormRootFieldErrors;
+declare const useRootFormFieldErrors: () => import('../getFlatFieldErrors').FlatFieldErrors;
+export default useRootFormFieldErrors;

package/dist/types/errors/useFormErrorsIfAny.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Returns errors only if there are errors.
+ * Allows simple typeguard without `isEmpty` dependency.
+ */
+declare const useFormErrorsIfAny: () => false | import('react-hook-form').FieldErrors<import("react-hook-form").FieldValues>;
+export default useFormErrorsIfAny;

package/dist/types/errors/useFormFlatFieldErrors.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Use {@link FieldErrors} as {@link FlatFieldErrors}.
+ */
+declare const useFormFlatFieldErrors: () => import('./getFlatFieldErrors').FlatFieldErrors;
+export default useFormFlatFieldErrors;

package/dist/types/main.d.ts

@@ -1,9 +1,14 @@
 export { default as FormNonFieldErrorMarker } from './errors/nonfield/FormNonFieldErrorMarker';
-export { FormNonFieldErrorMarkerHtmlAttribute } from './errors/nonfield/FormNonFieldErrorMarker.utils';
-export { default as useFormErrorOrphansToConsoleError } from './errors/orphans/useFormErrorOrphansToConsoleError';
-export { default as useFormOrphanErrors } from './errors/orphans/useFormOrphanErrors';
-export { default as useFormRootFieldErrors } from './errors/root/useFormRootFieldErrors';
+export { default as FormNonFieldErrorMarkerHtmlAttribute } from './errors/nonfield/FormNonFieldErrorMarker.utils';
+export { default as useFormErrorsHasOnlyOrphans } from './errors/orphan/useFormErrorsHasOnlyOrphans';
+export { default as useOrphanFormErrors } from './errors/orphan/useOrphanFormErrors';
+export { default as useOrphanFormErrorsToConsoleError } from './errors/orphan/useOrphanFormErrorsToConsoleError';
+export { default as useRootFormFieldErrors } from './errors/root/useRootFormFieldErrors';
 export { default as useFormErrorConsoleDebug } from './errors/useFormErrorConsoleDebug';
 export { default as useFormErrorsEffect } from './errors/useFormErrorsEffect';
+export { default as useFormErrorsIfAny } from './errors/useFormErrorsIfAny';
 export { default as useFormErrorsOnChange } from './errors/useFormErrorsOnChange';
 export { default as useFormRequestSubmit } from './errors/useFormRequestSubmit';
+export { default as useFormOnSubmitSuccessful } from './submit/useFormOnSubmitSuccessful';
+export { default as useFormOnSubmitSuccessfulAndReset } from './submit/useFormOnSubmitSuccessfulAndReset';
+export { default as useResetFormAfterSubmitSuccessful } from './submit/useResetFormOnSubmitSuccessful';

package/dist/types/submit/useFormOnSubmitSuccessful.d.ts

@@ -0,0 +1,2 @@
+declare const useFormOnSubmitSuccessful: (callback?: () => void) => void;
+export default useFormOnSubmitSuccessful;

package/dist/types/submit/useFormOnSubmitSuccessfulAndReset.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Calls a callback after a successful submit and after a form reset.
+ *
+ * Using RHF and following its rules, we are not able to get the state `isSubmitSuccessful=true` and `isDirty=false`.
+ * So, this has to keep track of previous state.
+ *
+ * SubmitSuccessfulAndReset = was `isSubmitSuccessful` and now `!isSubmitSuccessful && !isDirty`
+ */
+declare const useFormOnSubmitSuccessfulAndReset: (callback?: () => void) => void;
+export default useFormOnSubmitSuccessfulAndReset;

package/dist/types/submit/useResetFormOnSubmitSuccessful.d.ts

@@ -0,0 +1,12 @@
+import { KeepStateOptions } from 'react-hook-form';
+
+type Options = {
+    enabled?: boolean;
+} & KeepStateOptions;
+/**
+ * Handle resetting after successful submit with no server validation errors.
+ * See `Rules` section: https://react-hook-form.com/api/useform/reset/
+ * Specifically: "- It's recommended to reset inside useEffect after submission."
+ */
+declare const useResetFormAfterSubmitSuccessful: (options?: Options) => void;
+export default useResetFormAfterSubmitSuccessful;

package/package.json

@@ -2,9 +2,10 @@
   "name": "@paragrav/rhf-utils",
   "author": "paragrav.dev",
   "license": "MIT",
-  "version": "0.0.19",
+  "version": "0.0.21",
   "description": "Integration utilities for react-hook-form.",
   "type": "module",
+  "sideEffects": false,
   "files": [
     "dist"
   ],
@@ -12,22 +13,81 @@
   "module": "./dist/esm/main.mjs",
   "exports": {
     ".": {
-      "require": {
-        "types": "./dist/types/main.d.ts",
-        "default": "./dist/cjs/main.js"
-      },
-      "import": {
-        "types": "./dist/types/main.d.ts",
-        "default": "./dist/esm/main.mjs"
-      }
+      "import": "./dist/esm/main.mjs",
+      "require": "./dist/cjs/main.js",
+      "types": "./dist/types/main.d.ts"
     },
-    "./useFormErrorConsoleDebug": {
-      "types": "./dist/types/errors/useFormErrorConsoleDebug.d.ts",
+    "./errors/useFormErrorConsoleDebug": {
+      "import": "./dist/esm/errors/useFormErrorConsoleDebug.mjs",
       "require": "./dist/cjs/errors/useFormErrorConsoleDebug.cjs",
-      "import": "./dist/esm/errors/useFormErrorConsoleDebug.mjs"
+      "types": "./dist/types/errors/useFormErrorConsoleDebug.d.ts"
+    },
+    "./errors/useFormErrorsEffect": {
+      "import": "./dist/esm/errors/useFormErrorsEffect.mjs",
+      "require": "./dist/cjs/errors/useFormErrorsEffect.cjs",
+      "types": "./dist/types/errors/useFormErrorsEffect.d.ts"
+    },
+    "./errors/useFormErrorsIfAny": {
+      "import": "./dist/esm/errors/useFormErrorsIfAny.mjs",
+      "require": "./dist/cjs/errors/useFormErrorsIfAny.cjs",
+      "types": "./dist/types/errors/useFormErrorsIfAny.d.ts"
+    },
+    "./errors/useFormErrorsOnChange": {
+      "import": "./dist/esm/errors/useFormErrorsOnChange.mjs",
+      "require": "./dist/cjs/errors/useFormErrorsOnChange.cjs",
+      "types": "./dist/types/errors/useFormErrorsOnChange.d.ts"
+    },
+    "./errors/useFormRequestSubmit": {
+      "import": "./dist/esm/errors/useFormRequestSubmit.mjs",
+      "require": "./dist/cjs/errors/useFormRequestSubmit.cjs",
+      "types": "./dist/types/errors/useFormRequestSubmit.d.ts"
+    },
+    "./errors/FormNonFieldErrorMarker": {
+      "import": "./dist/esm/errors/nonfield/FormNonFieldErrorMarker.mjs",
+      "require": "./dist/cjs/errors/nonfield/FormNonFieldErrorMarker.cjs",
+      "types": "./dist/types/errors/nonfield/FormNonFieldErrorMarker.d.ts"
+    },
+    "./errors/FormNonFieldErrorMarkerHtmlAttribute": {
+      "import": "./dist/esm/errors/nonfield/FormNonFieldErrorMarker.utils.mjs",
+      "require": "./dist/cjs/errors/nonfield/FormNonFieldErrorMarker.utils.cjs",
+      "types": "./dist/types/errors/nonfield/FormNonFieldErrorMarker.utils.d.ts"
+    },
+    "./errors/useOrphanFormErrorsToConsoleError": {
+      "import": "./dist/esm/errors/orphan/useOrphanFormErrorsToConsoleError.mjs",
+      "require": "./dist/cjs/errors/orphan/useOrphanFormErrorsToConsoleError.cjs",
+      "types": "./dist/types/errors/orphan/useOrphanFormErrorsToConsoleError.d.ts"
+    },
+    "./errors/useFormErrorsHasOnlyOrphans": {
+      "import": "./dist/esm/errors/orphan/useFormErrorsHasOnlyOrphans.mjs",
+      "require": "./dist/cjs/errors/orphan/useFormErrorsHasOnlyOrphans.cjs",
+      "types": "./dist/types/errors/orphan/useFormErrorsHasOnlyOrphans.d.ts"
+    },
+    "./errors/useOrphanFormErrors": {
+      "import": "./dist/esm/errors/orphan/useOrphanFormErrors.mjs",
+      "require": "./dist/cjs/errors/orphan/useOrphanFormErrors.cjs",
+      "types": "./dist/types/errors/orphan/useOrphanFormErrors.d.ts"
+    },
+    "./errors/useRootFormFieldErrors": {
+      "import": "./dist/esm/errors/root/useRootFormFieldErrors.mjs",
+      "require": "./dist/cjs/errors/root/useRootFormFieldErrors.cjs",
+      "types": "./dist/types/errors/root/useRootFormFieldErrors.d.ts"
+    },
+    "./submit/useFormOnSubmitSuccessful": {
+      "import": "./dist/esm/submit/useFormOnSubmitSuccessful.mjs",
+      "require": "./dist/cjs/submit/useFormOnSubmitSuccessful.cjs",
+      "types": "./dist/types/submit/useFormOnSubmitSuccessful.d.ts"
+    },
+    "./submit/useFormOnSubmitSuccessfulAndReset": {
+      "import": "./dist/esm/submit/useFormOnSubmitSuccessfulAndReset.mjs",
+      "require": "./dist/cjs/submit/useFormOnSubmitSuccessfulAndReset.cjs",
+      "types": "./dist/types/submit/useFormOnSubmitSuccessfulAndReset.d.ts"
+    },
+    "./submit/useResetFormAfterSubmitSuccessful": {
+      "import": "./dist/esm/submit/useResetFormAfterSubmitSuccessful.mjs",
+      "require": "./dist/cjs/submit/useResetFormAfterSubmitSuccessful.cjs",
+      "types": "./dist/types/submit/useResetFormAfterSubmitSuccessful.d.ts"
     }
   },
-  "sideEffects": false,
   "scripts": {
     "build": "npm run validate && npm run build:cjs && npm run build:esm",
     "build:cjs": "tsc -p ./tsconfig.cjs.json",

package/dist/cjs/errors/orphans/useFormErrorOrphansToConsoleError.d.ts

@@ -1,9 +0,0 @@
-import React from 'react';
-/**
- * Orphans are field errors that do not have a ref.
- * (Most commonly `root(.*)`, but these are filtered out. They are handled by `useFormRootFieldErrors`.)
- * Outputs to `console.error` all errors with `ref: undefined` that do not begin with `root(.*)`.
- * Sentry (or equivalent) should capture.
- */
-declare const useFormErrorOrphansToConsoleError: (formRef: React.RefObject<HTMLFormElement>) => void;
-export default useFormErrorOrphansToConsoleError;

package/dist/cjs/errors/orphans/useFormErrorsHasOnlyOrphan.d.ts

@@ -1,2 +0,0 @@
-declare const useFormErrorsHasOnlyOrphan: (formRef: React.RefObject<HTMLFormElement>) => boolean;
-export default useFormErrorsHasOnlyOrphan;

package/dist/cjs/errors/orphans/useFormErrorsHasOnlyOrphan.js

@@ -1,21 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const utils_1 = require("@/utils");
-const useFormContextErrorsIfAny_1 = __importDefault(require("../useFormContextErrorsIfAny"));
-const useFormOrphanErrors_1 = __importDefault(require("./useFormOrphanErrors"));
-const useFormErrorsHasOnlyOrphan = (formRef) => {
-    const orphans = (0, useFormOrphanErrors_1.default)(formRef);
-    const errors = (0, useFormContextErrorsIfAny_1.default)();
-    // no errors
-    if (!errors)
-        return false;
-    // no orphans
-    if ((0, utils_1.isEmptyObject)(orphans))
-        return false;
-    // equal length
-    return Object.keys(orphans).length === Object.keys(errors).length;
-};
-exports.default = useFormErrorsHasOnlyOrphan;

package/dist/cjs/errors/orphans/utils.d.ts

@@ -1,3 +0,0 @@
-import type { FieldErrors } from 'react-hook-form';
-import type { FlatFieldErrors } from '../getFlatFieldErrors';
-export declare const getRootFlatFieldErrors: (errors: FieldErrors, parentElement: Pick<HTMLElement, 'querySelector'>) => FlatFieldErrors;

package/dist/cjs/errors/useFormContextErrorsIfAny.d.ts

@@ -1,6 +0,0 @@
-/**
- * Returns errors only if there are errors.
- * Allows simple typeguard without `isEmpty` dependency.
- */
-declare const useFormContextErrorsIfAny: () => false | import("react-hook-form").FieldErrors<import("react-hook-form").FieldValues>;
-export default useFormContextErrorsIfAny;

package/dist/esm/errors/orphans/useFormOrphanErrors.mjs

@@ -1,14 +0,0 @@
-import "react";
-import { isEmptyObject as t } from "../../utils.mjs";
-import e from "../useFormErrorsOnChange.mjs";
-import { getRootFlatFieldErrors as n } from "./utils.mjs";
-const s = (o) => e((r) => {
-  if (t(r))
-    return {};
-  if (!o.current)
-    throw console.error(r), new Error("This should not happen.");
-  return n(r, o.current);
-}), a = s;
-export {
-  a as default
-};

package/dist/esm/errors/useFormContextErrorsIfAny.mjs

@@ -1,9 +0,0 @@
-import { useFormState as t } from "react-hook-form";
-import { isEmptyObject as o } from "../utils.mjs";
-const m = () => {
-  const { errors: r } = t();
-  return o(r) ? !1 : r;
-};
-export {
-  m as default
-};

package/dist/types/errors/orphans/useFormErrorOrphansToConsoleError.d.ts

@@ -1,10 +0,0 @@
-import { default as React } from 'react';
-
-/**
- * Orphans are field errors that do not have a ref.
- * (Most commonly `root(.*)`, but these are filtered out. They are handled by `useFormRootFieldErrors`.)
- * Outputs to `console.error` all errors with `ref: undefined` that do not begin with `root(.*)`.
- * Sentry (or equivalent) should capture.
- */
-declare const useFormErrorOrphansToConsoleError: (formRef: React.RefObject<HTMLFormElement>) => void;
-export default useFormErrorOrphansToConsoleError;

package/dist/types/errors/orphans/useFormErrorsHasOnlyOrphan.d.ts

@@ -1,2 +0,0 @@
-declare const useFormErrorsHasOnlyOrphan: (formRef: React.RefObject<HTMLFormElement>) => boolean;
-export default useFormErrorsHasOnlyOrphan;

package/dist/types/errors/orphans/utils.d.ts

@@ -1,4 +0,0 @@
-import { FlatFieldErrors } from '../getFlatFieldErrors';
-import { FieldErrors } from 'react-hook-form';
-
-export declare const getRootFlatFieldErrors: (errors: FieldErrors, parentElement: Pick<HTMLElement, 'querySelector'>) => FlatFieldErrors;

package/dist/types/errors/useFormContextErrorsIfAny.d.ts

@@ -1,6 +0,0 @@
-/**
- * Returns errors only if there are errors.
- * Allows simple typeguard without `isEmpty` dependency.
- */
-declare const useFormContextErrorsIfAny: () => false | import('react-hook-form').FieldErrors<import("react-hook-form").FieldValues>;
-export default useFormContextErrorsIfAny;