@tetherto/mdk-react-devkit 0.0.0 → 0.12.1

package/dist/primitives/components/form/form-utils.d.ts

@@ -0,0 +1,215 @@
+import { z } from 'zod';
+import type { FieldPath, FieldValues } from 'react-hook-form';
+/**
+ * Extract field names from a form schema with type safety.
+ * Useful for creating type-safe field name constants.
+ *
+ * @example
+ * ```tsx
+ * type FormValues = { email: string; password: string; nested: { field: string } }
+ * type FieldName = FieldName<FormValues> // 'email' | 'password' | 'nested' | 'nested.field'
+ * ```
+ */
+export type FieldName<TFieldValues extends FieldValues> = FieldPath<TFieldValues>;
+/**
+ * Create a type-safe field name accessor for a form schema.
+ * Prevents typos and provides autocomplete for field names.
+ *
+ * @example
+ * ```tsx
+ * const formSchema = z.object({
+ *   email: z.string(),
+ *   profile: z.object({
+ *     name: z.string(),
+ *   }),
+ * })
+ *
+ * type FormValues = z.infer<typeof formSchema>
+ * const fields = createFieldNames<FormValues>()
+ *
+ * // Usage in components - provides autocomplete and type safety
+ * <FormInput control={form.control} name={fields('email')} label="Email" />
+ * <FormInput control={form.control} name={fields('profile.name')} label="Name" />
+ * ```
+ */
+export declare const createFieldNames: <TFieldValues extends FieldValues>() => <TName extends FieldPath<TFieldValues>>(name: TName) => TName;
+/**
+ * Common validation schemas for frequently used form fields.
+ * Built with Zod for use with zodResolver.
+ */
+export declare const validators: {
+    /**
+     * Email validation with custom error message
+     */
+    email: (options?: {
+        required?: boolean;
+        message?: string;
+    }) => z.ZodOptional<z.ZodString> | z.ZodString;
+    /**
+     * Password validation with minimum length
+     */
+    password: (options?: {
+        minLength?: number;
+        message?: string;
+    }) => z.ZodString;
+    /**
+     * Username validation (alphanumeric with underscores/hyphens)
+     */
+    username: (options?: {
+        minLength?: number;
+        maxLength?: number;
+        message?: string;
+    }) => z.ZodString;
+    /**
+     * Phone number validation (basic format)
+     * Accepts formats: +1234567890, 1234567890, +1-234-567-8900, (123) 456-7890
+     * Requires at least 10 digits total
+     */
+    phone: (options?: {
+        required?: boolean;
+        message?: string;
+    }) => z.ZodOptional<z.ZodString> | z.ZodString;
+    /**
+     * URL validation
+     */
+    url: (options?: {
+        required?: boolean;
+        message?: string;
+    }) => z.ZodOptional<z.ZodString> | z.ZodString;
+    /**
+     * Required string with minimum length
+     */
+    requiredString: (options?: {
+        minLength?: number;
+        maxLength?: number;
+    }) => z.ZodString;
+    /**
+     * Optional string with maximum length
+     */
+    optionalString: (options?: {
+        maxLength?: number;
+    }) => z.ZodOptional<z.ZodString>;
+    /**
+     * Number within a range
+     */
+    number: (options?: {
+        min?: number;
+        max?: number;
+        message?: string;
+    }) => z.ZodNumber;
+    /**
+     * Boolean with required true (e.g., for terms acceptance)
+     */
+    requiredBoolean: (message?: string) => z.ZodLiteral<true>;
+    /**
+     * Date validation
+     */
+    date: (options?: {
+        min?: Date;
+        max?: Date;
+        required?: boolean;
+    }) => z.ZodDate | z.ZodOptional<z.ZodDate>;
+    /**
+     * Enum validation with custom error
+     */
+    enum: <T extends [string, ...string[]]>(values: T, message?: string) => z.ZodEnum<{ [k in T[number]]: k; } extends infer T_1 ? { [k in keyof T_1]: T_1[k]; } : never>;
+    /**
+     * MAC address validation
+     */
+    macAddress: (options?: {
+        required?: boolean;
+        message?: string;
+    }) => z.ZodOptional<z.ZodString> | z.ZodString;
+    /**
+     * IP address validation (IPv4)
+     */
+    ipAddress: (options?: {
+        required?: boolean;
+        message?: string;
+    }) => z.ZodOptional<z.ZodString> | z.ZodString;
+};
+/**
+ * Create a password confirmation schema that matches another password field.
+ *
+ * @example
+ * ```tsx
+ * const formSchema = z.object({
+ *   password: validators.password(),
+ *   confirmPassword: z.string(),
+ * }).refine(...createPasswordMatch('password', 'confirmPassword'))
+ * ```
+ */
+export declare const createPasswordMatch: (passwordField: string, confirmPasswordField: string, message?: string) => [(data: Record<string, unknown>) => boolean, {
+    message: string;
+    path: string[];
+}];
+/**
+ * Create a custom validation for date ranges (start date must be before end date).
+ *
+ * @example
+ * ```tsx
+ * const formSchema = z.object({
+ *   startDate: z.date(),
+ *   endDate: z.date(),
+ * }).refine(...createDateRange('startDate', 'endDate'))
+ * ```
+ */
+export declare const createDateRange: (startDateField: string, endDateField: string, message?: string) => [(data: Record<string, unknown>) => boolean, {
+    message: string;
+    path: string[];
+}];
+/**
+ * Create conditional validation where one field is required if another field has a specific value.
+ *
+ * @example
+ * ```tsx
+ * const formSchema = z.object({
+ *   type: z.enum(['email', 'phone']),
+ *   email: z.string().optional(),
+ *   phone: z.string().optional(),
+ * })
+ *   .refine(...createConditionalRequired('type', 'email', 'email', 'Email is required'))
+ *   .refine(...createConditionalRequired('type', 'phone', 'phone', 'Phone is required'))
+ * ```
+ */
+export declare const createConditionalRequired: (conditionField: string, conditionValue: unknown, requiredField: string, message: string) => [(data: Record<string, unknown>) => boolean, {
+    message: string;
+    path: string[];
+}];
+/**
+ * Pre-built schema for a login form
+ */
+export declare const loginSchema: z.ZodObject<{
+    email: z.ZodOptional<z.ZodString> | z.ZodString;
+    password: z.ZodString;
+    rememberMe: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+/**
+ * Pre-built schema for a registration form
+ */
+export declare const registerSchema: z.ZodObject<{
+    username: z.ZodString;
+    email: z.ZodOptional<z.ZodString> | z.ZodString;
+    password: z.ZodString;
+    confirmPassword: z.ZodString;
+    terms: z.ZodLiteral<true>;
+}, z.core.$strip>;
+/**
+ * Pre-built schema for a profile form
+ */
+export declare const profileSchema: z.ZodObject<{
+    username: z.ZodString;
+    email: z.ZodOptional<z.ZodString> | z.ZodString;
+    bio: z.ZodOptional<z.ZodString>;
+    phone: z.ZodOptional<z.ZodString> | z.ZodString;
+    website: z.ZodOptional<z.ZodString> | z.ZodString;
+}, z.core.$strip>;
+/**
+ * Pre-built schema for a contact form
+ */
+export declare const contactSchema: z.ZodObject<{
+    name: z.ZodString;
+    email: z.ZodOptional<z.ZodString> | z.ZodString;
+    subject: z.ZodString;
+    message: z.ZodString;
+}, z.core.$strip>;

package/dist/primitives/components/form/form-utils.js

@@ -0,0 +1,286 @@
+import { z } from 'zod';
+/**
+ * Create a type-safe field name accessor for a form schema.
+ * Prevents typos and provides autocomplete for field names.
+ *
+ * @example
+ * ```tsx
+ * const formSchema = z.object({
+ *   email: z.string(),
+ *   profile: z.object({
+ *     name: z.string(),
+ *   }),
+ * })
+ *
+ * type FormValues = z.infer<typeof formSchema>
+ * const fields = createFieldNames<FormValues>()
+ *
+ * // Usage in components - provides autocomplete and type safety
+ * <FormInput control={form.control} name={fields('email')} label="Email" />
+ * <FormInput control={form.control} name={fields('profile.name')} label="Name" />
+ * ```
+ */
+export const createFieldNames = () => {
+    return (name) => name;
+};
+// ─── Common Validation Schemas ───────────────────────────────────────────────
+/**
+ * Common validation schemas for frequently used form fields.
+ * Built with Zod for use with zodResolver.
+ */
+export const validators = {
+    /**
+     * Email validation with custom error message
+     */
+    email: (options) => options?.required === false
+        ? z
+            .string()
+            .email(options?.message ?? 'Please enter a valid email address')
+            .optional()
+        : z.string().email(options?.message ?? 'Please enter a valid email address'),
+    /**
+     * Password validation with minimum length
+     */
+    password: (options) => {
+        const minLength = options?.minLength ?? 8;
+        return z
+            .string()
+            .min(minLength, options?.message ?? `Password must be at least ${minLength} characters`);
+    },
+    /**
+     * Username validation (alphanumeric with underscores/hyphens)
+     */
+    username: (options) => {
+        const minLength = options?.minLength ?? 3;
+        const maxLength = options?.maxLength ?? 20;
+        return z
+            .string()
+            .min(minLength, `Username must be at least ${minLength} characters`)
+            .max(maxLength, `Username must not exceed ${maxLength} characters`)
+            .regex(/^[\w-]+$/, options?.message ?? 'Username can only contain letters, numbers, underscores, and hyphens');
+    },
+    /**
+     * Phone number validation (basic format)
+     * Accepts formats: +1234567890, 1234567890, +1-234-567-8900, (123) 456-7890
+     * Requires at least 10 digits total
+     */
+    phone: (options) => options?.required === false
+        ? z
+            .string()
+            .regex(/^\+?\(?\d{1,4}\)?[-.\s]?\d{1,4}[-.\s]?\d{1,4}[-.\s]?\d{1,9}$/, options?.message ?? 'Please enter a valid phone number')
+            .refine((val) => val.replace(/\D/g, '').length >= 10, options?.message ?? 'Phone number must contain at least 10 digits')
+            .optional()
+        : z
+            .string()
+            .regex(/^\+?\(?\d{1,4}\)?[-.\s]?\d{1,4}[-.\s]?\d{1,4}[-.\s]?\d{1,9}$/, options?.message ?? 'Please enter a valid phone number')
+            .refine((val) => val.replace(/\D/g, '').length >= 10, options?.message ?? 'Phone number must contain at least 10 digits'),
+    /**
+     * URL validation
+     */
+    url: (options) => options?.required === false
+        ? z
+            .string()
+            .url(options?.message ?? 'Please enter a valid URL')
+            .optional()
+        : z.string().url(options?.message ?? 'Please enter a valid URL'),
+    /**
+     * Required string with minimum length
+     */
+    requiredString: (options) => {
+        const minLength = options?.minLength ?? 1;
+        let schema = z.string().min(minLength, `This field must be at least ${minLength} characters`);
+        if (options?.maxLength) {
+            schema = schema.max(options.maxLength, `This field must not exceed ${options.maxLength} characters`);
+        }
+        return schema;
+    },
+    /**
+     * Optional string with maximum length
+     */
+    optionalString: (options) => {
+        let schema = z.string().optional();
+        if (options?.maxLength) {
+            schema = z
+                .string()
+                .max(options.maxLength, `This field must not exceed ${options.maxLength} characters`)
+                .optional();
+        }
+        return schema;
+    },
+    /**
+     * Number within a range
+     */
+    number: (options) => {
+        // A wrong type gets the custom message; a missing value keeps Zod's default.
+        let schema = z.number(options?.message
+            ? { error: (issue) => (issue.input === undefined ? undefined : options.message) }
+            : undefined);
+        if (options?.min !== undefined) {
+            schema = schema.min(options.min, `Value must be at least ${options.min}`);
+        }
+        if (options?.max !== undefined) {
+            schema = schema.max(options.max, `Value must not exceed ${options.max}`);
+        }
+        return schema;
+    },
+    /**
+     * Boolean with required true (e.g., for terms acceptance)
+     */
+    requiredBoolean: (message = 'This field is required') => z.literal(true, { error: message }),
+    /**
+     * Date validation
+     */
+    date: (options) => {
+        let schema = z.date(options?.required === false
+            ? undefined
+            : { error: (issue) => (issue.input === undefined ? 'Please select a date' : undefined) });
+        if (options?.min) {
+            schema = schema.min(options.min, `Date must be after ${options.min.toLocaleDateString()}`);
+        }
+        if (options?.max) {
+            schema = schema.max(options.max, `Date must be before ${options.max.toLocaleDateString()}`);
+        }
+        return options?.required === false ? schema.optional() : schema;
+    },
+    /**
+     * Enum validation with custom error
+     */
+    enum: (values, message = 'Please select a valid option') => z.enum(values, { error: (issue) => (issue.input === undefined ? message : undefined) }),
+    /**
+     * MAC address validation
+     */
+    macAddress: (options) => options?.required === false
+        ? z
+            .string()
+            .regex(/^([0-9A-F]{2}[:-]){5}([0-9A-F]{2})$/i, options?.message ?? 'Please enter a valid MAC address (e.g., 00:11:22:33:44:55)')
+            .optional()
+        : z
+            .string()
+            .regex(/^([0-9A-F]{2}[:-]){5}([0-9A-F]{2})$/i, options?.message ?? 'Please enter a valid MAC address (e.g., 00:11:22:33:44:55)'),
+    /**
+     * IP address validation (IPv4)
+     */
+    ipAddress: (options) => options?.required === false
+        ? z
+            .string()
+            .regex(/^(?:(?:25[0-5]|2[0-4]\d|[01]?\d{1,2})\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d{1,2})$/, options?.message ?? 'Please enter a valid IP address')
+            .optional()
+        : z
+            .string()
+            .regex(/^(?:(?:25[0-5]|2[0-4]\d|[01]?\d{1,2})\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d{1,2})$/, options?.message ?? 'Please enter a valid IP address'),
+};
+// ─── Validation Helpers ──────────────────────────────────────────────────────
+/**
+ * Create a password confirmation schema that matches another password field.
+ *
+ * @example
+ * ```tsx
+ * const formSchema = z.object({
+ *   password: validators.password(),
+ *   confirmPassword: z.string(),
+ * }).refine(...createPasswordMatch('password', 'confirmPassword'))
+ * ```
+ */
+export const createPasswordMatch = (passwordField, confirmPasswordField, message = 'Passwords do not match') => {
+    return [
+        (data) => data[passwordField] === data[confirmPasswordField],
+        {
+            message,
+            path: [confirmPasswordField],
+        },
+    ];
+};
+/**
+ * Create a custom validation for date ranges (start date must be before end date).
+ *
+ * @example
+ * ```tsx
+ * const formSchema = z.object({
+ *   startDate: z.date(),
+ *   endDate: z.date(),
+ * }).refine(...createDateRange('startDate', 'endDate'))
+ * ```
+ */
+export const createDateRange = (startDateField, endDateField, message = 'End date must be after start date') => {
+    return [
+        (data) => {
+            const start = data[startDateField];
+            const end = data[endDateField];
+            if (!start || !end)
+                return true;
+            return start < end;
+        },
+        {
+            message,
+            path: [endDateField],
+        },
+    ];
+};
+/**
+ * Create conditional validation where one field is required if another field has a specific value.
+ *
+ * @example
+ * ```tsx
+ * const formSchema = z.object({
+ *   type: z.enum(['email', 'phone']),
+ *   email: z.string().optional(),
+ *   phone: z.string().optional(),
+ * })
+ *   .refine(...createConditionalRequired('type', 'email', 'email', 'Email is required'))
+ *   .refine(...createConditionalRequired('type', 'phone', 'phone', 'Phone is required'))
+ * ```
+ */
+export const createConditionalRequired = (conditionField, conditionValue, requiredField, message) => {
+    return [
+        (data) => {
+            if (data[conditionField] === conditionValue) {
+                return !!data[requiredField];
+            }
+            return true;
+        },
+        {
+            message,
+            path: [requiredField],
+        },
+    ];
+};
+// ─── Common Schema Presets ───────────────────────────────────────────────────
+/**
+ * Pre-built schema for a login form
+ */
+export const loginSchema = z.object({
+    email: validators.email(),
+    password: validators.password(),
+    rememberMe: z.boolean().default(false),
+});
+/**
+ * Pre-built schema for a registration form
+ */
+export const registerSchema = z
+    .object({
+    username: validators.username(),
+    email: validators.email(),
+    password: validators.password(),
+    confirmPassword: z.string(),
+    terms: validators.requiredBoolean('You must accept the terms and conditions'),
+})
+    .refine(...createPasswordMatch('password', 'confirmPassword'));
+/**
+ * Pre-built schema for a profile form
+ */
+export const profileSchema = z.object({
+    username: validators.username(),
+    email: validators.email(),
+    bio: validators.optionalString({ maxLength: 200 }),
+    phone: validators.phone({ required: false }),
+    website: validators.url({ required: false }),
+});
+/**
+ * Pre-built schema for a contact form
+ */
+export const contactSchema = z.object({
+    name: validators.requiredString({ minLength: 2 }),
+    email: validators.email(),
+    subject: validators.requiredString({ minLength: 5, maxLength: 100 }),
+    message: validators.requiredString({ minLength: 10, maxLength: 1000 }),
+});

package/dist/primitives/components/form/form.example.d.ts

@@ -0,0 +1 @@
+export declare const FormExample: () => import("react").JSX.Element;

package/dist/primitives/components/form/form.example.js

@@ -0,0 +1,23 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * Runnable example for Form (react-hook-form + zod).
+ */
+import { zodResolver } from '@hookform/resolvers/zod';
+import { useForm } from 'react-hook-form';
+import { z } from 'zod';
+import { Button, Form, FormControl, FormField, FormItem, FormLabel, FormMessage, Input, } from '@tetherto/mdk-react-devkit';
+const schema = z.object({
+    name: z.string().min(2, 'At least 2 characters'),
+    email: z.string().email('Must be a valid email'),
+});
+export const FormExample = () => {
+    const form = useForm({
+        resolver: zodResolver(schema),
+        defaultValues: { name: '', email: '' },
+    });
+    const onSubmit = (values) => {
+        // oxlint-disable-next-line no-console
+        console.log('submit', values);
+    };
+    return (_jsxs(Form, { form: form, onSubmit: form.handleSubmit(onSubmit), children: [_jsx(FormField, { control: form.control, name: "name", render: ({ field }) => (_jsxs(FormItem, { children: [_jsx(FormLabel, { children: "Name" }), _jsx(FormControl, { children: _jsx(Input, { placeholder: "Operator name", ...field }) }), _jsx(FormMessage, {})] })) }), _jsx(FormField, { control: form.control, name: "email", render: ({ field }) => (_jsxs(FormItem, { children: [_jsx(FormLabel, { children: "Email" }), _jsx(FormControl, { children: _jsx(Input, { placeholder: "ops@example.com", ...field }) }), _jsx(FormMessage, {})] })) }), _jsx(Button, { type: "submit", variant: "primary", children: "Submit" })] }));
+};

package/dist/primitives/components/form/index.d.ts

@@ -0,0 +1,116 @@
+import type { ControllerProps, FieldError, FieldPath, FieldValues, UseFormReturn } from 'react-hook-form';
+import { type ComponentProps, type JSX, type ReactNode } from 'react';
+/**
+ * Hook to access the current form field's state and generated IDs.
+ * Must be used inside a `<FormField>` and `<FormItem>`.
+ */
+type UseFormFieldReturn = {
+    id: string;
+    name: string;
+    formItemId: string;
+    formDescriptionId: string;
+    formMessageId: string;
+    invalid: boolean;
+    isDirty: boolean;
+    isTouched: boolean;
+    isValidating: boolean;
+    error?: FieldError;
+};
+/**
+ * Read-only context hook for form field children — returns the field's id, error state, and ARIA attributes.
+ *
+ * @category forms
+ * @domain generic
+ * @tier agent-ready
+ */
+declare const useFormField: () => UseFormFieldReturn;
+/**
+ * Form wrapper that provides react-hook-form context to child components.
+ *
+ * @example
+ * ```tsx
+ * const form = useForm({ resolver: zodResolver(schema) })
+ *
+ * <Form form={form} onSubmit={form.handleSubmit(onSubmit)}>
+ *   <FormField control={form.control} name="email" render={({ field }) => (
+ *     <FormItem>
+ *       <FormLabel>Email</FormLabel>
+ *       <FormControl><Input {...field} /></FormControl>
+ *       <FormMessage />
+ *     </FormItem>
+ *   )} />
+ * </Form>
+ * ```
+ */
+type FormProps<TFieldValues extends FieldValues = FieldValues> = Omit<ComponentProps<'form'>, 'children'> & {
+    form: UseFormReturn<TFieldValues>;
+    children: ReactNode;
+};
+/**
+ * React Hook Form provider wrapper. Pass the result of `useForm()` as
+ * `form` and render fields via `FormField` / `FormItem` / `FormLabel` /
+ * `FormControl` / `FormMessage`.
+ *
+ * @category forms
+ * @domain generic
+ * @tier agent-ready
+ */
+declare const Form: <TFieldValues extends FieldValues = FieldValues>({ form, children, className, ...props }: FormProps<TFieldValues>) => JSX.Element;
+/**
+ * Wraps react-hook-form's Controller and provides field context to descendants.
+ * @category forms
+ * @domain generic
+ * @tier agent-ready
+ */
+declare const FormField: <TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>>({ ...props }: ControllerProps<TFieldValues, TName>) => JSX.Element;
+/**
+ * Layout wrapper for a form field. Generates a unique ID for accessibility linking.
+ * @category forms
+ * @domain generic
+ * @tier agent-ready
+ */
+declare const FormItem: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+/**
+ * Label that auto-links to the form field input via generated IDs.
+ * Applies error styling when the field has a validation error.
+ * @category forms
+ * @domain generic
+ * @tier agent-ready
+ */
+declare const FormLabel: import("react").ForwardRefExoticComponent<Omit<Omit<import("@radix-ui/react-label").LabelProps & import("react").RefAttributes<HTMLLabelElement>, "ref"> & {
+    htmlFor?: string | undefined;
+} & import("react").RefAttributes<HTMLLabelElement>, "ref"> & import("react").RefAttributes<HTMLLabelElement>>;
+/**
+ * Slot-based wrapper that injects ARIA attributes onto its child input element
+ * without adding an extra DOM wrapper.
+ * @category forms
+ * @domain generic
+ * @tier agent-ready
+ */
+declare const FormControl: import("react").ForwardRefExoticComponent<Omit<import("react").HTMLAttributes<HTMLElement> & {
+    children?: React.ReactNode;
+} & import("react").RefAttributes<HTMLElement>, "ref"> & import("react").RefAttributes<HTMLElement>>;
+/**
+ * Optional helper text displayed below the input.
+ * @category forms
+ * @domain generic
+ * @tier agent-ready
+ */
+declare const FormDescription: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLParagraphElement>, HTMLParagraphElement>, "ref"> & import("react").RefAttributes<HTMLParagraphElement>>;
+/**
+ * Displays the validation error message from react-hook-form field state.
+ * Falls back to children if no error is present.
+ * Always renders to prevent layout shift when errors appear.
+ * @category forms
+ * @domain generic
+ * @tier agent-ready
+ */
+declare const FormMessage: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLParagraphElement>, HTMLParagraphElement>, "ref"> & import("react").RefAttributes<HTMLParagraphElement>>;
+export { Form, FormControl, FormDescription, FormField, FormItem, FormLabel, FormMessage, useFormField, };
+export type { FormProps, UseFormFieldReturn };
+export { FormCascader, FormCheckbox, FormDatePicker, FormInput, FormRadioGroup, FormSelect, FormSwitch, FormTagInput, FormTextArea, } from './form-fields';
+export type { FormCascaderProps, FormCheckboxProps, FormDatePickerProps, FormInputProps, FormRadioGroupProps, FormRadioOption, FormSelectOption, FormSelectProps, FormSwitchProps, FormTagInputProps, FormTextAreaProps, } from './form-fields';
+export { useFormReset } from './form-hooks';
+export type { UseFormResetOptions, UseFormResetReturn } from './form-hooks';
+export { contactSchema, createConditionalRequired, createDateRange, createFieldNames, createPasswordMatch, loginSchema, profileSchema, registerSchema, validators, } from './form-utils';
+export type { FieldName } from './form-utils';