@payfit/unity-components 0.0.0-alpha.6 → 0.0.0-alpha.7

package/dist/esm/components/text/Text.d.mts

@@ -80,5 +80,5 @@ declare const Text: import('react').ForwardRefExoticComponent<HTMLAttributes<HTM
     className?: string;
 } & {
     children?: import('react').ReactNode | undefined;
-} & import('react').RefAttributes<HTMLDivElement>>;
+} & import('react').RefAttributes<HTMLElement>>;
 export { Text };

package/dist/esm/components/text-area/TextArea.d.mts

@@ -0,0 +1,220 @@
+import { TextAreaProps as AriaTextAreaProps } from 'react-aria-components';
+export declare const textArea: import('tailwind-variants').TVReturnType<{
+    isInvalid: {
+        true: {
+            base: string;
+            inputWrapper: string;
+            input: string;
+            state: string;
+        };
+    };
+    isReadOnly: {
+        true: {
+            base: string;
+            inputWrapper: string;
+            input: string;
+        };
+    };
+    isDisabled: {
+        true: {
+            base: string;
+            inputWrapper: string;
+            input: string;
+        };
+    };
+}, {
+    base: string;
+    inputWrapper: string;
+    input: string;
+    state: string;
+    resizeHandle: string;
+}, undefined, import('tailwind-variants/dist/config').TVConfig<{
+    isInvalid: {
+        true: {
+            base: string;
+            inputWrapper: string;
+            input: string;
+            state: string;
+        };
+    };
+    isReadOnly: {
+        true: {
+            base: string;
+            inputWrapper: string;
+            input: string;
+        };
+    };
+    isDisabled: {
+        true: {
+            base: string;
+            inputWrapper: string;
+            input: string;
+        };
+    };
+}, {
+    isInvalid: {
+        true: {
+            base: string;
+            inputWrapper: string;
+            input: string;
+            state: string;
+        };
+    };
+    isReadOnly: {
+        true: {
+            base: string;
+            inputWrapper: string;
+            input: string;
+        };
+    };
+    isDisabled: {
+        true: {
+            base: string;
+            inputWrapper: string;
+            input: string;
+        };
+    };
+}>, {
+    isInvalid: {
+        true: {
+            base: string;
+            inputWrapper: string;
+            input: string;
+            state: string;
+        };
+    };
+    isReadOnly: {
+        true: {
+            base: string;
+            inputWrapper: string;
+            input: string;
+        };
+    };
+    isDisabled: {
+        true: {
+            base: string;
+            inputWrapper: string;
+            input: string;
+        };
+    };
+}, {
+    base: string;
+    inputWrapper: string;
+    input: string;
+    state: string;
+    resizeHandle: string;
+}, import('tailwind-variants').TVReturnType<{
+    isInvalid: {
+        true: {
+            base: string;
+            inputWrapper: string;
+            input: string;
+            state: string;
+        };
+    };
+    isReadOnly: {
+        true: {
+            base: string;
+            inputWrapper: string;
+            input: string;
+        };
+    };
+    isDisabled: {
+        true: {
+            base: string;
+            inputWrapper: string;
+            input: string;
+        };
+    };
+}, {
+    base: string;
+    inputWrapper: string;
+    input: string;
+    state: string;
+    resizeHandle: string;
+}, undefined, import('tailwind-variants/dist/config').TVConfig<{
+    isInvalid: {
+        true: {
+            base: string;
+            inputWrapper: string;
+            input: string;
+            state: string;
+        };
+    };
+    isReadOnly: {
+        true: {
+            base: string;
+            inputWrapper: string;
+            input: string;
+        };
+    };
+    isDisabled: {
+        true: {
+            base: string;
+            inputWrapper: string;
+            input: string;
+        };
+    };
+}, {
+    isInvalid: {
+        true: {
+            base: string;
+            inputWrapper: string;
+            input: string;
+            state: string;
+        };
+    };
+    isReadOnly: {
+        true: {
+            base: string;
+            inputWrapper: string;
+            input: string;
+        };
+    };
+    isDisabled: {
+        true: {
+            base: string;
+            inputWrapper: string;
+            input: string;
+        };
+    };
+}>, unknown, unknown, undefined>>;
+export interface TextAreaProps extends AriaTextAreaProps {
+    /** Whether the field is in an invalid state */
+    isInvalid?: boolean;
+    /** Whether the field is in a loading state */
+    isLoading?: boolean;
+    /** Whether the field is disabled */
+    isDisabled?: boolean;
+    /** Whether the field is read-only */
+    isReadOnly?: boolean;
+    /** Whether the textarea is resizable */
+    isResizable?: boolean;
+}
+/**
+ * The `TextArea` component displays a styled, single HTML `<textarea>` field that follows the Unity design system language. It supports multiple states out of the box and can be used as a controlled or uncontrolled component. It is also compatible with the `Form` and `FormField` component as a form control.
+ * @param {TextAreaProps} props - Regular props from the `<textarea>` HTML element, plus state-related props
+ * @see {@link TextAreaProps} for all available props
+ * @example
+ * ```tsx
+ * import { Input } from '@payfit/unity-components'
+ *
+ * function Example() {
+ *   const [value, setValue] = useState()
+ *
+ *   const handleTextChange = (e) => {
+ *     setValue(e.target.value)
+ *   }
+ *
+ *   return (
+ *    <TextArea
+ *      id="my-text-area"
+ *      isResizable cols={50} rows={5} onChange={handleTextChange}
+ *    >
+ *      {value}
+ *    </TextArea>
+ * }
+ * ```
+ */
+declare const TextArea: import('react').ForwardRefExoticComponent<TextAreaProps & import('react').RefAttributes<HTMLTextAreaElement>>;
+export { TextArea };

package/dist/esm/components/text-area/TextArea.mjs

@@ -0,0 +1,163 @@
+import { jsxs as r, jsx as e } from "react/jsx-runtime";
+import { forwardRef as v } from "react";
+import { TextArea as w } from "react-aria-components";
+import { useIntl as A } from "react-intl";
+import { tv as M } from "tailwind-variants";
+import { useResizable as z } from "../../hooks/use-resizable.mjs";
+import { Icon as L } from "../icon/Icon.mjs";
+import { Spinner as T } from "../spinner/Spinner.mjs";
+const D = M({
+  slots: {
+    base: "uy-flex uy-border uy-rounded-100 focus-within:uy-outline-none focus-within:uy-ring-2 focus-within:uy-ring-utility-focus-ring focus-within:uy-ring-offset-2 active:uy-border-border-form-active uy-overflow-hidden uy-relative",
+    inputWrapper: "uy-flex uy-gap-50 uy-flex-grow uy-pt-100 uy-pb-100 uy-pl-150 uy-pr-150 uy-rounded-100",
+    input: "uy-flex-grow uy-flex-shrink uy-outline-none uy-typography-body placeholder:uy-text-content-neutral-lowest uy-resize-none",
+    state: "uy-flex uy-gap-50 uy-flex-shrink-0 uy-basis-250",
+    resizeHandle: "uy-absolute uy-bottom-25 uy-right-25 uy-w-100 uy-h-100 uy-cursor-se-resize uy-flex uy-items-center uy-justify-center"
+  },
+  variants: {
+    isInvalid: {
+      true: {
+        base: "uy-border-border-form-error uy-bg-surface-form-error",
+        inputWrapper: "uy-bg-surface-form-error",
+        input: "uy-bg-surface-form-error",
+        state: "uy-text-content-form-error"
+      }
+    },
+    isReadOnly: {
+      true: {
+        base: "uy-border-border-form-disabled uy-bg-surface-form-disabled",
+        inputWrapper: "uy-border-border-form-disabled uy-bg-surface-form-disabled",
+        input: "uy-bg-surface-form-disabled uy-text-content-form-readonly"
+      }
+    },
+    isDisabled: {
+      true: {
+        base: "uy-border-border-form-disabled uy-bg-surface-form-disabled",
+        inputWrapper: "uy-bg-surface-form-disabled uy-text-content-form-disabled",
+        input: "uy-bg-surface-form-disabled uy-text-content-form-disabled"
+      }
+    }
+  },
+  compoundVariants: [
+    {
+      isInvalid: !1,
+      isDisabled: !1,
+      isReadOnly: !1,
+      className: {
+        base: "uy-border-border-form-enabled uy-bg-surface-form-enabled",
+        inputWrapper: "uy-border-border-form-enabled uy-bg-surface-form-enabled",
+        input: "uy-text-content-form-enabled uy-bg-surface-form-enabled",
+        state: "uy-text-content-neutral-disabled"
+      }
+    }
+  ],
+  defaultVariants: {
+    isInvalid: !1,
+    isDisabled: !1,
+    isReadOnly: !1
+  }
+}), N = v(
+  ({
+    isInvalid: n,
+    isLoading: s,
+    isDisabled: o,
+    isReadOnly: t,
+    isResizable: i = !1,
+    ...l
+  }, f) => {
+    const a = A(), { containerRef: d, handleResizeStart: m } = z({
+      isDisabled: !i || o || t
+    });
+    console.log("[TEXTAREA | userProps]", l), console.log("[TEXTAREA | ref]", f);
+    const { base: c, inputWrapper: p, input: g, state: x, resizeHandle: h } = D({
+      isInvalid: n,
+      isDisabled: o,
+      isReadOnly: t
+    });
+    return /* @__PURE__ */ r("div", { ref: d, className: c(), children: [
+      /* @__PURE__ */ r("div", { className: p(), children: [
+        /* @__PURE__ */ e(
+          w,
+          {
+            ...l,
+            ref: f,
+            className: g(),
+            "aria-busy": s
+          }
+        ),
+        /* @__PURE__ */ r("div", { className: x(), children: [
+          s && /* @__PURE__ */ e(
+            T,
+            {
+              color: "inherit",
+              size: "small",
+              label: a.formatMessage({
+                id: "unity:component:form-field:form-input:spinner:label",
+                defaultMessage: "Loading"
+              })
+            }
+          ),
+          n && /* @__PURE__ */ e(
+            L,
+            {
+              src: "WarningCircleOutlined",
+              color: "content.form.invalid",
+              alt: a.formatMessage({
+                id: "unity:component:form-field:form-input:error:alt",
+                defaultMessage: "Error"
+              })
+            }
+          )
+        ] })
+      ] }),
+      i && !o && !t && /* @__PURE__ */ e(
+        "div",
+        {
+          className: h(),
+          onMouseDown: m,
+          role: "button",
+          tabIndex: 0,
+          "aria-label": a.formatMessage({
+            id: "unity:component:form-field:textarea:resize-handle:label",
+            defaultMessage: "Resize textarea"
+          }),
+          onKeyDown: (u) => {
+            var y, b;
+            (u.key === "Enter" || u.key === " ") && (u.preventDefault(), (b = (y = d.current) == null ? void 0 : y.querySelector("textarea")) == null || b.focus());
+          },
+          children: /* @__PURE__ */ r(
+            "svg",
+            {
+              role: "presentation",
+              width: "8",
+              height: "8",
+              viewBox: "0 0 8 8",
+              fill: "none",
+              children: [
+                /* @__PURE__ */ e(
+                  "path",
+                  {
+                    d: "M0.72774 8L0 7.28745L7.27226 0L8 0.712547L0.72774 8Z",
+                    fill: "#8B8D98"
+                  }
+                ),
+                /* @__PURE__ */ e(
+                  "path",
+                  {
+                    d: "M4.73172 8L4 7.27073L7.26828 4L8 4.72927L4.73172 8Z",
+                    fill: "#8B8D98"
+                  }
+                )
+              ]
+            }
+          )
+        }
+      )
+    ] });
+  }
+);
+N.displayName = "TextArea";
+export {
+  N as TextArea,
+  D as textArea
+};

package/dist/esm/components/text-field/TextField.d.mts

@@ -0,0 +1,63 @@
+import { ForwardedRef, HTMLAttributes, JSX, ReactNode } from 'react';
+import { FieldPath, FieldValues } from 'react-hook-form';
+import { infer as ZodInfer } from 'zod';
+import { Schema } from '../../hooks/use-form.types.mjs';
+import { InputProps } from '../input/Input.mjs';
+import { LabelProps } from '../label/Label.mjs';
+import { TextAreaProps } from '../text-area/TextArea.mjs';
+interface FieldProps<TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>> extends Pick<LabelProps, 'isRequired' | 'requiredVariant'> {
+    /** The name of the field, which should match the form schema. */
+    name: TName;
+    /** The label for the text field. */
+    label: string;
+    /** If true, the text field will be a multi-line text area. */
+    multiline?: boolean;
+    /** The default value of the text field. */
+    defaultValue?: HTMLAttributes<HTMLInputElement>['defaultValue'];
+    /** Helper text to display below the text field. */
+    helperText?: ReactNode;
+    /** Feedback text to display below the text field. */
+    feedbackText?: ReactNode;
+    /** A contextual link to display below the text field. */
+    contextualLink?: ReactNode;
+}
+interface TextFieldWithInputProps<TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>> extends FieldProps<TFieldValues, TName>, Omit<InputProps, 'name'> {
+    multiline?: false;
+    type?: 'text' | 'password' | 'email' | 'tel' | 'url' | 'search';
+}
+interface TextFieldWithTextAreaProps<TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>> extends FieldProps<TFieldValues, TName>, Omit<TextAreaProps, 'name'> {
+    multiline?: true;
+    type?: never;
+}
+export type TextFieldProps<TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>> = TextFieldWithInputProps<TFieldValues, TName> | TextFieldWithTextAreaProps<TFieldValues, TName>;
+type TextFieldComponent = (<TSchema extends Schema>(props: TextFieldProps<ZodInfer<TSchema>> & {
+    ref?: ForwardedRef<HTMLInputElement | HTMLTextAreaElement>;
+}) => JSX.Element) & {
+    displayName?: string;
+};
+/**
+ * The `TextField` component renders a full field that can accept text input, supporting single-line and multi-line text fields, and integrates with the `Form` component automatically.
+ * @example
+ * ```tsx
+ * const schema = z.object({
+ *   name: z.string(),
+ *   email: z.string().email()
+ * })
+ *
+ * function MyForm() {
+ *   const { Form } = useUnityForm(schema)
+ *
+ *   return (
+ *     <Form action={handleSubmit}>
+ *       <TextField<typeof schema>
+ *         name="name"  // Only "name" | "email" allowed
+ *         label="Name"
+ *       />
+ *     </Form>
+ *   )
+ * }
+ * ```
+ * @note The schema type parameter is needed to ensure type safety with the form's schema. If you omit it, the `name` prop will not be type-safe.
+ */
+declare const TextField: TextFieldComponent;
+export { TextField };

package/dist/esm/components/text-field/TextField.mjs

@@ -0,0 +1,78 @@
+import { jsxs as B, jsx as o } from "react/jsx-runtime";
+import { forwardRef as I } from "react";
+import { useFormContext as g } from "react-hook-form";
+import { tv as j } from "tailwind-variants";
+import { FormField as k } from "../form-field/FormField.mjs";
+import { FormControl as L } from "../form-field/parts/FormControl.mjs";
+import { FormFeedbackText as N } from "../form-field/parts/FormFeedbackText.mjs";
+import { FormHelperText as P } from "../form-field/parts/FormHelperText.mjs";
+import { FormLabel as v } from "../form-field/parts/FormLabel.mjs";
+import { Input as w } from "../input/Input.mjs";
+import { TextArea as A } from "../text-area/TextArea.mjs";
+const H = j({
+  base: "uy-flex uy-flex-col uy-gap-100"
+});
+function R({
+  name: t,
+  label: e,
+  defaultValue: r,
+  helperText: m,
+  feedbackText: l,
+  contextualLink: c,
+  multiline: i,
+  isRequired: p,
+  isInvalid: a,
+  isLoading: f,
+  isDisabled: d,
+  isReadOnly: u,
+  requiredVariant: x,
+  ...n
+}, s) {
+  const { control: F, setValue: C } = g(), T = {
+    isRequired: p,
+    isInvalid: a,
+    isLoading: f,
+    isDisabled: d,
+    isReadOnly: u
+  }, h = !i, { onClearButtonPress: y } = h ? n : {}, b = y ?? (() => {
+    C(t, "");
+  });
+  return /* @__PURE__ */ B(
+    k,
+    {
+      control: F,
+      name: t,
+      className: H(),
+      ...T,
+      children: [
+        /* @__PURE__ */ o(v, { requiredVariant: x, children: e }),
+        m && /* @__PURE__ */ o(P, { children: m }),
+        /* @__PURE__ */ o(L, { children: i ? /* @__PURE__ */ o(
+          A,
+          {
+            ref: s,
+            defaultValue: r,
+            ...n
+          }
+        ) : /* @__PURE__ */ o(
+          w,
+          {
+            ref: s,
+            defaultValue: r,
+            onClearButtonPress: b,
+            ...n
+          }
+        ) }),
+        /* @__PURE__ */ o(N, { children: l }),
+        c
+      ]
+    }
+  );
+}
+const S = I(function(e, r) {
+  return R(e, r);
+});
+S.displayName = "TextField";
+export {
+  S as TextField
+};

package/dist/esm/components/toast/Toast.context.d.mts

@@ -3,6 +3,6 @@ type ToastContextValue = {
     inline: boolean;
 };
 export declare const ToastContext: import('react').Context<ToastContextValue>;
-export declare function ToastProvider({ inline, children, }: PropsWithChildren<ToastContextValue>): JSX.Element;
+export declare function ToastProvider({ inline, children, }: PropsWithChildren<ToastContextValue>): import("react/jsx-runtime").JSX.Element;
 export declare function useToastContext(): ToastContextValue;
 export {};

package/dist/esm/components/toast/ToastManager.d.mts

@@ -3,5 +3,5 @@ interface ToastOptions {
     duration: number;
 }
 declare const TOAST_CONFIG: Record<UnityToastProps['variant'], ToastOptions>;
-declare const ToastManager: () => JSX.Element;
+declare const ToastManager: () => import("react/jsx-runtime").JSX.Element;
 export { ToastManager, TOAST_CONFIG };

package/dist/esm/components/toast/UnityToast.d.mts

@@ -49,7 +49,7 @@ export interface UnityToastProps extends Required<Pick<VariantProps<typeof unity
  * - `ToastAction`(optional): The action on the toast
  */
 declare const UnityToast: {
-    ({ children, onClose, variant, inline, }: PropsWithChildren<UnityToastProps>): JSX.Element;
+    ({ children, onClose, variant, inline, }: PropsWithChildren<UnityToastProps>): import("react/jsx-runtime").JSX.Element;
     displayName: string;
 };
 export { UnityToast };

package/dist/esm/components/toast/parts/ToastAction.d.mts

@@ -2,7 +2,7 @@ import { PropsWithChildren } from 'react';
 export interface ToastActionProps {
     onPress: () => void;
 }
-declare function ToastAction({ children, onPress, }: PropsWithChildren<ToastActionProps>): JSX.Element;
+declare function ToastAction({ children, onPress, }: PropsWithChildren<ToastActionProps>): import("react/jsx-runtime").JSX.Element;
 declare namespace ToastAction {
     var displayName: string;
 }

package/dist/esm/components/toast/parts/ToastContent.d.mts

@@ -1,5 +1,5 @@
 import { PropsWithChildren } from 'react';
-declare function ToastContent({ children }: PropsWithChildren<object>): JSX.Element | null;
+declare function ToastContent({ children }: PropsWithChildren<object>): import("react/jsx-runtime").JSX.Element | null;
 declare namespace ToastContent {
     var displayName: string;
 }

package/dist/esm/components/toast/parts/ToastTitle.d.mts

@@ -1,5 +1,5 @@
 import { PropsWithChildren } from 'react';
-declare function ToastTitle({ children }: PropsWithChildren<object>): JSX.Element;
+declare function ToastTitle({ children }: PropsWithChildren<object>): import("react/jsx-runtime").JSX.Element;
 declare namespace ToastTitle {
     var displayName: string;
 }

package/dist/esm/components/tooltip/Tooltip.d.mts

@@ -3,5 +3,5 @@ interface TooltipProps {
     title: string;
     children: ReactElement;
 }
-declare function Tooltip({ title, children }: TooltipProps): JSX.Element;
+declare function Tooltip({ title, children }: TooltipProps): import("react/jsx-runtime").JSX.Element;
 export default Tooltip;

package/dist/esm/docs/blocks/Cards.d.mts

@@ -1,15 +1,15 @@
-import { default as React } from 'react';
-type CardProps = React.PropsWithChildren<unknown>;
+import { PropsWithChildren, default as React } from 'react';
+type CardProps = React.PropsWithChildren;
 export declare const Card: React.FC<CardProps>;
 export declare const CardWithCover: React.FC<CardProps & {
     coverSrc: string;
     coverAlt: string;
 }>;
-export declare const CardHeader: React.FC;
-export declare const CardTitle: React.FC;
-export declare const CardContent: React.FC;
-export declare const CardActions: React.FC;
-export declare const Link: React.FC<React.ComponentProps<"a">>;
+export declare const CardHeader: React.FC<PropsWithChildren>;
+export declare const CardTitle: React.FC<PropsWithChildren>;
+export declare const CardContent: React.FC<PropsWithChildren>;
+export declare const CardActions: React.FC<PropsWithChildren>;
+export declare const Link: React.FC<PropsWithChildren<React.ComponentProps<"a">>>;
 type CardGridProps = {
     children: React.ReactNode;
     cols?: number;

package/dist/esm/hooks/use-form.d.mts

@@ -1,4 +1,4 @@
-import { JSX } from 'react';
+import { JSX, PropsWithChildren } from 'react';
 import { UseFormProps as UseHookFormProps, UseFormReturn as UseHookFormReturn } from 'react-hook-form';
 import { infer as ZodInfer } from 'zod';
 import { FormFieldProps } from '../components/form-field/FormField.mjs';
@@ -7,12 +7,12 @@ import { Schema } from './use-form.types.mjs';
 export type UseUnityFormReturn<TSchema extends Schema> = {
     methods: UseHookFormReturn<ZodInfer<TSchema>>;
     Form: (props: Omit<FormProps<TSchema>, 'form' | 'schema'>) => JSX.Element;
-    FormField: (props: Omit<FormFieldProps<ZodInfer<TSchema>>, 'control'>) => JSX.Element;
+    FormField: (props: PropsWithChildren<Omit<FormFieldProps<ZodInfer<TSchema>>, 'control'>>) => JSX.Element;
 };
 /**
  * A hook to create `Form` and `FormField` components that are bound to a specific schema definition and form controller. The resulting components will have full type-safety based on the provided schema type.
- * @param schema {ZodObject} a Zod schema definition to validate the form data
- * @param options {UseHookFormProps} the options to pass to the `react-hook-form` hook. See the [official documentation](https://react-hook-form.com/api/useform) for more details.
+ * @param `schema` a Zod schema definition to validate the form data, {@link [Zod](https://zod.dev)}
+ * @param `options` the options to pass to the `react-hook-form` hook. See the official documentation for more details. {@link [React Hook Form](https://react-hook-form.com/api/useform)}
  * @returns an object containing the bounded  `Form` and `FormField` components, as well as the form controller methods {@link UseUnityFormReturn}
  * @example
  * ```tsx
@@ -35,7 +35,7 @@ export type UseUnityFormReturn<TSchema extends Schema> = {
  *        // ...
  *      </FormField>
  *      // Type Error: "baz" is not assignable to "foo" | "bar".
- *      <FormBield name="baz" type="text">
+ *      <FormField name="baz" type="text">
  *        // ...
  *      </FormField>
  *    </Form>

package/dist/esm/hooks/use-form.mjs

@@ -0,0 +1,32 @@
+import { jsx as t } from "react/jsx-runtime";
+import { useMemo as n } from "react";
+import { zodResolver as l } from "@hookform/resolvers/zod";
+import { useForm as c } from "react-hook-form";
+import { FormField as u } from "../components/form-field/FormField.mjs";
+import { Form as s } from "../components/form/Form.mjs";
+function v(m, i = {
+  mode: "onTouched",
+  reValidateMode: "onChange"
+}) {
+  const r = c({
+    ...i,
+    resolver: l(m)
+  }), d = n(() => {
+    const o = (e) => /* @__PURE__ */ t(s, { ...e, form: r, schema: m, children: e.children });
+    return o.displayName = "FormWithSchema", o;
+  }, [r, m]), F = n(() => {
+    const o = (e) => (
+      // @ts-expect-error: REACT-18-MIGRATION
+      /* @__PURE__ */ t(u, { ...e, control: r.control, children: e.children })
+    );
+    return o.displayName = "FormFieldWithSchema", o;
+  }, [r]);
+  return {
+    methods: r,
+    Form: d,
+    FormField: F
+  };
+}
+export {
+  v as useUnityForm
+};