@1money/react-ui 1.16.0 → 1.17.0

package/es/components/CheckboxGroup/interface.d.ts

@@ -10,26 +10,32 @@ interface CheckboxGroupBaseProps {
     labelCls?: string;
     size?: 'sm' | 'md' | 'lg';
 }
+interface CheckboxGroupNormalItem {
+    key: string;
+    label?: ReactNode;
+    defaultChecked?: boolean;
+    onChange?: (checked: boolean) => any;
+}
+interface CheckboxGroupTriStateItem {
+    key: string;
+    label?: ReactNode;
+    defaultValue?: boolean | null;
+    onChange?: (state: boolean | null) => any;
+}
+type NormalItem = CheckboxGroupNormalItem & Omit<PrimeCheckboxProps, 'key' | 'className' | 'checked' | 'value' | 'inputId' | 'onChange'>;
+type TriStateItem = CheckboxGroupTriStateItem & Omit<TriStateCheckboxProps, 'key' | 'className' | 'checked' | 'value' | 'inputId' | 'onChange' | 'defaultValue'>;
+export type CheckboxGroupItem = NormalItem | TriStateItem;
 interface CheckboxGroupNormalProps extends CheckboxGroupBaseProps {
     tristate?: false;
-    onChange?: (checkedList: string[]) => any;
-    items: ({
-        key: string;
-        label?: ReactNode;
-        checked?: boolean;
-        onChange?: (checked: boolean) => any;
-    } & Omit<PrimeCheckboxProps, 'key' | 'className' | 'checked' | 'value' | 'inputId' | 'onChange'>)[];
+    value?: string[];
+    onChange?: (checkedList: string[]) => void;
+    items: NormalItem[];
 }
 interface CheckboxGroupTriStateProps extends CheckboxGroupBaseProps {
     tristate: true;
-    onChange?: (itemsState: Record<string, boolean | null>) => any;
-    items: ({
-        key: string;
-        label?: ReactNode;
-        checked?: boolean;
-        defaultValue?: boolean | null;
-        onChange?: (state: boolean | null) => any;
-    } & Omit<TriStateCheckboxProps, 'key' | 'className' | 'checked' | 'value' | 'inputId' | 'onChange' | 'defaultValue'>)[];
+    value?: Record<string, boolean | null>;
+    onChange?: (itemsState: Record<string, boolean | null>) => void;
+    items: TriStateItem[];
 }
 export type CheckboxGroupProps = CheckboxGroupNormalProps | CheckboxGroupTriStateProps;
 export {};

package/es/components/CheckboxGroup/style/CheckboxGroup.scss

@@ -75,13 +75,6 @@ $component: 'checkboxgroup';
           border: 2px solid $color-primary;
           box-shadow: none;
         }
-
-        // &:has(.p-checkbox-input:checked) {
-        //   .p-checkbox-box {
-        //     // background-color: $color-primary-active;
-        //     // border-color: $color-primary-active;
-        //   }
-        // }
       }
 
       // 选中状态

package/es/components/Form/Form.d.ts

@@ -0,0 +1,29 @@
+import React from 'react';
+import type { FieldValues } from 'react-hook-form';
+import type { FormContextValue, FormProps } from './interface';
+/** React context that distributes form layout and state to descendant `<FormItem>` components. */
+export declare const FormContext: React.Context<FormContextValue | null>;
+/**
+ * Form component that wraps `react-hook-form` with layout, context distribution,
+ * value-change subscriptions, and scroll-to-error behavior.
+ *
+ * Renders a `<FormProvider>` and native `<form>` element. All `<FormItem>` children
+ * receive form methods and layout configuration via {@link FormContext}.
+ *
+ * Supports both controlled mode (pass an external `form` instance) and uncontrolled
+ * mode (internal `useForm` is created automatically).
+ *
+ * @template TFieldValues - The shape of the form values.
+ * @param props - {@link FormProps}
+ *
+ * @example
+ * ```tsx
+ * <Form defaultValues={{ name: '' }} onFinish={(values) => save(values)}>
+ *   <FormItem name="name" label="Name" rules={{ required: true }}>
+ *     <Input />
+ *   </FormItem>
+ * </Form>
+ * ```
+ */
+export declare function Form<TFieldValues extends FieldValues = FieldValues>(props: FormProps<TFieldValues>): import("react/jsx-runtime").JSX.Element;
+export default Form;

package/es/components/Form/Form.js

@@ -0,0 +1,188 @@
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+var __awaiter = this && this.__awaiter || function (thisArg, _arguments, P, generator) {
+  function adopt(value) {
+    return value instanceof P ? value : new P(function (resolve) {
+      resolve(value);
+    });
+  }
+  return new (P || (P = Promise))(function (resolve, reject) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function step(result) {
+      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+    }
+    step((generator = generator.apply(thisArg, _arguments || [])).next());
+  });
+};
+var __rest = this && this.__rest || function (s, e) {
+  var t = {};
+  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
+  if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+    if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
+  }
+  return t;
+};
+import { jsx as _jsx } from "react/jsx-runtime";
+import React, { createContext, useEffect, useMemo } from 'react';
+import { FormProvider, useForm } from 'react-hook-form';
+import { default as classnames, joinCls } from '../../utils/classnames';
+import useLatest from '../useLatest';
+import useMemoizedFn from '../useMemoizedFn';
+import { DEFAULT_LABEL_ALIGN, DEFAULT_LABEL_COL, DEFAULT_LAYOUT, DEFAULT_SIZE, DEFAULT_WRAPPER_COL } from './constants';
+import { getFirstErrorPath, scrollToField } from './helper';
+/** React context that distributes form layout and state to descendant `<FormItem>` components. */
+export var FormContext = /*#__PURE__*/createContext(null);
+/**
+ * Form component that wraps `react-hook-form` with layout, context distribution,
+ * value-change subscriptions, and scroll-to-error behavior.
+ *
+ * Renders a `<FormProvider>` and native `<form>` element. All `<FormItem>` children
+ * receive form methods and layout configuration via {@link FormContext}.
+ *
+ * Supports both controlled mode (pass an external `form` instance) and uncontrolled
+ * mode (internal `useForm` is created automatically).
+ *
+ * @template TFieldValues - The shape of the form values.
+ * @param props - {@link FormProps}
+ *
+ * @example
+ * ```tsx
+ * <Form defaultValues={{ name: '' }} onFinish={(values) => save(values)}>
+ *   <FormItem name="name" label="Name" rules={{ required: true }}>
+ *     <Input />
+ *   </FormItem>
+ * </Form>
+ * ```
+ */
+export function Form(props) {
+  var _this = this;
+  // Form is a thin wrapper over react-hook-form with layout + UX helpers.
+  var form = props.form,
+    defaultValues = props.defaultValues,
+    onFinish = props.onFinish,
+    onFinishFailed = props.onFinishFailed,
+    onValuesChange = props.onValuesChange,
+    watchNames = props.watchNames,
+    scrollToFirstError = props.scrollToFirstError,
+    _props$layout = props.layout,
+    layout = _props$layout === void 0 ? DEFAULT_LAYOUT : _props$layout,
+    _props$labelAlign = props.labelAlign,
+    labelAlign = _props$labelAlign === void 0 ? DEFAULT_LABEL_ALIGN : _props$labelAlign,
+    _props$labelCol = props.labelCol,
+    labelCol = _props$labelCol === void 0 ? DEFAULT_LABEL_COL : _props$labelCol,
+    _props$wrapperCol = props.wrapperCol,
+    wrapperCol = _props$wrapperCol === void 0 ? DEFAULT_WRAPPER_COL : _props$wrapperCol,
+    _props$size = props.size,
+    size = _props$size === void 0 ? DEFAULT_SIZE : _props$size,
+    disabled = props.disabled,
+    _props$colon = props.colon,
+    colon = _props$colon === void 0 ? true : _props$colon,
+    _props$requiredMark = props.requiredMark,
+    requiredMark = _props$requiredMark === void 0 ? true : _props$requiredMark,
+    className = props.className,
+    style = props.style,
+    children = props.children,
+    useFormProps = __rest(props, ["form", "defaultValues", "onFinish", "onFinishFailed", "onValuesChange", "watchNames", "scrollToFirstError", "layout", "labelAlign", "labelCol", "wrapperCol", "size", "disabled", "colon", "requiredMark", "className", "style", "children"]);
+  // Always create an internal form to keep hook ordering stable.
+  // When an external `form` is passed via the `form` prop, this instance is
+  // unused but must remain so that React's hook call order is consistent
+  // across renders. We pass `shouldUnregister: true` to minimize overhead
+  // of the unused form instance.
+  var internalMethods = useForm(Object.assign({
+    defaultValues: defaultValues,
+    shouldUnregister: true
+  }, useFormProps));
+  // Use provided form methods when controlled; otherwise use internal form state.
+  var methods = form !== null && form !== void 0 ? form : internalMethods;
+  var valuesChangeRef = useLatest(onValuesChange);
+  var watchNamesRef = useLatest((watchNames === null || watchNames === void 0 ? void 0 : watchNames.length) ? new Set(watchNames) : null);
+  // Provide layout + disabled state + form methods to FormItem via context.
+  var ctx = useMemo(function () {
+    return {
+      layout: layout,
+      labelAlign: labelAlign,
+      labelCol: labelCol,
+      wrapperCol: wrapperCol,
+      size: size,
+      disabled: disabled,
+      colon: colon,
+      requiredMark: requiredMark,
+      methods: methods
+    };
+  }, [layout, labelAlign, labelCol, wrapperCol, size, disabled, colon, requiredMark, methods]);
+  // Subscribe to all value changes when handler provided.
+  useEffect(function () {
+    if (!onValuesChange) return;
+    var subscription = methods.watch(function (values, info) {
+      var _a;
+      var watchSet = watchNamesRef.current;
+      if (watchSet) {
+        var name = info.name;
+        if (!name || !watchSet.has(name)) return;
+      }
+      (_a = valuesChangeRef.current) === null || _a === void 0 ? void 0 : _a.call(valuesChangeRef, values, {
+        name: info.name,
+        type: info.type
+      });
+    });
+    return function () {
+      return subscription.unsubscribe();
+    };
+    // `valuesChangeRef` and `watchNamesRef` are stable refs accessed via `.current`
+    // so they do not need to be in the dependency array.
+  }, [methods, onValuesChange]);
+  // Submit success handler.
+  var handleFinish = useMemoizedFn(function (values) {
+    return __awaiter(_this, void 0, void 0, /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+      return _regeneratorRuntime.wrap(function _callee$(_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            _context.next = 2;
+            return onFinish === null || onFinish === void 0 ? void 0 : onFinish(values);
+          case 2:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee);
+    }));
+  });
+  // Submit failure handler with optional scroll-to-error.
+  var handleFinishFailed = useMemoizedFn(function (errors) {
+    var _a;
+    if (scrollToFirstError) {
+      var first = getFirstErrorPath(errors);
+      if (first) {
+        (_a = methods.setFocus) === null || _a === void 0 ? void 0 : _a.call(methods, first);
+        scrollToField(first, scrollToFirstError);
+      }
+    }
+    onFinishFailed === null || onFinishFailed === void 0 ? void 0 : onFinishFailed(errors);
+  });
+  var classes = classnames('form');
+  return _jsx(FormProvider, Object.assign({}, methods, {
+    children: _jsx(FormContext.Provider, {
+      value: ctx,
+      children: _jsx("form", {
+        className: classes('root', joinCls(className, classes("layout-".concat(layout)), classes("size-".concat(size)), labelAlign === 'left' && classes('label-left'))),
+        style: style,
+        onSubmit: methods.handleSubmit(handleFinish, handleFinishFailed),
+        noValidate: true,
+        children: children
+      })
+    })
+  }));
+}
+export default Form;
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["components/Form/Form.js","components/src/components/Form/Form.tsx"],"names":["__awaiter","thisArg","_arguments","P","generator","adopt","value","resolve","Promise","reject","fulfilled","step","next","e","rejected","result","done","then","apply","__rest","s","t","p","Object","prototype","hasOwnProperty","call","indexOf","getOwnPropertySymbols","i","length","propertyIsEnumerable","jsx","_jsx","React","createContext","useEffect","useMemo","FormProvider","useForm","default","classnames","joinCls","useLatest","useMemoizedFn","DEFAULT_LABEL_ALIGN","DEFAULT_LABEL_COL","DEFAULT_LAYOUT","DEFAULT_SIZE","DEFAULT_WRAPPER_COL","getFirstErrorPath","scrollToField","FormContext","Form","props","_this","form","defaultValues","onFinish","onFinishFailed","onValuesChange","watchNames","scrollToFirstError","_props$layout","layout","_props$labelAlign","labelAlign","_props$labelCol","labelCol","_props$wrapperCol","wrapperCol","_props$size","size","disabled","_props$colon","colon","_props$requiredMark","requiredMark","className","style","children","useFormProps","internalMethods","assign","shouldUnregister","methods","valuesChangeRef","watchNamesRef","Set","ctx","subscription","watch","values","info","_a","watchSet","current","name","has","type","unsubscribe","handleFinish","_regeneratorRuntime","mark","_callee","wrap","_callee$","_context","prev","stop","handleFinishFailed","errors","first","setFocus","classes","Provider","concat","onSubmit","handleSubmit","noValidate"],"mappings":"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","file":"components/Form/Form.js","sourcesContent":["var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n    return new (P || (P = Promise))(function (resolve, reject) {\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\n    });\n};\nvar __rest = (this && this.__rest) || function (s, e) {\n    var t = {};\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\n        t[p] = s[p];\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\n                t[p[i]] = s[p[i]];\n        }\n    return t;\n};\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nimport React, { createContext, useEffect, useMemo } from 'react';\nimport { FormProvider, useForm } from 'react-hook-form';\nimport { default as classnames, joinCls } from '../../utils/classnames';\nimport useLatest from '../useLatest';\nimport useMemoizedFn from '../useMemoizedFn';\nimport { DEFAULT_LABEL_ALIGN, DEFAULT_LABEL_COL, DEFAULT_LAYOUT, DEFAULT_SIZE, DEFAULT_WRAPPER_COL, } from './constants';\nimport { getFirstErrorPath, scrollToField } from './helper';\n/** React context that distributes form layout and state to descendant `<FormItem>` components. */\nexport const FormContext = createContext(null);\n/**\n * Form component that wraps `react-hook-form` with layout, context distribution,\n * value-change subscriptions, and scroll-to-error behavior.\n *\n * Renders a `<FormProvider>` and native `<form>` element. All `<FormItem>` children\n * receive form methods and layout configuration via {@link FormContext}.\n *\n * Supports both controlled mode (pass an external `form` instance) and uncontrolled\n * mode (internal `useForm` is created automatically).\n *\n * @template TFieldValues - The shape of the form values.\n * @param props - {@link FormProps}\n *\n * @example\n * ```tsx\n * <Form defaultValues={{ name: '' }} onFinish={(values) => save(values)}>\n *   <FormItem name=\"name\" label=\"Name\" rules={{ required: true }}>\n *     <Input />\n *   </FormItem>\n * </Form>\n * ```\n */\nexport function Form(props) {\n    // Form is a thin wrapper over react-hook-form with layout + UX helpers.\n    const { form, defaultValues, onFinish, onFinishFailed, onValuesChange, watchNames, scrollToFirstError, layout = DEFAULT_LAYOUT, labelAlign = DEFAULT_LABEL_ALIGN, labelCol = DEFAULT_LABEL_COL, wrapperCol = DEFAULT_WRAPPER_COL, size = DEFAULT_SIZE, disabled, colon = true, requiredMark = true, className, style, children } = props, useFormProps = __rest(props, [\"form\", \"defaultValues\", \"onFinish\", \"onFinishFailed\", \"onValuesChange\", \"watchNames\", \"scrollToFirstError\", \"layout\", \"labelAlign\", \"labelCol\", \"wrapperCol\", \"size\", \"disabled\", \"colon\", \"requiredMark\", \"className\", \"style\", \"children\"]);\n    // Always create an internal form to keep hook ordering stable.\n    // When an external `form` is passed via the `form` prop, this instance is\n    // unused but must remain so that React's hook call order is consistent\n    // across renders. We pass `shouldUnregister: true` to minimize overhead\n    // of the unused form instance.\n    const internalMethods = useForm(Object.assign({ defaultValues, shouldUnregister: true }, useFormProps));\n    // Use provided form methods when controlled; otherwise use internal form state.\n    const methods = form !== null && form !== void 0 ? form : internalMethods;\n    const valuesChangeRef = useLatest(onValuesChange);\n    const watchNamesRef = useLatest((watchNames === null || watchNames === void 0 ? void 0 : watchNames.length) ? new Set(watchNames) : null);\n    // Provide layout + disabled state + form methods to FormItem via context.\n    const ctx = useMemo(() => ({\n        layout,\n        labelAlign,\n        labelCol,\n        wrapperCol,\n        size,\n        disabled,\n        colon,\n        requiredMark,\n        methods: methods,\n    }), [layout, labelAlign, labelCol, wrapperCol, size, disabled, colon, requiredMark, methods]);\n    // Subscribe to all value changes when handler provided.\n    useEffect(() => {\n        if (!onValuesChange)\n            return;\n        const subscription = methods.watch((values, info) => {\n            var _a;\n            const watchSet = watchNamesRef.current;\n            if (watchSet) {\n                const name = info.name;\n                if (!name || !watchSet.has(name))\n                    return;\n            }\n            (_a = valuesChangeRef.current) === null || _a === void 0 ? void 0 : _a.call(valuesChangeRef, values, { name: info.name, type: info.type });\n        });\n        return () => subscription.unsubscribe();\n        // `valuesChangeRef` and `watchNamesRef` are stable refs accessed via `.current`\n        // so they do not need to be in the dependency array.\n    }, [methods, onValuesChange]);\n    // Submit success handler.\n    const handleFinish = useMemoizedFn((values) => __awaiter(this, void 0, void 0, function* () {\n        yield (onFinish === null || onFinish === void 0 ? void 0 : onFinish(values));\n    }));\n    // Submit failure handler with optional scroll-to-error.\n    const handleFinishFailed = useMemoizedFn((errors) => {\n        var _a;\n        if (scrollToFirstError) {\n            const first = getFirstErrorPath(errors);\n            if (first) {\n                (_a = methods.setFocus) === null || _a === void 0 ? void 0 : _a.call(methods, first);\n                scrollToField(first, scrollToFirstError);\n            }\n        }\n        onFinishFailed === null || onFinishFailed === void 0 ? void 0 : onFinishFailed(errors);\n    });\n    const classes = classnames('form');\n    return (_jsx(FormProvider, Object.assign({}, methods, { children: _jsx(FormContext.Provider, { value: ctx, children: _jsx(\"form\", { className: classes('root', joinCls(className, classes(`layout-${layout}`), classes(`size-${size}`), labelAlign === 'left' && classes('label-left'))), style: style, onSubmit: methods.handleSubmit(handleFinish, handleFinishFailed), noValidate: true, children: children }) }) })));\n}\nexport default Form;",null],"sourceRoot":"../../../../../../../../../src"}

package/es/components/Form/FormItem.d.ts

@@ -0,0 +1,4 @@
+import type { FieldValues } from 'react-hook-form';
+import type { FormItemProps } from './interface';
+export declare function FormItem<TFieldValues extends FieldValues = FieldValues>(props: FormItemProps<TFieldValues>): import("react/jsx-runtime").JSX.Element;
+export default FormItem;

package/es/components/Form/FormItem.js

@@ -0,0 +1,165 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useContext, useMemo } from 'react';
+import { default as classnames, joinCls } from '../../utils/classnames';
+import Typography from '../Typography';
+import { FormContext } from './Form';
+import { CSS_VAR_LABEL_WIDTH, CSS_VAR_WRAPPER_WIDTH, DEFAULT_VALUE_PROP } from './constants';
+import { toPercent, wrapValidate } from './helper';
+import { FormItemContent } from './FormItemContent';
+import { FallbackFormProvider, useFormItemContext } from './useFormItemContext';
+import { useFormItemWatch } from './useFormItemWatch';
+import { useValidationTrigger } from './useValidationTrigger';
+/**
+ * Runtime type guard for render-prop children.
+ */
+var isRenderFnChild = function isRenderFnChild(child) {
+  return typeof child === 'function';
+};
+/**
+ * Form field wrapper that bridges `react-hook-form`'s Controller with the Form
+ * layout system, validation status display, and configurable trigger behavior.
+ *
+ * When a `name` is provided, the field is registered with `react-hook-form` via
+ * a `Controller` and supports validation rules, dependencies, and status feedback.
+ * Without a `name`, it renders as a free wrapper for uncontrolled content.
+ *
+ * Supports two child patterns:
+ * - **React element**: automatically bound via `React.cloneElement` with value/onChange/onBlur.
+ * - **Render-prop function**: receives `{ field, fieldState, form, values }` for full control.
+ *
+ * @template TFieldValues - The shape of the form values.
+ * @param props - {@link FormItemProps}
+ *
+ * @example
+ * ```tsx
+ * // Element child (auto-bound)
+ * <FormItem name="email" label="Email" rules={{ required: true }}>
+ *   <Input placeholder="Enter email" />
+ * </FormItem>
+ *
+ * // Render-prop child
+ * <FormItem name="agree">
+ *   {({ field }) => <Checkbox {...field} />}
+ * </FormItem>
+ * ```
+ */
+function FormItemInner(props) {
+  var name = props.name,
+    label = props.label,
+    required = props.required,
+    rules = props.rules,
+    defaultValue = props.defaultValue,
+    help = props.help,
+    extra = props.extra,
+    validateStatus = props.validateStatus,
+    dependencies = props.dependencies,
+    watchNames = props.watchNames,
+    shouldUpdate = props.shouldUpdate,
+    validateTrigger = props.validateTrigger,
+    validateFirst = props.validateFirst,
+    validateDebounce = props.validateDebounce,
+    noStyle = props.noStyle,
+    _props$valuePropName = props.valuePropName,
+    valuePropName = _props$valuePropName === void 0 ? DEFAULT_VALUE_PROP : _props$valuePropName,
+    className = props.className,
+    labelCol = props.labelCol,
+    wrapperCol = props.wrapperCol,
+    children = props.children;
+  var classes = classnames('form-item');
+  var _useFormItemContext = useFormItemContext(name),
+    ctx = _useFormItemContext.ctx,
+    methods = _useFormItemContext.methods,
+    control = _useFormItemContext.control,
+    trigger = _useFormItemContext.trigger;
+  var _useFormItemWatch = useFormItemWatch({
+      control: control,
+      methods: methods,
+      dependencies: dependencies,
+      watchNames: watchNames,
+      shouldUpdate: shouldUpdate,
+      name: name
+    }),
+    allValues = _useFormItemWatch.allValues,
+    depValues = _useFormItemWatch.depValues,
+    shouldRender = _useFormItemWatch.shouldRender;
+  var _useValidationTrigger = useValidationTrigger({
+      name: name,
+      trigger: trigger,
+      validateTrigger: validateTrigger,
+      validateDebounce: validateDebounce,
+      dependencies: dependencies,
+      depValues: depValues
+    }),
+    withTrigger = _useValidationTrigger.withTrigger;
+  var renderFn = isRenderFnChild(children) ? children : null;
+  var isRequired = required !== null && required !== void 0 ? required : !!(rules === null || rules === void 0 ? void 0 : rules.required);
+  var showRequired = (ctx === null || ctx === void 0 ? void 0 : ctx.requiredMark) !== false;
+  var labelWidth = useMemo(function () {
+    return toPercent(labelCol !== null && labelCol !== void 0 ? labelCol : ctx === null || ctx === void 0 ? void 0 : ctx.labelCol);
+  }, [labelCol, ctx === null || ctx === void 0 ? void 0 : ctx.labelCol]);
+  var wrapperWidth = useMemo(function () {
+    return toPercent(wrapperCol !== null && wrapperCol !== void 0 ? wrapperCol : ctx === null || ctx === void 0 ? void 0 : ctx.wrapperCol);
+  }, [wrapperCol, ctx === null || ctx === void 0 ? void 0 : ctx.wrapperCol]);
+  var mergedRules = useMemo(function () {
+    if (!(rules === null || rules === void 0 ? void 0 : rules.validate) || !validateFirst) return rules;
+    var validate = wrapValidate(rules.validate, validateFirst);
+    if (validate === rules.validate) return rules;
+    return Object.assign(Object.assign({}, rules), {
+      validate: validate
+    });
+  }, [rules, validateFirst]);
+  var contentProps = useMemo(function () {
+    return {
+      name: name,
+      control: control,
+      methods: methods,
+      rules: mergedRules,
+      defaultValue: defaultValue,
+      validateStatus: validateStatus,
+      valuePropName: valuePropName,
+      help: help,
+      extra: extra,
+      ctx: ctx,
+      children: children,
+      renderFn: renderFn,
+      allValues: allValues,
+      shouldUpdate: shouldUpdate,
+      shouldRender: shouldRender,
+      withTrigger: withTrigger
+    };
+  }, [name, control, methods, mergedRules, defaultValue, validateStatus, valuePropName, help, extra, ctx, children, renderFn, allValues, shouldUpdate, shouldRender, withTrigger]);
+  if (noStyle) {
+    return _jsx(FormItemContent, Object.assign({}, contentProps));
+  }
+  var rootStyle = _defineProperty(_defineProperty({}, CSS_VAR_LABEL_WIDTH, labelWidth), CSS_VAR_WRAPPER_WIDTH, wrapperWidth);
+  return _jsxs("div", {
+    className: classes('root', joinCls(className, (ctx === null || ctx === void 0 ? void 0 : ctx.layout) && classes("layout-".concat(ctx.layout)))),
+    "data-form-item-name": name ? String(name) : undefined,
+    style: rootStyle,
+    children: [label && _jsxs("div", {
+      className: classes('label', joinCls(showRequired && isRequired && classes('label-required'))),
+      children: [_jsx(Typography.Label, {
+        size: 's',
+        children: label
+      }), (ctx === null || ctx === void 0 ? void 0 : ctx.colon) && _jsx("span", {
+        className: classes('colon'),
+        children: ":"
+      })]
+    }), _jsx("div", {
+      className: classes('control'),
+      children: _jsx(FormItemContent, Object.assign({}, contentProps))
+    })]
+  });
+}
+export function FormItem(props) {
+  var ctx = useContext(FormContext);
+  if (ctx === null || ctx === void 0 ? void 0 : ctx.methods) {
+    return _jsx(FormItemInner, Object.assign({}, props));
+  }
+  return _jsx(FallbackFormProvider, {
+    children: _jsx(FormItemInner, Object.assign({}, props))
+  });
+}
+export default FormItem;
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["components/Form/FormItem.js","components/src/components/Form/FormItem.tsx"],"names":["jsx","_jsx","jsxs","_jsxs","useContext","useMemo","default","classnames","joinCls","Typography","FormContext","CSS_VAR_LABEL_WIDTH","CSS_VAR_WRAPPER_WIDTH","DEFAULT_VALUE_PROP","toPercent","wrapValidate","FormItemContent","FallbackFormProvider","useFormItemContext","useFormItemWatch","useValidationTrigger","isRenderFnChild","child","FormItemInner","props","name","label","required","rules","defaultValue","help","extra","validateStatus","dependencies","watchNames","shouldUpdate","validateTrigger","validateFirst","validateDebounce","noStyle","_props$valuePropName","valuePropName","className","labelCol","wrapperCol","children","classes","_useFormItemContext","ctx","methods","control","trigger","_useFormItemWatch","allValues","depValues","shouldRender","_useValidationTrigger","withTrigger","renderFn","isRequired","showRequired","requiredMark","labelWidth","wrapperWidth","mergedRules","validate","Object","assign","contentProps","rootStyle","_defineProperty","layout","concat","String","undefined","style","Label","size","colon","FormItem"],"mappings":"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","file":"components/Form/FormItem.js","sourcesContent":["import { jsx as _jsx, jsxs as _jsxs } from \"react/jsx-runtime\";\nimport { useContext, useMemo } from 'react';\nimport { default as classnames, joinCls } from '../../utils/classnames';\nimport Typography from '../Typography';\nimport { FormContext } from './Form';\nimport { CSS_VAR_LABEL_WIDTH, CSS_VAR_WRAPPER_WIDTH, DEFAULT_VALUE_PROP } from './constants';\nimport { toPercent, wrapValidate } from './helper';\nimport { FormItemContent } from './FormItemContent';\nimport { FallbackFormProvider, useFormItemContext } from './useFormItemContext';\nimport { useFormItemWatch } from './useFormItemWatch';\nimport { useValidationTrigger } from './useValidationTrigger';\n/**\n * Runtime type guard for render-prop children.\n */\nconst isRenderFnChild = (child) => typeof child === 'function';\n/**\n * Form field wrapper that bridges `react-hook-form`'s Controller with the Form\n * layout system, validation status display, and configurable trigger behavior.\n *\n * When a `name` is provided, the field is registered with `react-hook-form` via\n * a `Controller` and supports validation rules, dependencies, and status feedback.\n * Without a `name`, it renders as a free wrapper for uncontrolled content.\n *\n * Supports two child patterns:\n * - **React element**: automatically bound via `React.cloneElement` with value/onChange/onBlur.\n * - **Render-prop function**: receives `{ field, fieldState, form, values }` for full control.\n *\n * @template TFieldValues - The shape of the form values.\n * @param props - {@link FormItemProps}\n *\n * @example\n * ```tsx\n * // Element child (auto-bound)\n * <FormItem name=\"email\" label=\"Email\" rules={{ required: true }}>\n *   <Input placeholder=\"Enter email\" />\n * </FormItem>\n *\n * // Render-prop child\n * <FormItem name=\"agree\">\n *   {({ field }) => <Checkbox {...field} />}\n * </FormItem>\n * ```\n */\nfunction FormItemInner(props) {\n    const { name, label, required, rules, defaultValue, help, extra, validateStatus, dependencies, watchNames, shouldUpdate, validateTrigger, validateFirst, validateDebounce, noStyle, valuePropName = DEFAULT_VALUE_PROP, className, labelCol, wrapperCol, children, } = props;\n    const classes = classnames('form-item');\n    const { ctx, methods, control, trigger } = useFormItemContext(name);\n    const { allValues, depValues, shouldRender } = useFormItemWatch({\n        control,\n        methods,\n        dependencies,\n        watchNames,\n        shouldUpdate,\n        name,\n    });\n    const { withTrigger } = useValidationTrigger({\n        name,\n        trigger,\n        validateTrigger,\n        validateDebounce,\n        dependencies,\n        depValues,\n    });\n    const renderFn = isRenderFnChild(children) ? children : null;\n    const isRequired = required !== null && required !== void 0 ? required : !!(rules === null || rules === void 0 ? void 0 : rules.required);\n    const showRequired = (ctx === null || ctx === void 0 ? void 0 : ctx.requiredMark) !== false;\n    const labelWidth = useMemo(() => toPercent(labelCol !== null && labelCol !== void 0 ? labelCol : ctx === null || ctx === void 0 ? void 0 : ctx.labelCol), [labelCol, ctx === null || ctx === void 0 ? void 0 : ctx.labelCol]);\n    const wrapperWidth = useMemo(() => toPercent(wrapperCol !== null && wrapperCol !== void 0 ? wrapperCol : ctx === null || ctx === void 0 ? void 0 : ctx.wrapperCol), [wrapperCol, ctx === null || ctx === void 0 ? void 0 : ctx.wrapperCol]);\n    const mergedRules = useMemo(() => {\n        if (!(rules === null || rules === void 0 ? void 0 : rules.validate) || !validateFirst)\n            return rules;\n        const validate = wrapValidate(rules.validate, validateFirst);\n        if (validate === rules.validate)\n            return rules;\n        return Object.assign(Object.assign({}, rules), { validate });\n    }, [rules, validateFirst]);\n    const contentProps = useMemo(() => ({\n        name,\n        control,\n        methods,\n        rules: mergedRules,\n        defaultValue,\n        validateStatus,\n        valuePropName,\n        help,\n        extra,\n        ctx,\n        children,\n        renderFn,\n        allValues,\n        shouldUpdate,\n        shouldRender,\n        withTrigger,\n    }), [\n        name, control, methods, mergedRules, defaultValue, validateStatus,\n        valuePropName, help, extra, ctx, children, renderFn, allValues,\n        shouldUpdate, shouldRender, withTrigger,\n    ]);\n    if (noStyle) {\n        return _jsx(FormItemContent, Object.assign({}, contentProps));\n    }\n    const rootStyle = {\n        [CSS_VAR_LABEL_WIDTH]: labelWidth,\n        [CSS_VAR_WRAPPER_WIDTH]: wrapperWidth,\n    };\n    return (_jsxs(\"div\", { className: classes('root', joinCls(className, (ctx === null || ctx === void 0 ? void 0 : ctx.layout) && classes(`layout-${ctx.layout}`))), \"data-form-item-name\": name ? String(name) : undefined, style: rootStyle, children: [label && (_jsxs(\"div\", { className: classes('label', joinCls(showRequired && isRequired && classes('label-required'))), children: [_jsx(Typography.Label, { size: 's', children: label }), (ctx === null || ctx === void 0 ? void 0 : ctx.colon) && _jsx(\"span\", { className: classes('colon'), children: \":\" })] })), _jsx(\"div\", { className: classes('control'), children: _jsx(FormItemContent, Object.assign({}, contentProps)) })] }));\n}\nexport function FormItem(props) {\n    const ctx = useContext(FormContext);\n    if (ctx === null || ctx === void 0 ? void 0 : ctx.methods) {\n        return _jsx(FormItemInner, Object.assign({}, props));\n    }\n    return (_jsx(FallbackFormProvider, { children: _jsx(FormItemInner, Object.assign({}, props)) }));\n}\nexport default FormItem;",null],"sourceRoot":"../../../../../../../../../src"}

package/es/components/Form/FormItemContent.d.ts

@@ -0,0 +1,18 @@
+import type { FieldValues } from 'react-hook-form';
+import type { FormItemContentProps } from './interface';
+/**
+ * Renders the inner content of a `<FormItem>`.
+ *
+ * Handles two branches:
+ * - **Free branch** (no `name`): renders children directly or via a render-prop,
+ *   optionally gated by `shouldUpdate`.
+ * - **Controlled branch** (has `name`): wraps children in a `react-hook-form`
+ *   `Controller`, injecting field bindings and validation-trigger wrappers.
+ *
+ * Both branches render their output inside a {@link MetaWrapper} for consistent
+ * help/error/extra display.
+ *
+ * @template TFieldValues - The shape of the form values.
+ * @param props - {@link FormItemContentProps}
+ */
+export declare function FormItemContent<TFieldValues extends FieldValues = FieldValues>({ name, control, methods, rules, defaultValue, validateStatus, valuePropName, help, extra, ctx, children, renderFn, allValues, shouldUpdate, shouldRender, withTrigger, }: FormItemContentProps<TFieldValues>): import("react/jsx-runtime").JSX.Element;