@paragrav/rhf-utils 0.1.0 → 0.60.0

package/dist/dts/form/with-handlers-and-children/_useHandleSubmit.d.ts

@@ -0,0 +1,11 @@
+import { SubmitErrorHandler, SubmitHandler } from 'react-hook-form';
+import { MaybePromise } from '../../utils/types';
+import { SafeFieldValues } from '../rhf/SafeFieldValuesType';
+type Props<TFieldValues extends SafeFieldValues, TTransformedValues extends SafeFieldValues> = {
+    onValid: SubmitHandler<TTransformedValues>;
+    onInvalid?: SubmitErrorHandler<TFieldValues>;
+    onError: (error: unknown, event: React.BaseSyntheticEvent) => void;
+    onFinally?: () => MaybePromise<unknown>;
+};
+export declare const useRhfUtilsFormHandleSubmit_Internal: <TFieldValues extends SafeFieldValues, TTransformedValues extends SafeFieldValues>({ onValid, onInvalid, onError, onFinally, }: Props<TFieldValues, TTransformedValues>) => ((event: React.FormEvent<HTMLFormElement>) => void);
+export {};

package/dist/dts/form/with-providers/RhfUtilsFormWithProviders.d.ts

@@ -0,0 +1,8 @@
+import { SafeFieldValues } from '../rhf/SafeFieldValuesType';
+import { RhfUtilsFormPropsGetApiValues } from '../with-handlers-and-children/RhfUtilsFormProps';
+import { RhfUtilsFormWithProvidersProps } from './RhfUtilsFormWithProvidersProps';
+/**
+ * Form providers (with utils) with immediate descendent {@link RhfUtilsForm}.
+ * (Syntactic sugar for {@link useRhfUtilsForm}. Use this for most applications.)
+ */
+export declare function RhfUtilsFormWithProviders<TFieldValues extends SafeFieldValues, TTransformedValues extends SafeFieldValues, TGetApiValues extends undefined | RhfUtilsFormPropsGetApiValues<TTransformedValues, SafeFieldValues>, TOnSubmitReturnType, TApiValues extends undefined | SafeFieldValues = TGetApiValues extends RhfUtilsFormPropsGetApiValues<TTransformedValues, infer U> ? U : undefined>({ getApiData, resolver, rhf, defaultValues, options, onCancel, onSubmitInvalid, onBeforeSubmitInvariants, onBeforeSubmit, onSubmit, onSubmitSuccess, onSubmitError, onSubmitFinally, Children, form, formId, className, }: RhfUtilsFormWithProvidersProps<TFieldValues, TTransformedValues, TGetApiValues, TOnSubmitReturnType, TApiValues>): import("react/jsx-runtime").JSX.Element;

package/dist/dts/form/with-providers/RhfUtilsFormWithProvidersProps.d.ts

@@ -0,0 +1,4 @@
+import { RhfUtilsFormProvidersProps } from '../providers/RhfUtilsFormProvidersPropsType';
+import { SafeFieldValues } from '../rhf/SafeFieldValuesType';
+import { RhfUtilsFormProps, RhfUtilsFormPropsGetApiValues } from '../with-handlers-and-children/RhfUtilsFormProps';
+export type RhfUtilsFormWithProvidersProps<TFieldValues extends SafeFieldValues, TTransformedValues extends SafeFieldValues, TGetApiValues extends undefined | RhfUtilsFormPropsGetApiValues<TTransformedValues, SafeFieldValues>, TOnSubmitReturnType, TApiValues extends undefined | SafeFieldValues = TGetApiValues extends RhfUtilsFormPropsGetApiValues<TTransformedValues, infer U> ? U : undefined> = RhfUtilsFormProvidersProps<TFieldValues, TTransformedValues> & RhfUtilsFormProps<TFieldValues, TTransformedValues, TGetApiValues, TOnSubmitReturnType, TApiValues>;

package/dist/dts/resolvers/ObjectSchema.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Generic object schema type.
+ */
+export type ObjectSchema<
+  TInputKey extends string,
+  TOutputKey extends string,
+> = Record<TInputKey, SafeFieldValues> & Record<TOutputKey, SafeFieldValues>;

package/dist/dts/resolvers/zod/RhfUtilsUseZodFormChildrenFCType.d.ts

@@ -0,0 +1,7 @@
+import { default as React } from 'react';
+import { RhfUtilsUseZodFormChildrenProps } from './RhfUtilsUseZodFormChildrenPropsType';
+import { ZodTypeSafeFieldValues } from './ZodTypeSafeFieldValuesType';
+/**
+ * {@link React.FC} for {@link RhfUtilsUseZodFormChildrenProps}.
+ */
+export type RhfUtilsUseZodFormChildrenFC<TSchema extends ZodTypeSafeFieldValues, TChildrenProps = undefined> = React.FC<RhfUtilsUseZodFormChildrenProps<TSchema, TChildrenProps>>;

package/dist/dts/resolvers/zod/RhfUtilsUseZodFormChildrenPropsType.d.ts

@@ -0,0 +1,4 @@
+import { UseRhfUtilsFormChildrenProps } from '../../form/UseRhfUtilsFormChildrenPropsType';
+import { zodTypeInput, zodTypeOutput } from './consts';
+import { ZodTypeSafeFieldValues } from './ZodTypeSafeFieldValuesType';
+export type RhfUtilsUseZodFormChildrenProps<TSchema extends ZodTypeSafeFieldValues, TChildrenProps = undefined> = UseRhfUtilsFormChildrenProps<TSchema[typeof zodTypeInput], TSchema[typeof zodTypeOutput], TChildrenProps>;

package/dist/dts/resolvers/zod/ZodTypeSafeFieldValuesType.d.ts

@@ -0,0 +1,5 @@
+import { z } from 'zod';
+import { SafeFieldValues } from '../../form/rhf/SafeFieldValuesType';
+type ZodTypeOfSafeFieldValues = z.ZodType<SafeFieldValues, z.ZodObjectDef>;
+export type ZodTypeSafeFieldValues = ZodTypeOfSafeFieldValues | z.ZodEffects<ZodTypeOfSafeFieldValues>;
+export {};

package/dist/dts/resolvers/zod/consts.d.ts

@@ -0,0 +1,4 @@
+/** Schema key that returns input type. */
+export declare const zodTypeInput: "_input";
+/** Schema keys that returns output type. */
+export declare const zodTypeOutput: "_output";

package/dist/dts/resolvers/zod/form/RhfUtilsZodForm.d.ts

@@ -0,0 +1,7 @@
+import { SafeFieldValues } from '../../../form/rhf/SafeFieldValuesType';
+import { RhfUtilsFormProps, RhfUtilsFormPropsGetApiValues } from '../../../form/with-handlers-and-children/RhfUtilsFormProps';
+import { zodTypeInput, zodTypeOutput } from '../consts';
+import { ZodTypeSafeFieldValues } from '../ZodTypeSafeFieldValuesType';
+type Props<TSchema extends ZodTypeSafeFieldValues, TGetApiValues extends undefined | RhfUtilsFormPropsGetApiValues<TSchema[typeof zodTypeOutput], SafeFieldValues>, TOnSubmitReturnType, TApiValues extends undefined | SafeFieldValues = TGetApiValues extends RhfUtilsFormPropsGetApiValues<TSchema[typeof zodTypeOutput], infer U> ? U : undefined> = React.PropsWithChildren<RhfUtilsFormProps<TSchema[typeof zodTypeInput], TSchema[typeof zodTypeOutput], TGetApiValues, TOnSubmitReturnType, TApiValues>>;
+export declare const RhfUtilsZodForm: <TSchema extends ZodTypeSafeFieldValues, TGetApiValues extends undefined | RhfUtilsFormPropsGetApiValues<TSchema[typeof zodTypeOutput], SafeFieldValues>, TOnSubmitReturnType, TApiValues extends undefined | SafeFieldValues = TGetApiValues extends RhfUtilsFormPropsGetApiValues<TSchema[typeof zodTypeOutput], infer U> ? U : undefined>(props: Props<TSchema, TGetApiValues, TOnSubmitReturnType, TApiValues>) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/dts/resolvers/zod/getZodResolver.d.ts

@@ -0,0 +1,4 @@
+import { Resolver } from 'react-hook-form';
+import { zodTypeInput, zodTypeOutput } from './consts';
+import { ZodTypeSafeFieldValues } from './ZodTypeSafeFieldValuesType';
+export declare const getZodResolver: <TSchema extends ZodTypeSafeFieldValues, TFieldValues extends TSchema[typeof zodTypeInput], TTransformedValues extends TSchema[typeof zodTypeOutput]>(schema: TSchema) => Resolver<TFieldValues, unknown, TTransformedValues>;

package/dist/dts/resolvers/zod/providers/RhfUtilsZodFormProviders.d.ts

@@ -0,0 +1,8 @@
+import { RhfUtilsFormProvidersProps } from '../../../form/providers/RhfUtilsFormProvidersPropsType';
+import { zodTypeInput, zodTypeOutput } from '../consts';
+import { ZodTypeSafeFieldValues } from '../ZodTypeSafeFieldValuesType';
+type Props<TSchema extends ZodTypeSafeFieldValues> = React.PropsWithChildren<{
+    schema: TSchema;
+} & RhfUtilsFormProvidersProps<TSchema[typeof zodTypeInput], TSchema[typeof zodTypeOutput]>>;
+export declare const RhfUtilsZodFormProviders: <TSchema extends ZodTypeSafeFieldValues>({ schema, children, ...props }: Props<TSchema>) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/dts/resolvers/zod/with-providers/RhfUtilsZodFormWithProviders.d.ts

@@ -0,0 +1,10 @@
+import { RhfUtilsFormProvidersProps } from '../../../form/providers/RhfUtilsFormProvidersPropsType';
+import { SafeFieldValues } from '../../../form/rhf/SafeFieldValuesType';
+import { RhfUtilsFormProps, RhfUtilsFormPropsGetApiValues } from '../../../form/with-handlers-and-children/RhfUtilsFormProps';
+import { zodTypeInput, zodTypeOutput } from '../consts';
+import { ZodTypeSafeFieldValues } from '../ZodTypeSafeFieldValuesType';
+type Props<TSchema extends ZodTypeSafeFieldValues, TGetApiValues extends undefined | RhfUtilsFormPropsGetApiValues<TTransformedValues, SafeFieldValues>, TOnSubmitReturnType, TFieldValues extends TSchema[typeof zodTypeInput] = TSchema[typeof zodTypeInput], TTransformedValues extends TSchema[typeof zodTypeOutput] = TSchema[typeof zodTypeOutput], TApiValues extends undefined | SafeFieldValues = TGetApiValues extends RhfUtilsFormPropsGetApiValues<TTransformedValues, infer U> ? U : undefined> = React.PropsWithChildren<{
+    schema: TSchema;
+} & Omit<RhfUtilsFormProvidersProps<TFieldValues, TTransformedValues>, 'resolver'> & RhfUtilsFormProps<TFieldValues, TTransformedValues, TGetApiValues, TOnSubmitReturnType, TApiValues>>;
+export declare const RhfUtilsZodFormWithProviders: <TSchema extends ZodTypeSafeFieldValues, TGetApiValues extends undefined | RhfUtilsFormPropsGetApiValues<TTransformedValues, SafeFieldValues>, TOnSubmitReturnType, TFieldValues extends TSchema[typeof zodTypeInput] = TSchema[typeof zodTypeInput], TTransformedValues extends TSchema[typeof zodTypeOutput] = TSchema[typeof zodTypeOutput], TApiValues extends undefined | SafeFieldValues = TGetApiValues extends RhfUtilsFormPropsGetApiValues<TTransformedValues, infer U> ? U : undefined>({ schema, ...props }: Props<TSchema, TGetApiValues, TOnSubmitReturnType, TFieldValues, TTransformedValues, TApiValues>) => import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,23 @@
+import { UseFormReturn } from 'react-hook-form';
+import { FormSubmitError } from './error/FormSubmitError';
+import { FormSubmitFieldErrors } from './error/FormSubmitFieldErrors';
+import { RhfUtilsContextProps } from '../form/context/utils/RhfUtilsContextPropsType';
+import { SafeFieldValues } from '../form/rhf/SafeFieldValuesType';
+/**
+ * Props for onSubmit other than `data` and `event`.
+ *
+ * Consider keeping shape in line with `UseRhfUtilsFormChildrenProps` and `UseRhfUtilsFormReturn`.
+ */
+export type UseRhfUtilsFormOnSubmitContext<TFieldValues extends SafeFieldValues = SafeFieldValues, TTransformedValues extends SafeFieldValues = TFieldValues, TApiValues extends undefined | SafeFieldValues = undefined> = {
+    utils: RhfUtilsContextProps;
+    rhf: UseFormReturn<TFieldValues, unknown, TTransformedValues>;
+    FormSubmitError: typeof FormSubmitError<TFieldValues, TApiValues>;
+};
+/**
+ * Props for onSubmitError other than `error` and `event`.
+ */
+export type UseRhfUtilsFormOnSubmitErrorContext<TFieldValues extends SafeFieldValues, TTransformedValues extends SafeFieldValues> = {
+    utils: RhfUtilsContextProps;
+    rhf: UseFormReturn<TFieldValues, unknown, TTransformedValues>;
+    errors?: FormSubmitFieldErrors;
+};

package/dist/dts/submit/error/FormSubmitError.d.ts

@@ -0,0 +1,6 @@
+import { SafeFieldValues } from '../../form/rhf/SafeFieldValuesType';
+import { FormSubmitFieldErrors } from './FormSubmitFieldErrors';
+export declare class FormSubmitError<TFieldValues extends SafeFieldValues = SafeFieldValues, TApiValues extends undefined | SafeFieldValues = undefined, TAllValues extends SafeFieldValues = TApiValues extends undefined ? TFieldValues : TFieldValues | TApiValues> extends Error {
+    errors: FormSubmitFieldErrors<TAllValues>;
+    constructor(errors: FormSubmitFieldErrors<TAllValues>, message?: string);
+}

package/dist/{types → dts}/submit/error/FormSubmitFieldErrors.d.ts

@@ -1,5 +1,5 @@
 import { FieldPath } from 'react-hook-form';
-import { SafeFieldValues } from '../../form/SafeFieldValues';
+import { SafeFieldValues } from '../../form/rhf/SafeFieldValuesType';
 /**
  * Field errors structure based on RHF's `FieldErrors`.
  *

package/dist/dts/submit/error/setCtxErrorsByFormSubmitFieldErrors.d.ts

@@ -0,0 +1,8 @@
+import { SafeFieldValues } from '../../form/rhf/SafeFieldValuesType';
+import { RHF_UseFormReturnWithoutProxies } from '../../form/RHF_UseFormReturnWithoutProxiesType';
+import { FormSubmitFieldErrors } from './FormSubmitFieldErrors';
+/**
+ * Handle thrown {@link FormSubmitError}.
+ * Add key/values as name/message to RHF context errors.
+ */
+export declare const setCtxErrorsByFormSubmitFieldErrors: <TFieldValues extends SafeFieldValues, TTransformedValues extends SafeFieldValues>(ctx: RHF_UseFormReturnWithoutProxies<TFieldValues, TTransformedValues>, errors: FormSubmitFieldErrors) => void;

package/dist/dts/submit/last-error/LastSubmitErrorContextProvider.d.ts

@@ -0,0 +1,4 @@
+import { default as React } from 'react';
+type Props = React.PropsWithChildren;
+export declare const LastSubmitErrorContextProvider: React.FC<Props>;
+export {};

package/dist/dts/submit/last-error/LastSubmitErrorContextType.d.ts

@@ -0,0 +1,8 @@
+export type LastSubmitErrorContext = {
+    current: undefined | {
+        error: unknown;
+        event: React.BaseSyntheticEvent;
+    };
+    set: (error: unknown, event: React.BaseSyntheticEvent) => void;
+    reset: () => void;
+};

package/dist/dts/submit/last-error/useLastSubmitError.d.ts

@@ -0,0 +1,4 @@
+export declare const useLastSubmitError: () => {
+    error: unknown;
+    event: React.BaseSyntheticEvent;
+} | undefined;

package/dist/dts/submit/last-error/useLastSubmitErrorContext.d.ts

@@ -0,0 +1,3 @@
+import { LastSubmitErrorContext } from './LastSubmitErrorContextType';
+declare const _LastSubmitErrorContextProvider: import('react').Provider<LastSubmitErrorContext | undefined>, _useLastSubmitErrorContext: () => LastSubmitErrorContext;
+export { _LastSubmitErrorContextProvider, _useLastSubmitErrorContext };

package/dist/dts/submit/last-error/useLastSubmitErrorContextWith.d.ts

@@ -0,0 +1,2 @@
+import { MaybePromise } from '../../utils/types';
+export declare const useLastSubmitErrorContextWith: (handleSubmit: (event: React.FormEvent<HTMLFormElement>) => MaybePromise<unknown>) => (event: React.FormEvent<HTMLFormElement>) => Promise<unknown>;

package/dist/{types → dts}/submit/useFormOnSubmitSuccessfulAndReset.d.ts

@@ -10,5 +10,4 @@ import { MaybePromise } from '../utils/types';
  *
  * SubmitSuccessfulAndReset = was `isSubmitSuccessful` and now `!isDirty`
  */
-declare const useFormOnSubmitSuccessfulAndReset: (callback?: (...data: unknown[]) => MaybePromise<unknown>) => void;
-export default useFormOnSubmitSuccessfulAndReset;
+export declare const useFormOnSubmitSuccessfulAndReset: (callback?: (...data: unknown[]) => MaybePromise<unknown>) => void;

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

@@ -0,0 +1,4 @@
+import { MaybePromise } from '../utils/types';
+export declare const useFormOnSubmitted: (callback?: (success: boolean) => MaybePromise<unknown>, options?: {
+    successful?: boolean;
+}) => void;

package/dist/{types → dts}/submit/useResetFormOnSubmitted.d.ts

@@ -32,5 +32,4 @@ export type UseResetFormOnSubmittedOptions = undefined | {
  * See `Rules` section: https://react-hook-form.com/api/useform/reset/
  * Specifically: "- It's recommended to reset inside useEffect after submission."
  */
-declare const useResetFormOnSubmitted: (options: UseResetFormOnSubmittedOptions) => void;
-export default useResetFormOnSubmitted;
+export declare const useResetFormOnSubmitted: (options: UseResetFormOnSubmittedOptions) => void;

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

@@ -0,0 +1,3 @@
+import { SafeFieldValues } from '../form/rhf/SafeFieldValuesType';
+import { UseRhfUtilsFormOnSubmitContext } from './UseRhfUtilsFormOnSubmitContextType';
+export declare const useRhfUtilsFormOnSubmitContext: <TFieldValues extends SafeFieldValues = SafeFieldValues, TTransformedValues extends SafeFieldValues = TFieldValues>() => UseRhfUtilsFormOnSubmitContext<TFieldValues, TTransformedValues>;

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

@@ -0,0 +1,15 @@
+import { default as React } from 'react';
+/**
+ * Listens for "change" event on form. (Debounce via `options` param.)
+ *
+ * Caveats:
+ * - uses DOM "change" event listener on form element via ref
+ * - in some cases, event does not trigger until input loses focus
+ * - no RHF dependency
+ */
+export declare const useSubmitFormOnChange: (formRef: React.RefObject<HTMLFormElement | null>, options?: {
+    /** Disable behavior. (Default behavior is enabled for sake of simplicity of general usage.) */
+    disabled?: boolean;
+    /** Milliseconds to debounce form submission. (Default is none.) */
+    debounce?: number;
+}) => void;

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

@@ -0,0 +1,9 @@
+import { default as React } from 'react';
+export type UseSubmitFormOnEventDebouncedOptions = {
+    /** Milliseconds to debounce form submission. (Default is none.) */
+    debounce?: number;
+};
+/**
+ * Internal, shared hook to setup debounced callback for OnChange hooks.
+ */
+export declare const useSubmitFormOnEventDebounced: (formRef: React.RefObject<HTMLFormElement | null>, options?: UseSubmitFormOnEventDebouncedOptions) => (value: unknown) => void;

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

@@ -0,0 +1,14 @@
+import { default as React } from 'react';
+export type UseSubmitFormOnWatchOptions = {
+    /** Milliseconds to debounce form submission. (Default is none.) */
+    debounce: number;
+};
+/**
+ * Watches for changes in form values.
+ *
+ * Caveats:
+ * - uses RHF's useWatch
+ * - triggers change immediately as user types, so use sensible debounce time
+ * - does not cover uncontrolled inputs
+ */
+export declare const useSubmitFormOnWatch: (formRef: React.RefObject<HTMLFormElement | null>, options?: UseSubmitFormOnWatchOptions) => void;

package/dist/dts/utils/PassthroughChildren.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Component for passing-through children and ignoring props.
+ *
+ * Useful for conditional wrapping of children where conditional wrapper has props.
+ * (`React.Fragment` only allows `key` and `children`.)
+ */
+export declare const PassthroughChildren: React.FC<React.PropsWithChildren>;

package/dist/{types → dts}/utils/createContext.d.ts

@@ -3,9 +3,8 @@ import { default as React } from 'react';
  * Create a strictly-typed context that throws error if no provider is found.
  * @returns A tuple with a function to get the context and the context provider.
  */
-declare function createContext<T = unknown>(): {
+export declare function createContext<T = unknown>(): {
     readonly Provider: React.Provider<T | undefined>;
     readonly useMaybe: () => T | undefined;
     readonly useRequired: () => T & ({} | null);
 };
-export default createContext;

package/dist/dts/utils/fixedForwardRef.d.ts

@@ -0,0 +1,5 @@
+import { default as React } from 'react';
+/**
+ * @see https://www.totaltypescript.com/forwardref-with-generic-components
+ */
+export declare function fixedForwardRef<T, P = object>(render: React.ForwardRefRenderFunction<T, React.PropsWithoutRef<P>>): (props: P & React.RefAttributes<T>) => React.ReactNode;

package/dist/dts/utils/isEmptyObject.d.ts

@@ -0,0 +1 @@
+export declare const isEmptyObject: (obj: Record<string, unknown>) => boolean;

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

@@ -0,0 +1,3 @@
+export type MaybePromise<T> = T | Promise<T>;
+/** Merge {@link C} into {@link B} into {@link A} (last taking highest precedence). */
+export type Merge<A, B, C = unknown, D = unknown> = D & Omit<C, keyof D> & Omit<Omit<B, keyof C>, keyof D> & Omit<Omit<Omit<A, keyof B>, keyof C>, keyof D>;

package/dist/{types → dts}/utils/useImperativeForwardedRef.d.ts

@@ -6,5 +6,4 @@ import { default as React } from 'react';
  *
  * @param forwardedRef Forwarded `ref` prop.
  */
-declare const useImperativeForwardedRef: <TRef>(forwardedRef?: React.ForwardedRef<TRef>) => React.RefObject<TRef>;
-export default useImperativeForwardedRef;
+export declare const useImperativeForwardedRef: <TRef>(forwardedRef?: React.ForwardedRef<TRef>) => React.RefObject<TRef | null>;

package/dist/dts/utils/useIsFirstRender.d.ts

@@ -0,0 +1,7 @@
+import { default as React } from 'react';
+/**
+ * Use to determine if first render has run.
+ *
+ * (Supports strict mode.)
+ */
+export declare const useIsFirstRender: () => React.RefObject<boolean>;

package/dist/dts/utils/useRefIfValueWasTrue.d.ts

@@ -0,0 +1,2 @@
+import { default as React } from 'react';
+export declare const useRefIfValueWasTrue: (value: boolean) => readonly [React.RefObject<boolean>, () => void];

package/dist/dts/utils/useToggle.d.ts

@@ -0,0 +1,2 @@
+import { default as React } from 'react';
+export declare const useToggle: (defaultValue?: boolean) => [boolean, React.DispatchWithoutAction];

package/dist/dts/vite-env.d.ts

@@ -0,0 +1 @@
+/// <reference types="vite/client" />

package/dist/esm/getFlatFieldErrors.mjs

@@ -0,0 +1,55 @@
+import a from "react";
+import { get as c } from "react-hook-form";
+import { flatten as f } from "flat";
+function d() {
+  const e = a.createContext(void 0), r = () => a.useContext(e), s = () => {
+    const t = r();
+    if (t === void 0) throw new Error();
+    return t;
+  };
+  return {
+    Provider: e.Provider,
+    useMaybe: r,
+    useRequired: s
+  };
+}
+const {
+  Provider: x,
+  useRequired: g,
+  useMaybe: E
+} = d(), h = (e) => Object.keys(e).length === 0, u = (e) => f(e), b = (e) => {
+  const r = u(e), s = Object.keys(r);
+  return Object.fromEntries(
+    s.reduce(
+      (t, n) => {
+        const o = n.replace(
+          l,
+          ""
+        );
+        if (o === n) return t;
+        const i = c(e, o, void 0);
+        return i && t.push([o, i]), t;
+      },
+      []
+      // entries
+    )
+  );
+}, l = /\.(?:type|message)\b$/, v = (e) => Object.fromEntries(
+  Object.entries(b(e)).map(([r, s]) => [
+    r,
+    {
+      type: s.type,
+      message: s.message
+      // strip out ref, etc. (avoid circular JSON error)
+    }
+  ])
+);
+export {
+  x as _,
+  E as a,
+  v as b,
+  d as c,
+  b as g,
+  h as i,
+  g as u
+};