@wix/site-ui 1.30.0 → 1.31.0

package/dist/Fieldset/index.d.ts

@@ -1,17 +1,106 @@
-import { FieldsetLegendProps } from '@base-ui/react/fieldset';
-import { FieldsetRootProps } from '@base-ui/react/fieldset';
+import { FieldsetLegendProps as FieldsetLegendProps_2 } from '@base-ui/react/fieldset';
+import { FieldsetRootProps as FieldsetRootProps_2 } from '@base-ui/react/fieldset';
 import * as React_2 from 'react';
 
+/**
+ * Props shared by all Base UI components.
+ * Contains `className` (string or callback taking the component's state as an argument) and `render` (function to customize rendering).
+ */
+declare type BaseUIComponentProps<ElementType extends React_2.ElementType, State, RenderFunctionProps = HTMLProps> = Omit<WithBaseUIEvent<React_2.ComponentPropsWithRef<ElementType>>, 'className' | 'color' | 'defaultValue' | 'defaultChecked' | 'style'> & {
+    /**
+     * CSS class applied to the element, or a function that
+     * returns a class based on the component's state.
+     */
+    className?: string | ((state: State) => string | undefined) | undefined;
+    /**
+     * Allows you to replace the component's HTML element
+     * with a different tag, or compose it with another component.
+     *
+     * Accepts a `ReactElement` or a function that returns the element to render.
+     */
+    render?: React_2.ReactElement | ComponentRenderFn<RenderFunctionProps, State> | undefined;
+    /**
+     * Style applied to the element, or a function that
+     * returns a style object based on the component's state.
+     */
+    style?: React_2.CSSProperties | ((state: State) => React_2.CSSProperties | undefined) | undefined;
+};
+
+declare type BaseUIEvent<E extends React_2.SyntheticEvent<Element, Event>> = E & {
+    preventBaseUIHandler: () => void;
+    readonly baseUIHandlerPrevented?: boolean | undefined;
+};
+
+/**
+ * Shape of the render prop: a function that takes props to be spread on the element and component's state and returns a React element.
+ *
+ * @template Props Props to be spread on the rendered element.
+ * @template State Component's internal state.
+ */
+declare type ComponentRenderFn<Props, State> = (props: Props, state: State) => React_2.ReactElement<unknown>;
+
 export declare const Fieldset: {
-    Root: React_2.ForwardRefExoticComponent<Omit<Omit<Omit<FieldsetRootProps, "ref"> & React_2.RefAttributes<HTMLElement>, "ref">, "className"> & {
+    Root: React_2.ForwardRefExoticComponent<Omit<Omit<Omit<FieldsetRootProps_2, "ref"> & React_2.RefAttributes<HTMLElement>, "ref">, "className"> & {
         className?: string | undefined;
     } & React_2.RefAttributes<HTMLElement>>;
-    Legend: React_2.ForwardRefExoticComponent<Omit<Omit<Omit<FieldsetLegendProps, "ref"> & React_2.RefAttributes<HTMLDivElement>, "ref">, "className"> & {
+    Legend: React_2.ForwardRefExoticComponent<Omit<Omit<Omit<FieldsetLegendProps_2, "ref"> & React_2.RefAttributes<HTMLDivElement>, "ref">, "className"> & {
         className?: string | undefined;
     } & React_2.RefAttributes<HTMLDivElement>>;
 };
 
+/**
+ * An accessible label that is automatically associated with the fieldset.
+ * Renders a `<div>` element.
+ *
+ * Documentation: [Base UI Fieldset](https://base-ui.com/react/components/fieldset)
+ */
+export declare const FieldsetLegend: React_2.ForwardRefExoticComponent<Omit<FieldsetLegendProps, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare namespace FieldsetLegend {
+    export type State = FieldsetLegendState;
+    export type Props = FieldsetLegendProps;
+}
+
+export declare interface FieldsetLegendProps extends BaseUIComponentProps<'div', FieldsetLegendState> {}
+
+export declare interface FieldsetLegendState {
+    /**
+     * Whether the component should ignore user interaction.
+     */
+    disabled: boolean;
+}
+
+/**
+ * Groups a shared legend with related controls.
+ * Renders a `<fieldset>` element.
+ *
+ * Documentation: [Base UI Fieldset](https://base-ui.com/react/components/fieldset)
+ */
+export declare const FieldsetRoot: React_2.ForwardRefExoticComponent<Omit<FieldsetRootProps, "ref"> & React_2.RefAttributes<HTMLElement>>;
+
+export declare namespace FieldsetRoot {
+    export type State = FieldsetRootState;
+    export type Props = FieldsetRootProps;
+}
+
+export declare interface FieldsetRootProps extends BaseUIComponentProps<'fieldset', FieldsetRootState> {}
+
+export declare interface FieldsetRootState {
+    /**
+     * Whether the component should ignore user interaction.
+     */
+    disabled: boolean;
+}
+
+declare type HTMLProps<T = any> = React_2.HTMLAttributes<T> & {
+    ref?: React_2.Ref<T> | undefined;
+};
+
+/**
+ * Adds a `preventBaseUIHandler` method to all event handlers.
+ */
+declare type WithBaseUIEvent<T> = { [K in keyof T]: WithPreventBaseUIHandler<T[K]> };
 
-export * from "@base-ui/react/fieldset";
+declare type WithPreventBaseUIHandler<T> = T extends ((event: infer E) => any) ? E extends React_2.SyntheticEvent<Element, Event> ? (event: BaseUIEvent<E>) => ReturnType<T> : T : T extends undefined ? undefined : T;
 
 export { }

package/dist/Fieldset/index.js

@@ -1,22 +1,85 @@
 import { jsx } from "react/jsx-runtime";
-import { Fieldset } from "@base-ui/react/fieldset";
 import clsx from "clsx";
+import { useRenderElement } from "../8272.js";
+import { FieldsetRootContext, useFieldsetRootContext } from "../353.js";
+import { useBaseUiId } from "../6046.js";
+import { useIsoLayoutEffect } from "../6499.js";
 import * as __rspack_external_react from "react";
+const FieldsetRoot_FieldsetRoot = /*#__PURE__*/ __rspack_external_react.forwardRef(function(componentProps, forwardedRef) {
+    const { render, className, style, disabled = false, ...elementProps } = componentProps;
+    const [legendId, setLegendId] = __rspack_external_react.useState(void 0);
+    const state = {
+        disabled
+    };
+    const element = useRenderElement('fieldset', componentProps, {
+        ref: forwardedRef,
+        state,
+        props: [
+            {
+                'aria-labelledby': legendId
+            },
+            elementProps
+        ]
+    });
+    const contextValue = __rspack_external_react.useMemo(()=>({
+            legendId,
+            setLegendId,
+            disabled
+        }), [
+        legendId,
+        setLegendId,
+        disabled
+    ]);
+    return /*#__PURE__*/ jsx(FieldsetRootContext.Provider, {
+        value: contextValue,
+        children: element
+    });
+});
+if ("production" !== process.env.NODE_ENV) FieldsetRoot_FieldsetRoot.displayName = "FieldsetRoot";
+const FieldsetLegend_FieldsetLegend = /*#__PURE__*/ __rspack_external_react.forwardRef(function(componentProps, forwardedRef) {
+    const { render, className, style, id: idProp, ...elementProps } = componentProps;
+    const { disabled, setLegendId } = useFieldsetRootContext();
+    const id = useBaseUiId(idProp);
+    useIsoLayoutEffect(()=>{
+        setLegendId(id);
+        return ()=>{
+            setLegendId(void 0);
+        };
+    }, [
+        setLegendId,
+        id
+    ]);
+    const state = {
+        disabled: disabled ?? false
+    };
+    const element = useRenderElement('div', componentProps, {
+        state,
+        ref: forwardedRef,
+        props: [
+            {
+                id
+            },
+            elementProps
+        ]
+    });
+    return element;
+});
+if ("production" !== process.env.NODE_ENV) FieldsetLegend_FieldsetLegend.displayName = "FieldsetLegend";
 const Fieldset_module = {
     root: "root-v8M2Sx"
 };
-const Root = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(Fieldset.Root, {
+const Root = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(FieldsetRoot_FieldsetRoot, {
         ref: ref,
         className: clsx(Fieldset_module.root, className),
         ...props
     }));
-const Legend = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(Fieldset.Legend, {
+const Legend = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(FieldsetLegend_FieldsetLegend, {
         ref: ref,
         className: clsx(Fieldset_module.legend, className),
         ...props
     }));
-const Fieldset_Fieldset = {
+const Fieldset = {
     Root: Root,
     Legend: Legend
 };
-export { Fieldset_Fieldset as Fieldset };
+export { Fieldset };

package/dist/Form/index.d.ts

@@ -1,13 +1,342 @@
-import { Form as Form_2 } from '@base-ui/react/form';
 import * as React_2 from 'react';
 
+/**
+ * Props shared by all Base UI components.
+ * Contains `className` (string or callback taking the component's state as an argument) and `render` (function to customize rendering).
+ */
+declare type BaseUIComponentProps<ElementType extends React_2.ElementType, State, RenderFunctionProps = HTMLProps> = Omit<WithBaseUIEvent<React_2.ComponentPropsWithRef<ElementType>>, 'className' | 'color' | 'defaultValue' | 'defaultChecked' | 'style'> & {
+    /**
+     * CSS class applied to the element, or a function that
+     * returns a class based on the component's state.
+     */
+    className?: string | ((state: State) => string | undefined) | undefined;
+    /**
+     * Allows you to replace the component's HTML element
+     * with a different tag, or compose it with another component.
+     *
+     * Accepts a `ReactElement` or a function that returns the element to render.
+     */
+    render?: React_2.ReactElement | ComponentRenderFn<RenderFunctionProps, State> | undefined;
+    /**
+     * Style applied to the element, or a function that
+     * returns a style object based on the component's state.
+     */
+    style?: React_2.CSSProperties | ((state: State) => React_2.CSSProperties | undefined) | undefined;
+};
+
+declare type BaseUIEvent<E extends React_2.SyntheticEvent<Element, Event>> = E & {
+    preventBaseUIHandler: () => void;
+    readonly baseUIHandlerPrevented?: boolean | undefined;
+};
+
+/**
+ * Details of custom generic events emitted by Base UI components.
+ */
+declare type BaseUIGenericEventDetail<Reason extends string, CustomProperties extends object> = {
+    /**
+     * The reason for the event.
+     */
+    reason: Reason;
+    /**
+     * The native event associated with the custom event.
+     */
+    event: ReasonToEvent<Reason>;
+} & CustomProperties;
+
+declare type BaseUIGenericEventDetails<Reason extends string, CustomProperties extends object = {}> = Reason extends string ? BaseUIGenericEventDetail<Reason, CustomProperties> & {} : never;
+
+declare const cancelOpen: "cancel-open";
+
+declare const chipRemovePress: "chip-remove-press";
+
+declare const clearPress: "clear-press";
+
+declare const closePress: "close-press";
+
+declare const closeWatcher: "close-watcher";
+
+/**
+ * Shape of the render prop: a function that takes props to be spread on the element and component's state and returns a React element.
+ *
+ * @template Props Props to be spread on the rendered element.
+ * @template State Component's internal state.
+ */
+declare type ComponentRenderFn<Props, State> = (props: Props, state: State) => React_2.ReactElement<unknown>;
+
+declare const decrementPress: "decrement-press";
+
+declare const disabled: "disabled";
+
+declare const drag: "drag";
+
+declare type Errors = Record<string, string | string[]>;
+
+declare const escapeKey: "escape-key";
+
+declare interface FieldValidityData {
+    state: {
+        badInput: boolean;
+        customError: boolean;
+        patternMismatch: boolean;
+        rangeOverflow: boolean;
+        rangeUnderflow: boolean;
+        stepMismatch: boolean;
+        tooLong: boolean;
+        tooShort: boolean;
+        typeMismatch: boolean;
+        valueMissing: boolean;
+        valid: boolean | null;
+    };
+    error: string;
+    errors: string[];
+    value: unknown;
+    initialValue: unknown;
+}
+
+declare const focusOut: "focus-out";
+
 export declare const Form: React_2.ForwardRefExoticComponent<Omit<Omit<Form_2.Props<Record<string, any>> & {
     ref?: React_2.Ref<HTMLFormElement> | undefined;
 }, "ref">, "className"> & {
     className?: string | undefined;
 } & React_2.RefAttributes<HTMLFormElement>>;
 
+/**
+ * A native form element with consolidated error handling.
+ * Renders a `<form>` element.
+ *
+ * Documentation: [Base UI Form](https://base-ui.com/react/components/form)
+ */
+declare const Form_2: {
+    <FormValues extends Record<string, any> = Record<string, any>>(props: Form_2.Props<FormValues> & {
+        ref?: React_2.Ref<HTMLFormElement> | undefined;
+    }): React_2.JSX.Element;
+};
+
+declare namespace Form_2 {
+    type Props<FormValues extends Record<string, any> = Record<string, any>> = FormProps<FormValues>;
+    type State = FormState;
+    type Actions = FormActions;
+    type ValidationMode = FormValidationMode;
+    type SubmitEventReason = FormSubmitEventReason;
+    type SubmitEventDetails = FormSubmitEventDetails;
+    type Values<FormValues extends Record<string, any> = Record<string, any>> = FormValues;
+}
+
+export declare interface FormActions {
+    validate: (fieldName?: string | undefined) => void;
+}
+
+declare interface FormContext {
+    errors: Errors;
+    clearErrors: (name: string | undefined) => void;
+    formRef: React_2.RefObject<{
+        fields: Map<string, {
+            name: string | undefined;
+            /**
+             * After this returns, the field registry entry reflects the latest synchronous
+             * validity verdict. Async validators do not block submit.
+             */
+            validate: () => void;
+            validityData: FieldValidityData;
+            controlRef: React_2.RefObject<HTMLElement | null>;
+            getValue: () => unknown;
+        }>;
+    }>;
+    validationMode: Form_2.ValidationMode;
+    submitAttemptedRef: React_2.RefObject<boolean>;
+}
+
+declare const FormContext: React_2.Context<FormContext>;
+
+export declare interface FormProps<FormValues extends Record<string, any> = Record<string, any>> extends BaseUIComponentProps<'form', FormState> {
+    /**
+     * Determines when the form should be validated.
+     * The `validationMode` prop on `<Field.Root>` takes precedence over this.
+     *
+     * - `onSubmit` (default): validates the field when the form is submitted, afterwards fields will re-validate on change.
+     * - `onBlur`: validates a field when it loses focus.
+     * - `onChange`: validates the field on every change to its value.
+     *
+     * @default 'onSubmit'
+     */
+    validationMode?: FormValidationMode | undefined;
+    /**
+     * Validation errors returned externally, typically after submission by a server or a form action.
+     * This should be an object where keys correspond to the `name` attribute on `<Field.Root>`,
+     * and values correspond to error(s) related to that field.
+     */
+    errors?: FormContext['errors'] | undefined;
+    /**
+     * Event handler called when the form is submitted.
+     * `preventDefault()` is called on the native submit event when used.
+     */
+    onFormSubmit?: ((formValues: FormValues, eventDetails: Form_2.SubmitEventDetails) => void) | undefined;
+    /**
+     * A ref to imperative actions.
+     * - `validate`: Validates all fields when called. Optionally pass a field name to validate a single field.
+     * @example
+     * ```tsx
+     * // validate all fields
+     * actionsRef.current.validate();
+     *
+     * // validate one field
+     * actionsRef.current.validate('email');
+     * ```
+     */
+    actionsRef?: React_2.RefObject<Form_2.Actions | null> | undefined;
+}
+
+export declare interface FormState {}
+
+export declare type FormSubmitEventDetails = BaseUIGenericEventDetails<Form_2.SubmitEventReason>;
+
+export declare type FormSubmitEventReason = typeof REASONS.none;
+
+export declare type FormValidationMode = 'onSubmit' | 'onBlur' | 'onChange';
+
+declare type HTMLProps<T = any> = React_2.HTMLAttributes<T> & {
+    ref?: React_2.Ref<T> | undefined;
+};
+
+declare const imperativeAction: "imperative-action";
+
+declare const incrementPress: "increment-press";
+
+declare const initial: "initial";
+
+declare const inputBlur: "input-blur";
+
+declare const inputChange: "input-change";
+
+declare const inputClear: "input-clear";
+
+declare const inputPaste: "input-paste";
+
+declare const inputPress: "input-press";
+
+declare const itemPress: "item-press";
+
+declare const keyboard: "keyboard";
+
+declare const linkPress: "link-press";
+
+declare const listNavigation: "list-navigation";
+
+declare const missing: "missing";
+
+declare const none: "none";
+
+declare const outsidePress: "outside-press";
+
+declare const pointer: "pointer";
+
+declare namespace REASONS {
+    export {
+        none,
+        triggerPress,
+        triggerHover,
+        triggerFocus,
+        outsidePress,
+        itemPress,
+        closePress,
+        linkPress,
+        clearPress,
+        chipRemovePress,
+        trackPress,
+        incrementPress,
+        decrementPress,
+        inputChange,
+        inputClear,
+        inputBlur,
+        inputPaste,
+        inputPress,
+        focusOut,
+        escapeKey,
+        closeWatcher,
+        listNavigation,
+        keyboard,
+        pointer,
+        drag,
+        wheel,
+        scrub,
+        cancelOpen,
+        siblingOpen,
+        disabled,
+        missing,
+        initial,
+        imperativeAction,
+        swipe,
+        windowResize
+    }
+}
+
+/**
+ * Maps a change `reason` string to the corresponding native event type.
+ */
+declare type ReasonToEvent<Reason extends string> = Reason extends keyof ReasonToEventMap ? ReasonToEventMap[Reason] : Event;
+
+declare interface ReasonToEventMap {
+    [REASONS.none]: Event;
+    [REASONS.triggerPress]: MouseEvent | PointerEvent | TouchEvent | KeyboardEvent;
+    [REASONS.triggerHover]: MouseEvent;
+    [REASONS.triggerFocus]: FocusEvent;
+    [REASONS.outsidePress]: MouseEvent | PointerEvent | TouchEvent;
+    [REASONS.itemPress]: MouseEvent | KeyboardEvent | PointerEvent;
+    [REASONS.closePress]: MouseEvent | KeyboardEvent | PointerEvent;
+    [REASONS.linkPress]: MouseEvent | PointerEvent;
+    [REASONS.clearPress]: PointerEvent | MouseEvent | KeyboardEvent;
+    [REASONS.chipRemovePress]: PointerEvent | MouseEvent | KeyboardEvent;
+    [REASONS.trackPress]: PointerEvent | MouseEvent | TouchEvent;
+    [REASONS.incrementPress]: PointerEvent | MouseEvent | TouchEvent;
+    [REASONS.decrementPress]: PointerEvent | MouseEvent | TouchEvent;
+    [REASONS.inputChange]: InputEvent | Event;
+    [REASONS.inputClear]: InputEvent | FocusEvent | Event;
+    [REASONS.inputBlur]: FocusEvent;
+    [REASONS.inputPaste]: ClipboardEvent;
+    [REASONS.inputPress]: MouseEvent | PointerEvent | TouchEvent | KeyboardEvent;
+    [REASONS.focusOut]: FocusEvent | KeyboardEvent;
+    [REASONS.escapeKey]: KeyboardEvent;
+    [REASONS.closeWatcher]: Event;
+    [REASONS.listNavigation]: KeyboardEvent;
+    [REASONS.keyboard]: KeyboardEvent;
+    [REASONS.pointer]: PointerEvent;
+    [REASONS.drag]: PointerEvent | TouchEvent;
+    [REASONS.swipe]: PointerEvent | TouchEvent;
+    [REASONS.wheel]: WheelEvent;
+    [REASONS.scrub]: PointerEvent;
+    [REASONS.cancelOpen]: MouseEvent;
+    [REASONS.siblingOpen]: Event;
+    [REASONS.disabled]: Event;
+    [REASONS.missing]: Event;
+    [REASONS.initial]: Event;
+    [REASONS.imperativeAction]: Event;
+    [REASONS.windowResize]: UIEvent;
+}
+
+declare const scrub: "scrub";
+
+declare const siblingOpen: "sibling-open";
+
+declare const swipe: "swipe";
+
+declare const trackPress: "track-press";
+
+declare const triggerFocus: "trigger-focus";
+
+declare const triggerHover: "trigger-hover";
+
+declare const triggerPress: "trigger-press";
+
+declare const wheel: "wheel";
+
+declare const windowResize: "window-resize";
+
+/**
+ * Adds a `preventBaseUIHandler` method to all event handlers.
+ */
+declare type WithBaseUIEvent<T> = { [K in keyof T]: WithPreventBaseUIHandler<T[K]> };
 
-export * from "@base-ui/react/form";
+declare type WithPreventBaseUIHandler<T> = T extends ((event: infer E) => any) ? E extends React_2.SyntheticEvent<Element, Event> ? (event: BaseUIEvent<E>) => ReturnType<T> : T : T extends undefined ? undefined : T;
 
 export { }

package/dist/Form/index.js

@@ -1,11 +1,114 @@
 import { jsx } from "react/jsx-runtime";
-import { Form } from "@base-ui/react/form";
 import clsx from "clsx";
+import { useStableCallback } from "../7541.js";
+import { useValueChanged } from "../2801.js";
+import { useRenderElement, EMPTY_OBJECT } from "../8272.js";
+import { createGenericEventDetails } from "../4768.js";
+import { FormContext } from "../5085.js";
 import * as __rspack_external_react from "react";
+const Form_Form = /*#__PURE__*/ __rspack_external_react.forwardRef(function(componentProps, forwardedRef) {
+    const { render, className, validationMode = 'onSubmit', errors: externalErrors, onSubmit, onFormSubmit, actionsRef, style, ...elementProps } = componentProps;
+    const formRef = __rspack_external_react.useRef({
+        fields: new Map()
+    });
+    const submittedRef = __rspack_external_react.useRef(false);
+    const submitAttemptedRef = __rspack_external_react.useRef(false);
+    const focusControl = useStableCallback((control)=>{
+        if (!control) return;
+        control.focus();
+        if ('INPUT' === control.tagName) control.select();
+    });
+    const [errors, setErrors] = __rspack_external_react.useState(externalErrors);
+    useValueChanged(externalErrors, ()=>{
+        setErrors(externalErrors);
+    });
+    __rspack_external_react.useEffect(()=>{
+        if (!submittedRef.current) return;
+        submittedRef.current = false;
+        const invalidFields = Array.from(formRef.current.fields.values()).filter((field)=>false === field.validityData.state.valid);
+        if (invalidFields.length) focusControl(invalidFields[0].controlRef.current);
+    }, [
+        errors,
+        focusControl
+    ]);
+    const handleImperativeValidate = __rspack_external_react.useCallback((fieldName)=>{
+        const values = Array.from(formRef.current.fields.values());
+        if (fieldName) {
+            const namedField = values.find((field)=>field.name === fieldName);
+            if (namedField) namedField.validate();
+        } else values.forEach((field)=>{
+            field.validate();
+        });
+    }, []);
+    __rspack_external_react.useImperativeHandle(actionsRef, ()=>({
+            validate: handleImperativeValidate
+        }), [
+        handleImperativeValidate
+    ]);
+    const element = useRenderElement('form', componentProps, {
+        ref: forwardedRef,
+        props: [
+            {
+                noValidate: true,
+                onSubmit (event) {
+                    submitAttemptedRef.current = true;
+                    let values = Array.from(formRef.current.fields.values());
+                    values.forEach((field)=>{
+                        field.validate();
+                    });
+                    values = Array.from(formRef.current.fields.values());
+                    const invalidFields = values.filter((field)=>!field.validityData.state.valid);
+                    if (invalidFields.length) {
+                        event.preventDefault();
+                        focusControl(invalidFields[0].controlRef.current);
+                    } else {
+                        submittedRef.current = true;
+                        onSubmit?.(event);
+                        if (onFormSubmit) {
+                            event.preventDefault();
+                            const formValues = values.reduce((acc, field)=>{
+                                if (field.name) acc[field.name] = field.getValue();
+                                return acc;
+                            }, {});
+                            onFormSubmit(formValues, createGenericEventDetails("none", event.nativeEvent));
+                        }
+                    }
+                }
+            },
+            elementProps
+        ]
+    });
+    const clearErrors = useStableCallback((name)=>{
+        if (name && errors && EMPTY_OBJECT.hasOwnProperty.call(errors, name)) {
+            const nextErrors = {
+                ...errors
+            };
+            delete nextErrors[name];
+            setErrors(nextErrors);
+        }
+    });
+    const contextValue = __rspack_external_react.useMemo(()=>({
+            formRef,
+            validationMode,
+            errors: errors ?? EMPTY_OBJECT,
+            clearErrors,
+            submitAttemptedRef
+        }), [
+        formRef,
+        validationMode,
+        errors,
+        clearErrors
+    ]);
+    return /*#__PURE__*/ jsx(FormContext.Provider, {
+        value: contextValue,
+        children: element
+    });
+});
+if ("production" !== process.env.NODE_ENV) Form_Form.displayName = "Form";
 const Form_module = {};
-const Form_Form = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(Form, {
+const Form_Form_Form = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(Form_Form, {
         ref: ref,
         className: clsx(Form_module.root, className),
         ...props
     }));
-export { Form_Form as Form };
+export { Form_Form_Form as Form };