@paragrav/rhf-utils 0.1.0 → 0.59.0

package/README.md

@@ -7,46 +7,51 @@ Integration and utility library for [react-hook-form](https://www.react-hook-for
 ## Features
 
 - TypeScript-first
-- global configuration (`RhfUtilsClientConfig`)
+- global configuration (🔗 [`RhfUtilsClientConfig`](#config) section)
   - RHF (`UseFormProps`) and utilities (`RhfUtilsFormOptions`) options defaults
-  - inject your own hooks and UI (`FormChildrenWrapper`)
-  - server error transformation (`onSubmitErrorUnknown`)
-  - RHF `FormState.errors` logging/throwing (`RhfUtilsClientConfig.fieldErrors`)
-- form-level configuration (`RhfUtilsZodForm`)
+  - inject your own hooks and UI (`FormComponent`)
+  - server error transformation (`onSubmitErrorUnknown`) ✨
+  - handle cancel prompt (`useCanFormBeCancelled`) ✨
+  - RHF `FormState.errors` logging/throwing (`RhfUtilsClientConfig.fieldErrors`) ✨
+- form-level configuration (🔗 [`RhfUtilsZodForm`](#form) section)
   - RHF and utilities options overrides
     - extendable utilities options type (`RhfUtilsFormOptions`)
   - throw error (`FormSubmitError`) in submit handler to add errors to RHF context and fail submit
-  - handle submit error (`onSubmitError`)
-  - dependency injection for children (`RhfUtilsZodForm.Children`), including:
+  - handle submit error (`onSubmitError` / `useLastSubmitError`)
+  - context injection for children (`RhfUtilsZodForm.Children`), including:
     - formId, formRef, RHF context, utilities options
     - schema-typed Controller component and FormSubmitError class
-- simpler/flatter `FieldErrors` structure (`FlatFieldErrors`)
+- form state relay (🔗 [`FormStateRelayContextProvider`](#form-state-relay) section) ✨
+  - access specific form's state from outside that form/provider
+  - assign forms into groups and watch collectively
+- simpler/flatter `FieldErrors` structure (🔗 [`FlatFieldErrors`](#flatfielderrors) section)
+  - find orphans errors (🔗 [orphan errors](#orphan-errors) section) ✨
   - context groups errors into `all`, `fields`, `roots`, and `orphans` (`useFlatFieldErrorsContext`)
-- safer `FieldValues` type (`SafeFieldValues`)
+- safer `FieldValues` type (🔗 [`SafeFieldValues`](#safefieldvalues) section)
 - `zod` support, including input/output types for transformations
-- ~3.2kB min+gzip core (excluding [peer dependencies](#peer-dependencies))
+- ~2.8kB min+gzip core (excluding [peer dependencies](#peer-dependencies))
 
 ## Install
 
 ```sh
 npm install @paragrav/rhf-utils  # npm
-pnpm install @paragrav/rhf-utils # pnpm
+pnpm add @paragrav/rhf-utils     # pnpm
 yarn add @paragrav/rhf-utils     # yarn
 ```
 
 ## Quick Start
 
 - 🔗 [Config](#config) (`RhfUtilsClientConfig`): define your global config (optional)
-- 🔗 [Provider](#provider) (`RhfUtilsClientForZodContextProvider`): add to your global stack
-- 🔗 [Form](#form) (`RhfUtilsZodForm`): use as form component
+  - 🔗 [Provider](#config-provider) (`RhfUtilsClientConfigProvider`): add to your global stack
+- 🔗 [Form With Providers](#form-with-providers) (`RhfUtilsZodFormWithProviders`): use as form component
+- 🔗 [Form State Relay](#form-state-relay) (`FormStateRelayContextProvider`): relay form state
 
 ## Config
 
-Create a config (`RhfUtilsClientConfig`) object with desired global config and default options. Config applies across all forms, and defaults can be overridden per form.
+Create a config (`RhfUtilsClientConfig`) object with desired **global** config and default options. Config applies across all forms, and defaults can be overridden per form.
 
 ```tsx
 export const rhfUtilsClientConfig: RhfUtilsClientConfig = {
-  // overridable at individual form level
   defaults: {
     // globally-relevant subset of RHF's `UseFormProps` options
     rhf: {
@@ -66,17 +71,16 @@ export const rhfUtilsClientConfig: RhfUtilsClientConfig = {
     },
   },
 
-  // optional form component (defaults to primitive HTML form)
-  FormComponent: Form.Root,
-
-  // optional wrapper component to inject your own hooks and components
-  // around all RhfUtilsZodForm instances
-  FormChildrenWrapper: (
-    // UseRhfUtilsFormChildrenProps
+  // optional form component to use (defaults to primitive HTML form)
+  // also, is used to inject your own hooks and components
+  // for all RhfUtilsZodForm instances
+  FormComponent: (
+    // RhfUtilsFormComponentProps
     {
+      formProps, //       computed form props
       formId, //          unique id string
       formRef, //         ref
-      context, //         rhf UseFormReturn
+      context, //         rhf UseFormReturn (without proxy `formState`)
       options, //         RhfUtilsFormOptions (with any custom props)
       Controller, //      rhf controller (SafeFieldValues-typed; no schema at this level)
       FormSubmitError, // error class (SafeFieldValues-typed; no schema at this level)
@@ -92,16 +96,31 @@ export const rhfUtilsClientConfig: RhfUtilsClientConfig = {
     });
 
     return (
-      <>
+      <Form.Root {...formProps} ref={formRef}>
         {/* RhfUtilsZodForm.Children "outlet" (see "Component Hierarchy" section) */}
         {children}
 
         {/* root errors list */}
         <RootErrorsList />
-      </>
+      </Form.Root>
     );
   },
 
+  // hook that returns callback to determine whether form can be cancelled
+  // if `true`, `RhfUtilsZodForm.onCancel` at form-level is called (e.g., parent component hides form)
+  // this allows you to handle non-navigational blocking/prompting
+  // NOTE: this library is router-agnostic, so navigation blocking should happen elsewhere
+  // (i.e., calling your own hook in `FormComponent`)
+  useCanFormBeCancelled: () => {
+    const { isDirty } = useFormState();
+
+    // return callback to be called at event-time
+    return ({ options }) =>
+      !options.enableMyPrompter || // my prompter option not enabled
+      !isDirty || // or rhf form state not dirty
+      confirm('Are you sure you want to cancel?'); // or user confirms
+  },
+
   // non-FormSubmitError thrown in onSubmit
   // use case: handle and transform server error data for frontend
   onSubmitErrorUnknown: (
@@ -134,108 +153,140 @@ export const rhfUtilsClientConfig: RhfUtilsClientConfig = {
 };
 ```
 
-## Provider
+## Config Provider
 
 Add the context provider to your global provider stack.
 
 ```tsx
-<RhfUtilsClientForZodContextProvider config={rhfUtilsClientConfig}>
+<RhfUtilsClientConfigProvider config={rhfUtilsClientConfig}>
   {children}
-</RhfUtilsClientForZodContextProvider>
+</RhfUtilsClientConfigProvider>
 ```
 
-Currently, only `zod` is supported.
+## Form With Providers
 
-## Form
+Currently, only `zod` schemas are supported.
 
 ```tsx
-<RhfUtilsZodForm
-  schema={loginFormSchema}
-  defaultValues={{
-    email: '',
+<RhfUtilsZodFormWithProviders
+  schema={z.object({
+    email: z.string().min(1).email(),
+    password: z.string().min(1),
+    passwordConfirm: z.string().min(1),
+  })}
+  defaultValues={{ email: '', password: '', passwordConfirm: '' }}
+  getApiData={({ email, password }) => ({ email, password })}
+  // cancel handler (passed to `Children` below)
+  // execution routed through `RhfUtilsClientConfig.useCanFormBeCancelled`, if provided
+  onCancel={handleCancel}
+  // submit handlers
+  onBeforeSubmitInvariants={async (
+    { input, output, api }, // schema input (form values), output; api data (via getApiData)
+    context, //                UseRhfUtilsFormOnSubmitContext (id, ref, rhf context (without proxy formState), utils options, schema-typed FormSubmitError class)
+    event, //                  SubmitEvent
+  ) => [
+    [
+      'passwordConfirm', // type safe
+      'Passwords must match.',
+      data.password === data.passwordConfirm,
+    ],
+  ]}
+  onBeforeSubmit={({ input, output, api }, context, event) => {
+    if (!isValid(input.email))
+      throw new context.FormSubmitError({
+        email: { message: 'Email is invalid.' },
+      });
   }}
   // submit handler
-  onSubmit={async (
-    data, //    schema output
-    context, // UseRhfUtilsFormOnSubmitContext (id, ref, rhf context, utils options, schema-typed FormSubmitError class)
-    event, //   SubmitEvent
-  ) => {
-    await loginService(data);
-    handleSuccess();
-  }}
+  onSubmit={({ input, output, api }, context, event) => registerService(api)}
+  onSubmitSuccess={(onSubmitResult, { input, output, api }, context, event) =>
+    navigate('/app/' + onSubmitResult.id)
+  }
   // handle error declaratively (i.e., no throw/catch)
-  onSubmitError={({
-    error, //   unknown
-    context, // UseRhfUtilsFormOnSubmitErrorContext (id, ref, rhf context, utils options, `FormSubmitFieldErrors` from `onSubmitErrorUnknown`)
-    event, //   SubmitEvent
-  }) => {
+  onSubmitError={({ error, context, event }) => {
     handleError(error);
   }}
+  onSubmitFinally={() => {
+    setState();
+  }}
+  // form-specific options/overrides (merged with defaults)
+  rhf={{
+    mode: 'onBlur',
+  }}
+  utils={{
+    submitOnWatch: { debounce: 250 },
+    // custom option props
+    // (see "Extend RhfUtilsFormOptions" section)
+    enableMyOptionalFormHook: true,
+  }}
+  // surfaced form element attributes
+  id="my-form-id"
+  className="my-special-form-class" // merged with global defaults
+  // other form element attributes
+  form={{ noValidate: true }} // merged with global defaults
   // fields
   Children={({
     // UseRhfUtilsFormChildrenProps
-    formId, //          unique id string
+    formId, //          unique id string (auto-gen if not supplied)
     formRef, //         ref
-    context, //         rhf UseFormReturn
+    context, //         rhf UseFormReturn (without proxy `formState`)
     options, //         RhfUtilsFormOptions
     Controller, //      schema-typed rhf controller
     FormSubmitError, // schema-typed error class
+    onCancel, //        wrapped cancel handler from above
   }) => (
     <>
       <Controller
         name="email" // schema-typed field name
         render={({ field, formState: { isSubmitting } }) => (
-          <label>
-            Email
-            <input {...field} disabled={isSubmitting} />
+          <Stack>
+            <label>
+              Email
+              <input {...field} disabled={isSubmitting} />
+            </label>
+
             <ErrorMessage path={field.name} />
-          </label>
+          </Stack>
         )}
       />
 
-      <button type="button" onClick={handleCancel}>
+      <button type="button" onClick={onCancel}>
         Cancel
       </button>
       <button type="submit">Login</button>
     </>
   )}
-  // form-specific options/overrides (merged with defaults)
-  rhf={{
-    mode: 'onBlur',
-  }}
-  utils={{
-    submitOnChange: true,
-    // custom option props
-    // (see "Extend RhfUtilsFormOptions" section)
-    enableMyOptionalFormHook: true,
-  }}
-  form={{
-    // class names are merged together with global defaults
-    className: 'my-special-form-class',
-  }}
 />
 ```
 
 ### Form Children
 
-`Children` prop takes a component which is rendered as a child of the form (and, if supplied, of `RhfUtilsClientConfig.FormChildrenWrapper`). It receives `UseRhfUtilsFormChildrenProps` as props, including a type-safe `Controller` component.
+`Children` prop takes a component which is rendered as a child of the form (and, if supplied, of `RhfUtilsClientConfig.FormComponent`). It receives `UseRhfUtilsFormChildrenProps` as props, including a type-safe `Controller` component.
 
-If you prefer to define your `Children` component as standalone, you will need to specify any dependencies as `props` (e.g., `onCancel` callback):
+If you prefer to define your `Children` component as standalone, you will need to specify any dependencies as `props` (e.g., `onEvent` callback):
 
 ```tsx
-const Children: RhfUtilsUseFormChildrenZodFC<typeof schema, { onCancel: () => void }> = ({...}) => {};
+const Children: RhfUtilsUseZodFormChildrenFC<
+  typeof schema,
+  { onEvent: () => void } // other props (if required)
+> = ({ ... }) => {};
 
-function Children({...}: RhfUtilsUseFormChildrenZodProps<typeof schema, { onCancel: () => void }>) {}
+// or
+
+function Children({ ... }: RhfUtilsUseZodFormChildrenProps<
+  typeof schema,
+  { onEvent: () => void } // other props (if required)
+>) {}
 ```
 
-And pass dependencies manually:
+And pass other props manually, if applicable:
 
 ```tsx
-<RhfUtilsZodForm
+<RhfUtilsZodFormWithProviders
   Children={(rhfUtilsZodFormChildrenProps) => (
     <Children
       {...rhfUtilsZodFormChildrenProps}
-      props={{ onCancel: handleCancel }}
+      props={{ onEvent: handleEvent }}
     />
   )}
 />
@@ -243,20 +294,40 @@ And pass dependencies manually:
 
 ## Form Component Hierarchy
 
-`RhfUtilsZodForm` renders as:
+For each form instance, `RhfUtilsZodForm` renders as the following:
 
 ```tsx
-<ReactHookForm.FormProvider> // standard rhf provider
-  <RhfUtilsProviders> // rhf utils internal providers
-    <RhfUtilsClientConfig.FormComponent> // from global config (or default)
-      <RhfUtilsClientConfig.FormChildrenWrapper> // from global config (if provided)
-        <RhfUtilsZodForm.Children /> // form instance component prop
-      </RhfUtilsClientConfig.FormChildrenWrapper>
+<ReactHookForm.FormProvider>             // standard rhf provider
+  <RhfUtilsProviders>                    // rhf utils internal providers
+    <RhfUtilsClientConfig.FormComponent> // from global config (or native form, if not provided)
+      <RhfUtilsZodForm.Children />       // form instance component prop
     </RhfUtilsClientConfig.FormComponent>
   <RhfUtilsProviders>
 </ReactHookForm.FormProvider>
 ```
 
+## De-couple Providers from Form
+
+Sometimes you need to control the nesting of the Form element. For example, to appease HTML rules or expand the scope of the Provider.
+
+```tsx
+<aside>
+  <RhfUtilsZodFormProviders formId="my-form">
+    <main>
+      <RhfUtilsZodForm />
+    </main>
+
+    <footer>
+      <SubmitButton form="my-form">
+
+      <MyFormErrorsViaProviders>
+    </footer>
+  </RhfUtilsZodFormProviders>
+</aside>
+```
+
+For similar pattern, especially across more than one form, see [Form State Relay](#form-state-relay) section.
+
 ## `FormSubmitError`
 
 This is an `Error`-based class that you can use to throw a schema-typed error in your submit handler.
@@ -266,21 +337,23 @@ This is an `Error`-based class that you can use to throw a schema-typed error in
 ### Example
 
 ```tsx
-<RhfUtilsZodForm
-  onSubmit={async (data, { FormSubmitError }) => {
-    if (isProblem(data))
+<RhfUtilsZodFormWithProviders
+  onBeforeSubmit={async ({ input, output, api }, { FormSubmitError }) => {
+    if (!isValid(data))
       throw new FormSubmitError({
         'street.address': { message: 'Street address invalid.' },
       });
-
-    await post('/backend');
   }}
 />
 ```
 
 Any non-`FormSubmitError` error thrown from your submit handler (e.g., fetch/axios error) can be transformed by `RhfUtilsClientConfig`'s `onSubmitErrorUnknown` callback. This takes an `unknown` error and can return a `FormSubmitFieldErrors` object, which is merged into RHF's form state errors.
 
-Most common use case will be transforming backend errors to frontend shape.
+Most common use case will be transforming backend errors to frontend shape expected by RHF.
+
+### Last Submit Error
+
+Sometimes, perhaps outside any specific `FormContext`, you need direct access to the actual error object that was thrown, which caused the last submit to fail. The `useLastSubmitError` hook allows you to do just this. (You can probably handle most form-specific cases via `onSubmitErrorUnknown`, which receives error as well.)
 
 ## `RhfUtilsFormOptions`
 
@@ -291,12 +364,8 @@ type RhfUtilsFormOptions = {
   /** Stop propagation of submit event. */
   stopSubmitPropagation?: boolean;
 
-  /**
-   * Request submit via listener on form change.
-   * - `true`: no debounce
-   * - number: milliseconds to debounce
-   */
-  submitOnChange?: boolean | number;
+  /** Request submit on change. */
+  submitOnChange?: { debounce?: number };
 
   /**
    * Reset form values and state (e.g., isDirty, etc.) after submit -- on success and/or error.
@@ -327,7 +396,8 @@ import '@paragrav/rhf-utils';
 declare module '@paragrav/rhf-utils' {
   export interface Register {
     RhfUtilsFormOptions: {
-      /** Custom props for your custom hooks/behaviors. */
+      /** Custom props for your custom options/hooks/behaviors. */
+      enableMyPrompter?: boolean;
       enableMyOptionalFormHook?: boolean;
       configMyOptionalFormHook?: MyCustomFormHookConfig;
     };
@@ -335,6 +405,100 @@ declare module '@paragrav/rhf-utils' {
 }
 ```
 
+## <a id="form-state-relay" /> Form State Relay _(~1.2kB min+gzip)_
+
+Sometimes you need to access one or more forms' state outside the form (and its providers).
+
+### Single form state
+
+Use case: display a form's errors (or any other state) outside form and its context.
+
+```tsx
+<FormStateRelayContextProvider> // relay provider
+  <ReactHookForm.FormProvider>  // rhf provider
+    <FormStateRelayPusher />    // push form state
+  <ReactHookForm.FormProvider>
+
+  <WatchOutsideFormContext />   // watch form state
+</FormStateRelayContextProvider>;
+```
+
+Push can be configured via `FormStateRelayPusher` component or `useFormStateRelayPush` hook with `FormStateRelayPushOptions` options.
+
+```ts
+type FormStateRelayPushOptions = {
+  group?: string | string[]; // assign group(s) to watch multiple forms in aggregate
+  flaggedState?: {
+    isMounted?: true; // flag form when mounted -- e.g., forms that are hidden by default
+  };
+};
+```
+
+```tsx
+function WatchOutsideFormContext() {
+  // FormStateWithUtils (either via RHF -- when requested within form context -- or relay when not)
+  const formState = useFormStateWithUtilsViaRhfOrRelay();
+}
+
+// when watching a single form, original RHF FormState with generally-typed SafeFieldValues
+type FormStateRelayed = FormState<SafeFieldValues>;
+```
+
+The `useFormStateWithUtilsViaRhfOrRelay` hook uses `useFormStateRelayPullOnlyOrThrow` internally. It provides additional naivety when consumer doesn't know which context between RHF or Relay is present. (This is useful when building base components -- e.g., buttons -- which may exist outside of form context.)
+
+### Multiple forms
+
+Use cases:
+
+- disable parent form when ANY child is "flagged" (i.e., dirty)
+- disable ALL children when parent is "flagged" (i.e., submitting)
+- confirm navigation when ANY mounted form is "flagged" (i.e., dirty)
+
+```tsx
+function ParentForm() {
+  const childrenFormState = useFormStateRelayWatchGroup('children'); // FormStateRelayedAggregated
+
+  return (
+    <ReactHookForm.FormProvider>
+      <FormStateRelayPusher formId="parent" /> // pusher
+      <input type="submit" disabled={childrenFormState.isDirty} />
+    </ReactHookForm.FormProvider>
+  );
+}
+
+function ChildForm() {
+  const parentFormState = useFormStateRelayWatchId('parent'); // FormStateRelayed
+
+  return (
+    <ReactHookForm.FormProvider>
+      <FormStateRelayPusher group="children" /> // pusher
+      <input type="submit" disabled={parentFormState.isSubmitting} />
+    </ReactHookForm.FormProvider>
+  );
+}
+
+type FormStateRelayedAggregated = FormStateRelayed & {
+  // object values reduced to booleans for non-empty-ness
+  dirtyFields: boolean;
+  touchedFields: boolean;
+  validatingFields: boolean;
+  error: boolean;
+  // composites
+  isSubmitUnsuccessful: boolean;
+  isMountedFlagged: boolean; // via RelayedFormOptions['flaggedState']['isMounted']
+};
+```
+
+You can also aggregate any (i.e., all) forms via `useFormStateRelayPullAny`, which returns `FormStateRelayedAggregated` as well.
+
+```tsx
+<FormStateRelayContextProvider>
+  <ParentForm />
+  <ChildForm />
+  <Child2Form />
+</FormStateRelayContextProvider>
+```
+
 ## Field Errors
 
 ### FlatFieldErrors
@@ -402,32 +566,7 @@ _If you include the marker in bulk error lists, it will defeat the purpose of th
 
 ## Other Features
 
-### Form Groups _(0.7kB min+gzip)_
-
-Sometimes you need to group multiple forms together.
-
-Use case: disable parent form when any child is "busy"; disable all children when parent is "busy".
-
-Use `FormGroupContextProvider` to wrap your children and parent forms.
-
-```tsx
-<FormGroupContextProvider>
-  <ChildForm1 />
-  <ChildForm2 />
-  <ParentForm />
-</FormGroupContextProvider>
-```
-
-In your parent form, use the hook `useFormGroupParentTracker`, which returns `boolean` value indicating whether any child forms is busy.
-
-In children forms, there are two options. You can choose to consider form "busy" when:
-
-- `isSubmitting` is `true` by using `useFormGroupChildIsSubmittingTracker` hook
-- it is mounted by using `useFormGroupChildIsMountedTracker` hook
-
-Both hooks return `boolean` value indicating whether parent form is busy.
-
-### TRPC.io Utils _(0.4kB min+gzip)_
+### TRPC.io Utils _(0.41kB min+gzip)_
 
 #### `trpcClientErrorToFormSubmitFieldErrorsSchemaTransformer`
 

package/dist/dts/Register.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Use this to extend internal types.
+ *
+ * @example
+ * ```ts
+ * declare module '@paragrav/rhf-utils' {
+ *   export interface Register {
+ *     RhfUtilsFormOptions: {
+ *       myCustomOption?: boolean;
+ *     };
+ *   }
+ * }
+ * ```
+ */
+// eslint-disable-next-line @typescript-eslint/consistent-type-definitions, @typescript-eslint/no-empty-object-type
+export interface Register {}

package/dist/dts/_exports/config.d.ts

@@ -0,0 +1,2 @@
+export { RhfUtilsClientConfigProvider } from '../client/config/context/RhfUtilsClientConfigProvider';
+export type { RhfUtilsClientConfig } from '../client/config/RhfUtilsClientConfigType';

package/dist/dts/_exports/errors.d.ts

@@ -0,0 +1,3 @@
+export { useFlatFieldErrorsContext } from '../errors/flat/context/useFlatFieldErrorsContext';
+export { useFlatFieldErrorsContextHasOnlyOrphans } from '../errors/flat/context/useFlatFieldErrorsContextHasOnlyOrphans';
+export { RhfUtilsNonFieldErrorMarker } from '../errors/nonfield/RhfUtilsNonFieldErrorMarker';

package/dist/dts/_exports/form.d.ts

@@ -0,0 +1,7 @@
+export { useRhfUtilsContext } from '../form/context/utils/useRhfUtilsContext';
+export type { RhfUtilsFormOptions } from '../form/options/RhfUtilsFormOptionsType';
+export type { SafeFieldValues } from '../form/rhf/SafeFieldValuesType';
+export type { RHF_UseFormReturnWithoutProxies as UseFormReturnWithoutProxies } from '../form/RHF_UseFormReturnWithoutProxiesType';
+export type { RhfUtilsFormComponentProps } from '../form/RhfUtilsFormComponentPropsType';
+export type { UseRhfUtilsFormChildrenProps } from '../form/UseRhfUtilsFormChildrenPropsType';
+export { useFormRequestSubmit } from '../form/utils/useFormRequestSubmit';

package/dist/dts/_exports/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @license @paragrav/rhf-utils
+ *
+ * Copyright (c) 2024-present paragrav.dev
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+export * from './config';
+export * from './errors';
+export * from './form';
+export * from './submit';
+export * from './zod';

package/dist/dts/_exports/relay.d.ts

@@ -0,0 +1,8 @@
+export { FormStateRelayContextProvider } from '../form/state/relay/FormStateRelayContextProvider';
+export type { FormStateRelayedAggregated } from '../form/state/relay/FormStateRelayedAggregatedType';
+export type { FormStateRelayedItemWithUtils } from '../form/state/relay/FormStateRelayedItemType';
+export type { FormStateRelayedOptions } from '../form/state/relay/FormStateRelayedOptionsType';
+export type { FormStateRelayed } from '../form/state/relay/FormStateRelayedType';
+export { useFormStateRelayPullAny, useFormStateRelayPullById, useFormStateRelayPullGroup, useFormStateRelayPullOnlyOrThrow, useFormStateWithUtilsViaRhfOrRelay, } from '../form/state/relay/pull/hooks';
+export { FormStateRelayPusher } from '../form/state/relay/push/FormStateRelayPusher';
+export { useFormStateRelayPusher } from '../form/state/relay/push/useFormStateRelayPusher';

package/dist/dts/_exports/submit.d.ts

@@ -0,0 +1,4 @@
+export { FormSubmitError } from '../submit/error/FormSubmitError';
+export type { FormSubmitFieldErrors } from '../submit/error/FormSubmitFieldErrors';
+export { useLastSubmitError } from '../submit/last-error/useLastSubmitError';
+export type { UseRhfUtilsFormOnSubmitContext, UseRhfUtilsFormOnSubmitErrorContext, } from '../submit/UseRhfUtilsFormOnSubmitContextType';

package/dist/dts/_exports/trpc.d.ts

@@ -0,0 +1,2 @@
+export { makeOnSubmitTrpcClientErrorHandler } from '../errors/trpc/makeOnSubmitTrpcClientErrorHandler';
+export { trpcClientErrorToFormSubmitFieldErrorsSchemaTransformer } from '../errors/trpc/trpcClientErrorToFormSubmitFieldErrorsSchemaTransformer';

package/dist/dts/_exports/types.d.ts

@@ -0,0 +1,7 @@
+export type * from './errors';
+export type * from './form';
+export type * from './relay';
+export type * from './submit';
+export type * from './trpc';
+export type * from './zod';
+export type { Register } from '../Register';

package/dist/dts/_exports/zod.d.ts

@@ -0,0 +1,6 @@
+export { RhfUtilsZodForm } from '../resolvers/zod/form/RhfUtilsZodForm';
+export { RhfUtilsZodFormProviders } from '../resolvers/zod/providers/RhfUtilsZodFormProviders';
+export { RhfUtilsZodFormWithProviders } from '../resolvers/zod/with-providers/RhfUtilsZodFormWithProviders';
+export type { RhfUtilsUseZodFormChildrenFC } from '../resolvers/zod/RhfUtilsUseZodFormChildrenFCType';
+export type { RhfUtilsUseZodFormChildrenProps } from '../resolvers/zod/RhfUtilsUseZodFormChildrenPropsType';
+export type { ZodTypeSafeFieldValues } from '../resolvers/zod/ZodTypeSafeFieldValuesType';