sy-form-components 0.2.0

package/dist/index.mjs

@@ -0,0 +1,4765 @@
+// src/core/FormProvider.tsx
+import React32, { useCallback, useRef as useRef4, useState as useState12, useMemo as useMemo4 } from "react";
+
+// src/core/FormContext.ts
+import { createContext, useContext } from "react";
+var FormContext = createContext(null);
+function useFormContext() {
+  const context = useContext(FormContext);
+  if (!context) {
+    throw new Error("useFormContext must be used within a FormProvider");
+  }
+  return context;
+}
+
+// src/core/ComponentRegistry.tsx
+import React, { createContext as createContext2, useContext as useContext2 } from "react";
+var ComponentRegistryContext = createContext2(null);
+function ComponentRegistryProvider({
+  components,
+  children
+}) {
+  const [registry, setRegistry] = React.useState(components);
+  const register = React.useCallback((name, component) => {
+    setRegistry((prev) => ({ ...prev, [name]: component }));
+  }, []);
+  const value = React.useMemo(() => ({ registry, register }), [registry, register]);
+  return React.createElement(ComponentRegistryContext.Provider, { value }, children);
+}
+function useComponent(componentName) {
+  const context = useContext2(ComponentRegistryContext);
+  if (!context) {
+    return null;
+  }
+  return context.registry[componentName] || null;
+}
+
+// src/fields/TextField/index.tsx
+import { useEffect } from "react";
+
+// src/core/FieldWrapper.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+function cn(...classes) {
+  return classes.filter(Boolean).join(" ");
+}
+function FieldWrapper({
+  fieldId,
+  label,
+  required,
+  tips,
+  className,
+  labelClassName,
+  tipsClassName,
+  children
+}) {
+  const { fieldErrors } = useFormContext();
+  const error = fieldErrors[fieldId];
+  return /* @__PURE__ */ jsxs("div", { className: cn("sy-field-wrapper", className), "data-field-id": fieldId, children: [
+    /* @__PURE__ */ jsxs("label", { className: cn("sy-field-label", labelClassName), children: [
+      required && /* @__PURE__ */ jsx("span", { className: "sy-field-required", "aria-hidden": "true", children: "*" }),
+      label
+    ] }),
+    /* @__PURE__ */ jsx("div", { className: "sy-field-control", children }),
+    tips && !error && /* @__PURE__ */ jsx("div", { className: cn("sy-field-tips", tipsClassName), "data-testid": `tips-${fieldId}`, children: tips }),
+    error && /* @__PURE__ */ jsx("div", { className: "sy-field-error", role: "alert", "data-testid": `error-${fieldId}`, children: error })
+  ] });
+}
+
+// src/hooks/useDeviceDetect.ts
+import { useSyncExternalStore } from "react";
+var MOBILE_BREAKPOINT = 768;
+function subscribe(callback) {
+  let prev = window.innerWidth < MOBILE_BREAKPOINT;
+  const handler = () => {
+    const next = window.innerWidth < MOBILE_BREAKPOINT;
+    if (next !== prev) {
+      prev = next;
+      callback();
+    }
+  };
+  window.addEventListener("resize", handler);
+  return () => window.removeEventListener("resize", handler);
+}
+function getSnapshot() {
+  return window.innerWidth < MOBILE_BREAKPOINT;
+}
+function useDeviceDetect() {
+  const isMobile = useSyncExternalStore(
+    subscribe,
+    getSnapshot,
+    /* v8 ignore next */
+    () => false
+  );
+  return { isMobile };
+}
+
+// src/fields/TextField/TextFieldPC.tsx
+import { Input } from "antd";
+import { jsx as jsx2 } from "react/jsx-runtime";
+function TextFieldPC({
+  fieldId,
+  placeholder,
+  maxLength,
+  inputClassName,
+  behavior,
+  onChange,
+  onBlur
+}) {
+  const { formData, setFieldValue } = useFormContext();
+  const value = formData[fieldId] ?? "";
+  const disabled = behavior === "DISABLED";
+  const handleChange = (e) => {
+    const v = e.target.value;
+    setFieldValue(fieldId, v);
+    onChange?.(v);
+  };
+  const handleBlur = (e) => {
+    onBlur?.(e.target.value);
+  };
+  return /* @__PURE__ */ jsx2(
+    Input,
+    {
+      className: inputClassName,
+      style: { width: "100%" },
+      value,
+      placeholder,
+      maxLength,
+      disabled,
+      onChange: handleChange,
+      onBlur: handleBlur,
+      "data-testid": `textfield-input-${fieldId}`
+    }
+  );
+}
+
+// src/fields/TextField/TextFieldMobile.tsx
+import { Input as Input2 } from "antd-mobile";
+import { jsx as jsx3 } from "react/jsx-runtime";
+function TextFieldMobile({
+  fieldId,
+  placeholder,
+  maxLength,
+  inputClassName,
+  behavior,
+  onChange,
+  onBlur
+}) {
+  const { formData, setFieldValue } = useFormContext();
+  const value = formData[fieldId] ?? "";
+  const disabled = behavior === "DISABLED";
+  const handleChange = (v) => {
+    setFieldValue(fieldId, v);
+    onChange?.(v);
+  };
+  const handleBlur = () => {
+    onBlur?.(value);
+  };
+  return /* @__PURE__ */ jsx3("div", { className: inputClassName, "data-testid": `textfield-input-${fieldId}`, children: /* @__PURE__ */ jsx3(
+    Input2,
+    {
+      value,
+      placeholder,
+      maxLength,
+      disabled,
+      onChange: handleChange,
+      onBlur: handleBlur
+    }
+  ) });
+}
+
+// src/fields/TextField/TextFieldReadonly.tsx
+import { jsx as jsx4 } from "react/jsx-runtime";
+function TextFieldReadonly({ fieldId, readonlyClassName }) {
+  const { formData } = useFormContext();
+  const value = formData[fieldId];
+  const display = value != null && value !== "" ? String(value) : "--";
+  return /* @__PURE__ */ jsx4(
+    "div",
+    {
+      className: readonlyClassName || "sy-field-readonly-value",
+      "data-testid": `textfield-readonly-${fieldId}`,
+      children: display
+    }
+  );
+}
+
+// src/fields/TextField/index.tsx
+import { jsx as jsx5 } from "react/jsx-runtime";
+function TextField(props) {
+  const {
+    fieldId,
+    label,
+    behavior: propBehavior,
+    required,
+    tips,
+    defaultValue,
+    className,
+    labelClassName,
+    tipsClassName
+  } = props;
+  const { fieldBehaviors, setFieldValue, formData, registerField, unregisterField } = useFormContext();
+  const { isMobile } = useDeviceDetect();
+  const behavior = propBehavior ?? fieldBehaviors[fieldId] ?? "NORMAL";
+  useEffect(() => {
+    registerField(fieldId);
+    if (defaultValue !== void 0 && formData[fieldId] === void 0) {
+      setFieldValue(fieldId, defaultValue);
+    }
+    return () => unregisterField(fieldId);
+  }, [fieldId]);
+  if (behavior === "HIDDEN") return null;
+  const childProps = { ...props, behavior };
+  return /* @__PURE__ */ jsx5(
+    FieldWrapper,
+    {
+      fieldId,
+      label,
+      required,
+      tips,
+      className,
+      labelClassName,
+      tipsClassName,
+      children: behavior === "READONLY" ? /* @__PURE__ */ jsx5(TextFieldReadonly, { ...childProps }) : isMobile ? /* @__PURE__ */ jsx5(TextFieldMobile, { ...childProps }) : /* @__PURE__ */ jsx5(TextFieldPC, { ...childProps })
+    }
+  );
+}
+
+// src/fields/NumberField/index.tsx
+import { useEffect as useEffect2 } from "react";
+
+// src/fields/NumberField/NumberFieldPC.tsx
+import { InputNumber } from "antd";
+import { jsx as jsx6 } from "react/jsx-runtime";
+function NumberFieldPC({
+  fieldId,
+  placeholder,
+  inputClassName,
+  behavior,
+  min,
+  max,
+  step,
+  precision,
+  onChange,
+  onBlur
+}) {
+  const { formData, setFieldValue } = useFormContext();
+  const value = formData[fieldId];
+  const disabled = behavior === "DISABLED";
+  const handleChange = (v) => {
+    setFieldValue(fieldId, v);
+    onChange?.(v);
+  };
+  const handleBlur = () => {
+    onBlur?.(value ?? null);
+  };
+  return /* @__PURE__ */ jsx6(
+    InputNumber,
+    {
+      className: inputClassName,
+      style: { width: "100%" },
+      value: value ?? null,
+      placeholder,
+      disabled,
+      min,
+      max,
+      step,
+      precision,
+      onChange: handleChange,
+      onBlur: handleBlur,
+      "data-testid": `numberfield-input-${fieldId}`
+    }
+  );
+}
+
+// src/fields/NumberField/NumberFieldMobile.tsx
+import { Input as Input3 } from "antd-mobile";
+import { jsx as jsx7 } from "react/jsx-runtime";
+function NumberFieldMobile({
+  fieldId,
+  placeholder,
+  inputClassName,
+  behavior,
+  onChange,
+  onBlur
+}) {
+  const { formData, setFieldValue } = useFormContext();
+  const value = formData[fieldId];
+  const disabled = behavior === "DISABLED";
+  const handleChange = (v) => {
+    const num = v === "" ? null : Number(v);
+    const finalValue = num !== null && isNaN(num) ? null : num;
+    setFieldValue(fieldId, finalValue);
+    onChange?.(finalValue);
+  };
+  const handleBlur = () => {
+    onBlur?.(value ?? null);
+  };
+  return /* @__PURE__ */ jsx7("div", { className: inputClassName, "data-testid": `numberfield-input-${fieldId}`, children: /* @__PURE__ */ jsx7(
+    Input3,
+    {
+      type: "number",
+      value: value != null ? String(value) : "",
+      placeholder,
+      disabled,
+      onChange: handleChange,
+      onBlur: handleBlur
+    }
+  ) });
+}
+
+// src/fields/NumberField/NumberFieldReadonly.tsx
+import { jsx as jsx8 } from "react/jsx-runtime";
+function NumberFieldReadonly({ fieldId, readonlyClassName }) {
+  const { formData } = useFormContext();
+  const value = formData[fieldId];
+  const display = value != null ? String(value) : "--";
+  return /* @__PURE__ */ jsx8(
+    "div",
+    {
+      className: readonlyClassName || "sy-field-readonly-value",
+      "data-testid": `numberfield-readonly-${fieldId}`,
+      children: display
+    }
+  );
+}
+
+// src/fields/NumberField/index.tsx
+import { jsx as jsx9 } from "react/jsx-runtime";
+function NumberField(props) {
+  const {
+    fieldId,
+    label,
+    behavior: propBehavior,
+    required,
+    tips,
+    defaultValue,
+    className,
+    labelClassName,
+    tipsClassName
+  } = props;
+  const { fieldBehaviors, setFieldValue, formData, registerField, unregisterField } = useFormContext();
+  const { isMobile } = useDeviceDetect();
+  const behavior = propBehavior ?? fieldBehaviors[fieldId] ?? "NORMAL";
+  useEffect2(() => {
+    registerField(fieldId);
+    if (defaultValue !== void 0 && formData[fieldId] === void 0) {
+      setFieldValue(fieldId, defaultValue);
+    }
+    return () => unregisterField(fieldId);
+  }, [fieldId]);
+  if (behavior === "HIDDEN") return null;
+  const childProps = { ...props, behavior };
+  return /* @__PURE__ */ jsx9(
+    FieldWrapper,
+    {
+      fieldId,
+      label,
+      required,
+      tips,
+      className,
+      labelClassName,
+      tipsClassName,
+      children: behavior === "READONLY" ? /* @__PURE__ */ jsx9(NumberFieldReadonly, { ...childProps }) : isMobile ? /* @__PURE__ */ jsx9(NumberFieldMobile, { ...childProps }) : /* @__PURE__ */ jsx9(NumberFieldPC, { ...childProps })
+    }
+  );
+}
+
+// src/fields/TextAreaField/index.tsx
+import { useEffect as useEffect3 } from "react";
+
+// src/fields/TextAreaField/TextAreaFieldPC.tsx
+import { Input as Input4 } from "antd";
+import { jsx as jsx10 } from "react/jsx-runtime";
+var { TextArea } = Input4;
+function TextAreaFieldPC({
+  fieldId,
+  placeholder,
+  inputClassName,
+  behavior,
+  rows,
+  maxLength,
+  showCount,
+  onChange,
+  onBlur
+}) {
+  const { formData, setFieldValue } = useFormContext();
+  const value = formData[fieldId] ?? "";
+  const disabled = behavior === "DISABLED";
+  const handleChange = (e) => {
+    const v = e.target.value;
+    setFieldValue(fieldId, v);
+    onChange?.(v);
+  };
+  const handleBlur = (e) => {
+    onBlur?.(e.target.value);
+  };
+  return /* @__PURE__ */ jsx10(
+    TextArea,
+    {
+      className: inputClassName,
+      style: { width: "100%" },
+      value,
+      placeholder,
+      disabled,
+      rows,
+      maxLength,
+      showCount,
+      onChange: handleChange,
+      onBlur: handleBlur,
+      "data-testid": `textareafield-input-${fieldId}`
+    }
+  );
+}
+
+// src/fields/TextAreaField/TextAreaFieldMobile.tsx
+import { TextArea as TextArea2 } from "antd-mobile";
+import { jsx as jsx11 } from "react/jsx-runtime";
+function TextAreaFieldMobile({
+  fieldId,
+  placeholder,
+  inputClassName,
+  behavior,
+  rows,
+  maxLength,
+  showCount,
+  onChange,
+  onBlur
+}) {
+  const { formData, setFieldValue } = useFormContext();
+  const value = formData[fieldId] ?? "";
+  const disabled = behavior === "DISABLED";
+  const handleChange = (v) => {
+    setFieldValue(fieldId, v);
+    onChange?.(v);
+  };
+  const handleBlur = () => {
+    onBlur?.(value);
+  };
+  return /* @__PURE__ */ jsx11("div", { className: inputClassName, "data-testid": `textareafield-input-${fieldId}`, children: /* @__PURE__ */ jsx11(
+    TextArea2,
+    {
+      value,
+      placeholder,
+      disabled,
+      rows,
+      maxLength,
+      showCount,
+      onChange: handleChange,
+      onBlur: handleBlur
+    }
+  ) });
+}
+
+// src/fields/TextAreaField/TextAreaFieldReadonly.tsx
+import { jsx as jsx12 } from "react/jsx-runtime";
+function TextAreaFieldReadonly({ fieldId, readonlyClassName }) {
+  const { formData } = useFormContext();
+  const value = formData[fieldId];
+  const display = value != null && value !== "" ? String(value) : "--";
+  return /* @__PURE__ */ jsx12(
+    "div",
+    {
+      className: readonlyClassName || "sy-field-readonly-value",
+      "data-testid": `textareafield-readonly-${fieldId}`,
+      style: { whiteSpace: "pre-wrap" },
+      children: display
+    }
+  );
+}
+
+// src/fields/TextAreaField/index.tsx
+import { jsx as jsx13 } from "react/jsx-runtime";
+function TextAreaField(props) {
+  const {
+    fieldId,
+    label,
+    behavior: propBehavior,
+    required,
+    tips,
+    defaultValue,
+    className,
+    labelClassName,
+    tipsClassName
+  } = props;
+  const { fieldBehaviors, setFieldValue, formData, registerField, unregisterField } = useFormContext();
+  const { isMobile } = useDeviceDetect();
+  const behavior = propBehavior ?? fieldBehaviors[fieldId] ?? "NORMAL";
+  useEffect3(() => {
+    registerField(fieldId);
+    if (defaultValue !== void 0 && formData[fieldId] === void 0) {
+      setFieldValue(fieldId, defaultValue);
+    }
+    return () => unregisterField(fieldId);
+  }, [fieldId]);
+  if (behavior === "HIDDEN") return null;
+  const childProps = { ...props, behavior };
+  return /* @__PURE__ */ jsx13(
+    FieldWrapper,
+    {
+      fieldId,
+      label,
+      required,
+      tips,
+      className,
+      labelClassName,
+      tipsClassName,
+      children: behavior === "READONLY" ? /* @__PURE__ */ jsx13(TextAreaFieldReadonly, { ...childProps }) : isMobile ? /* @__PURE__ */ jsx13(TextAreaFieldMobile, { ...childProps }) : /* @__PURE__ */ jsx13(TextAreaFieldPC, { ...childProps })
+    }
+  );
+}
+
+// src/fields/SelectField/index.tsx
+import { useEffect as useEffect4 } from "react";
+
+// src/fields/SelectField/SelectFieldPC.tsx
+import { Select } from "antd";
+import { jsx as jsx14 } from "react/jsx-runtime";
+function SelectFieldPC({
+  fieldId,
+  placeholder,
+  inputClassName,
+  behavior,
+  options,
+  allowClear,
+  onChange
+}) {
+  const { formData, setFieldValue } = useFormContext();
+  const value = formData[fieldId];
+  const disabled = behavior === "DISABLED";
+  const handleChange = (val) => {
+    if (val === void 0) {
+      setFieldValue(fieldId, null);
+      onChange?.(null);
+    } else {
+      const option = options.find((o) => o.value === val) ?? null;
+      setFieldValue(fieldId, option);
+      onChange?.(option);
+    }
+  };
+  return /* @__PURE__ */ jsx14(
+    Select,
+    {
+      className: inputClassName,
+      style: { width: "100%" },
+      value: value?.value ?? void 0,
+      placeholder,
+      disabled,
+      allowClear,
+      options,
+      onChange: handleChange,
+      "data-testid": `selectfield-input-${fieldId}`
+    }
+  );
+}
+
+// src/fields/SelectField/SelectFieldMobile.tsx
+import { useState } from "react";
+import { Picker } from "antd-mobile";
+import { jsx as jsx15, jsxs as jsxs2 } from "react/jsx-runtime";
+function SelectFieldMobile({
+  fieldId,
+  placeholder,
+  inputClassName,
+  behavior,
+  options,
+  onChange
+}) {
+  const { formData, setFieldValue } = useFormContext();
+  const value = formData[fieldId];
+  const disabled = behavior === "DISABLED";
+  const [visible, setVisible] = useState(false);
+  const columns = [options.map((o) => ({ label: o.label, value: o.value }))];
+  const handleConfirm = (val) => {
+    const selected = val[0];
+    if (selected) {
+      const option = options.find((o) => o.value === selected) ?? null;
+      setFieldValue(fieldId, option);
+      onChange?.(option);
+    } else {
+      setFieldValue(fieldId, null);
+      onChange?.(null);
+    }
+  };
+  return /* @__PURE__ */ jsxs2("div", { className: inputClassName, "data-testid": `selectfield-input-${fieldId}`, children: [
+    /* @__PURE__ */ jsx15(
+      "div",
+      {
+        onClick: () => !disabled && setVisible(true),
+        "data-testid": `selectfield-trigger-${fieldId}`,
+        children: value?.label ?? placeholder ?? "\u8BF7\u9009\u62E9"
+      }
+    ),
+    /* @__PURE__ */ jsx15(
+      Picker,
+      {
+        columns,
+        visible,
+        onClose: () => setVisible(false),
+        onConfirm: handleConfirm,
+        value: value ? [value.value] : []
+      }
+    )
+  ] });
+}
+
+// src/fields/SelectField/SelectFieldReadonly.tsx
+import { jsx as jsx16 } from "react/jsx-runtime";
+function SelectFieldReadonly({ fieldId, readonlyClassName }) {
+  const { formData } = useFormContext();
+  const value = formData[fieldId];
+  const display = value?.label ?? "--";
+  return /* @__PURE__ */ jsx16(
+    "div",
+    {
+      className: readonlyClassName || "sy-field-readonly-value",
+      "data-testid": `selectfield-readonly-${fieldId}`,
+      children: display
+    }
+  );
+}
+
+// src/fields/SelectField/index.tsx
+import { jsx as jsx17 } from "react/jsx-runtime";
+function SelectField(props) {
+  const {
+    fieldId,
+    label,
+    behavior: propBehavior,
+    required,
+    tips,
+    defaultValue,
+    className,
+    labelClassName,
+    tipsClassName
+  } = props;
+  const { fieldBehaviors, setFieldValue, formData, registerField, unregisterField } = useFormContext();
+  const { isMobile } = useDeviceDetect();
+  const behavior = propBehavior ?? fieldBehaviors[fieldId] ?? "NORMAL";
+  useEffect4(() => {
+    registerField(fieldId);
+    if (defaultValue !== void 0 && formData[fieldId] === void 0) {
+      setFieldValue(fieldId, defaultValue);
+    }
+    return () => unregisterField(fieldId);
+  }, [fieldId]);
+  if (behavior === "HIDDEN") return null;
+  const childProps = { ...props, behavior };
+  return /* @__PURE__ */ jsx17(
+    FieldWrapper,
+    {
+      fieldId,
+      label,
+      required,
+      tips,
+      className,
+      labelClassName,
+      tipsClassName,
+      children: behavior === "READONLY" ? /* @__PURE__ */ jsx17(SelectFieldReadonly, { ...childProps }) : isMobile ? /* @__PURE__ */ jsx17(SelectFieldMobile, { ...childProps }) : /* @__PURE__ */ jsx17(SelectFieldPC, { ...childProps })
+    }
+  );
+}
+
+// src/fields/MultiSelectField/index.tsx
+import { useEffect as useEffect5 } from "react";
+
+// src/fields/MultiSelectField/MultiSelectFieldPC.tsx
+import { Select as Select2 } from "antd";
+import { jsx as jsx18 } from "react/jsx-runtime";
+function MultiSelectFieldPC({
+  fieldId,
+  placeholder,
+  inputClassName,
+  behavior,
+  options,
+  maxCount,
+  onChange
+}) {
+  const { formData, setFieldValue } = useFormContext();
+  const value = formData[fieldId] ?? [];
+  const disabled = behavior === "DISABLED";
+  const handleChange = (vals) => {
+    const selected = vals.map((v) => options.find((o) => o.value === v)).filter((o) => o != null);
+    setFieldValue(fieldId, selected);
+    onChange?.(selected);
+  };
+  return /* @__PURE__ */ jsx18(
+    Select2,
+    {
+      mode: "multiple",
+      className: inputClassName,
+      style: { width: "100%" },
+      value: value.map((v) => v.value),
+      placeholder,
+      disabled,
+      maxCount,
+      options,
+      onChange: handleChange,
+      "data-testid": `multiselectfield-input-${fieldId}`
+    }
+  );
+}
+
+// src/fields/MultiSelectField/MultiSelectFieldMobile.tsx
+import { Selector } from "antd-mobile";
+import { jsx as jsx19 } from "react/jsx-runtime";
+function MultiSelectFieldMobile({
+  fieldId,
+  inputClassName,
+  behavior,
+  options,
+  onChange
+}) {
+  const { formData, setFieldValue } = useFormContext();
+  const value = formData[fieldId] ?? [];
+  const disabled = behavior === "DISABLED";
+  const handleChange = (vals) => {
+    const selected = vals.map((v) => options.find((o) => o.value === v)).filter((o) => o != null);
+    setFieldValue(fieldId, selected);
+    onChange?.(selected);
+  };
+  return /* @__PURE__ */ jsx19("div", { className: inputClassName, "data-testid": `multiselectfield-input-${fieldId}`, children: /* @__PURE__ */ jsx19(
+    Selector,
+    {
+      multiple: true,
+      options,
+      value: value.map((v) => v.value),
+      onChange: handleChange,
+      disabled
+    }
+  ) });
+}
+
+// src/fields/MultiSelectField/MultiSelectFieldReadonly.tsx
+import { jsx as jsx20 } from "react/jsx-runtime";
+function MultiSelectFieldReadonly({ fieldId, readonlyClassName }) {
+  const { formData } = useFormContext();
+  const value = formData[fieldId] ?? [];
+  const display = value.length > 0 ? value.map((v) => v.label).join(", ") : "--";
+  return /* @__PURE__ */ jsx20(
+    "div",
+    {
+      className: readonlyClassName || "sy-field-readonly-value",
+      "data-testid": `multiselectfield-readonly-${fieldId}`,
+      children: display
+    }
+  );
+}
+
+// src/fields/MultiSelectField/index.tsx
+import { jsx as jsx21 } from "react/jsx-runtime";
+function MultiSelectField(props) {
+  const {
+    fieldId,
+    label,
+    behavior: propBehavior,
+    required,
+    tips,
+    defaultValue,
+    className,
+    labelClassName,
+    tipsClassName
+  } = props;
+  const { fieldBehaviors, setFieldValue, formData, registerField, unregisterField } = useFormContext();
+  const { isMobile } = useDeviceDetect();
+  const behavior = propBehavior ?? fieldBehaviors[fieldId] ?? "NORMAL";
+  useEffect5(() => {
+    registerField(fieldId);
+    if (defaultValue !== void 0 && formData[fieldId] === void 0) {
+      setFieldValue(fieldId, defaultValue);
+    }
+    return () => unregisterField(fieldId);
+  }, [fieldId]);
+  if (behavior === "HIDDEN") return null;
+  const childProps = { ...props, behavior };
+  return /* @__PURE__ */ jsx21(
+    FieldWrapper,
+    {
+      fieldId,
+      label,
+      required,
+      tips,
+      className,
+      labelClassName,
+      tipsClassName,
+      children: behavior === "READONLY" ? /* @__PURE__ */ jsx21(MultiSelectFieldReadonly, { ...childProps }) : isMobile ? /* @__PURE__ */ jsx21(MultiSelectFieldMobile, { ...childProps }) : /* @__PURE__ */ jsx21(MultiSelectFieldPC, { ...childProps })
+    }
+  );
+}
+
+// src/fields/RadioField/index.tsx
+import { useEffect as useEffect6 } from "react";
+
+// src/fields/RadioField/RadioFieldPC.tsx
+import { Radio } from "antd";
+import { jsx as jsx22 } from "react/jsx-runtime";
+function RadioFieldPC({
+  fieldId,
+  inputClassName,
+  behavior,
+  options,
+  direction,
+  onChange
+}) {
+  const { formData, setFieldValue } = useFormContext();
+  const value = formData[fieldId];
+  const disabled = behavior === "DISABLED";
+  const handleChange = (e) => {
+    const val = e.target.value;
+    const option = options.find((o) => o.value === val) ?? null;
+    setFieldValue(fieldId, option);
+    onChange?.(option);
+  };
+  const style = direction === "vertical" ? { display: "flex", flexDirection: "column", gap: 8 } : {};
+  return /* @__PURE__ */ jsx22(
+    Radio.Group,
+    {
+      className: inputClassName,
+      value: value?.value ?? void 0,
+      disabled,
+      onChange: handleChange,
+      "data-testid": `radiofield-input-${fieldId}`,
+      style,
+      children: options.map((o) => /* @__PURE__ */ jsx22(Radio, { value: o.value, children: o.label }, o.value))
+    }
+  );
+}
+
+// src/fields/RadioField/RadioFieldMobile.tsx
+import { Radio as Radio2, Space } from "antd-mobile";
+import { jsx as jsx23 } from "react/jsx-runtime";
+function RadioFieldMobile({
+  fieldId,
+  inputClassName,
+  behavior,
+  options,
+  direction,
+  onChange
+}) {
+  const { formData, setFieldValue } = useFormContext();
+  const value = formData[fieldId];
+  const disabled = behavior === "DISABLED";
+  const handleChange = (val) => {
+    const option = options.find((o) => o.value === val) ?? null;
+    setFieldValue(fieldId, option);
+    onChange?.(option);
+  };
+  return /* @__PURE__ */ jsx23("div", { className: inputClassName, "data-testid": `radiofield-input-${fieldId}`, children: /* @__PURE__ */ jsx23(Radio2.Group, { value: value?.value, onChange: handleChange, disabled, children: /* @__PURE__ */ jsx23(Space, { direction: direction === "horizontal" ? "horizontal" : "vertical", children: options.map((o) => /* @__PURE__ */ jsx23(Radio2, { value: o.value, children: o.label }, o.value)) }) }) });
+}
+
+// src/fields/RadioField/RadioFieldReadonly.tsx
+import { jsx as jsx24 } from "react/jsx-runtime";
+function RadioFieldReadonly({ fieldId, readonlyClassName }) {
+  const { formData } = useFormContext();
+  const value = formData[fieldId];
+  const display = value?.label ?? "--";
+  return /* @__PURE__ */ jsx24(
+    "div",
+    {
+      className: readonlyClassName || "sy-field-readonly-value",
+      "data-testid": `radiofield-readonly-${fieldId}`,
+      children: display
+    }
+  );
+}
+
+// src/fields/RadioField/index.tsx
+import { jsx as jsx25 } from "react/jsx-runtime";
+function RadioField(props) {
+  const {
+    fieldId,
+    label,
+    behavior: propBehavior,
+    required,
+    tips,
+    defaultValue,
+    className,
+    labelClassName,
+    tipsClassName
+  } = props;
+  const { fieldBehaviors, setFieldValue, formData, registerField, unregisterField } = useFormContext();
+  const { isMobile } = useDeviceDetect();
+  const behavior = propBehavior ?? fieldBehaviors[fieldId] ?? "NORMAL";
+  useEffect6(() => {
+    registerField(fieldId);
+    if (defaultValue !== void 0 && formData[fieldId] === void 0) {
+      setFieldValue(fieldId, defaultValue);
+    }
+    return () => unregisterField(fieldId);
+  }, [fieldId]);
+  if (behavior === "HIDDEN") return null;
+  const childProps = { ...props, behavior };
+  return /* @__PURE__ */ jsx25(
+    FieldWrapper,
+    {
+      fieldId,
+      label,
+      required,
+      tips,
+      className,
+      labelClassName,
+      tipsClassName,
+      children: behavior === "READONLY" ? /* @__PURE__ */ jsx25(RadioFieldReadonly, { ...childProps }) : isMobile ? /* @__PURE__ */ jsx25(RadioFieldMobile, { ...childProps }) : /* @__PURE__ */ jsx25(RadioFieldPC, { ...childProps })
+    }
+  );
+}
+
+// src/fields/CheckboxField/index.tsx
+import { useEffect as useEffect7 } from "react";
+
+// src/fields/CheckboxField/CheckboxFieldPC.tsx
+import { Checkbox } from "antd";
+import { jsx as jsx26 } from "react/jsx-runtime";
+function CheckboxFieldPC({
+  fieldId,
+  inputClassName,
+  behavior,
+  options,
+  direction,
+  onChange
+}) {
+  const { formData, setFieldValue } = useFormContext();
+  const value = formData[fieldId] ?? [];
+  const disabled = behavior === "DISABLED";
+  const handleChange = (vals) => {
+    const selected = vals.map((v) => options.find((o) => o.value === v)).filter((o) => o != null);
+    setFieldValue(fieldId, selected);
+    onChange?.(selected);
+  };
+  const style = direction === "vertical" ? { display: "flex", flexDirection: "column", gap: 8 } : {};
+  return /* @__PURE__ */ jsx26(
+    Checkbox.Group,
+    {
+      className: inputClassName,
+      value: value.map((v) => v.value),
+      disabled,
+      onChange: handleChange,
+      "data-testid": `checkboxfield-input-${fieldId}`,
+      style,
+      children: options.map((o) => /* @__PURE__ */ jsx26(Checkbox, { value: o.value, children: o.label }, o.value))
+    }
+  );
+}
+
+// src/fields/CheckboxField/CheckboxFieldMobile.tsx
+import { Checkbox as Checkbox2, Space as Space2 } from "antd-mobile";
+import { jsx as jsx27 } from "react/jsx-runtime";
+function CheckboxFieldMobile({
+  fieldId,
+  inputClassName,
+  behavior,
+  options,
+  direction,
+  onChange
+}) {
+  const { formData, setFieldValue } = useFormContext();
+  const value = formData[fieldId] ?? [];
+  const disabled = behavior === "DISABLED";
+  const handleChange = (vals) => {
+    const selected = vals.map((v) => options.find((o) => o.value === v)).filter((o) => o != null);
+    setFieldValue(fieldId, selected);
+    onChange?.(selected);
+  };
+  return /* @__PURE__ */ jsx27("div", { className: inputClassName, "data-testid": `checkboxfield-input-${fieldId}`, children: /* @__PURE__ */ jsx27(
+    Checkbox2.Group,
+    {
+      value: value.map((v) => v.value),
+      onChange: handleChange,
+      disabled,
+      children: /* @__PURE__ */ jsx27(Space2, { direction: direction === "horizontal" ? "horizontal" : "vertical", children: options.map((o) => /* @__PURE__ */ jsx27(Checkbox2, { value: o.value, children: o.label }, o.value)) })
+    }
+  ) });
+}
+
+// src/fields/CheckboxField/CheckboxFieldReadonly.tsx
+import { jsx as jsx28 } from "react/jsx-runtime";
+function CheckboxFieldReadonly({ fieldId, readonlyClassName }) {
+  const { formData } = useFormContext();
+  const value = formData[fieldId] ?? [];
+  const display = value.length > 0 ? value.map((v) => v.label).join(", ") : "--";
+  return /* @__PURE__ */ jsx28(
+    "div",
+    {
+      className: readonlyClassName || "sy-field-readonly-value",
+      "data-testid": `checkboxfield-readonly-${fieldId}`,
+      children: display
+    }
+  );
+}
+
+// src/fields/CheckboxField/index.tsx
+import { jsx as jsx29 } from "react/jsx-runtime";
+function CheckboxField(props) {
+  const {
+    fieldId,
+    label,
+    behavior: propBehavior,
+    required,
+    tips,
+    defaultValue,
+    className,
+    labelClassName,
+    tipsClassName
+  } = props;
+  const { fieldBehaviors, setFieldValue, formData, registerField, unregisterField } = useFormContext();
+  const { isMobile } = useDeviceDetect();
+  const behavior = propBehavior ?? fieldBehaviors[fieldId] ?? "NORMAL";
+  useEffect7(() => {
+    registerField(fieldId);
+    if (defaultValue !== void 0 && formData[fieldId] === void 0) {
+      setFieldValue(fieldId, defaultValue);
+    }
+    return () => unregisterField(fieldId);
+  }, [fieldId]);
+  if (behavior === "HIDDEN") return null;
+  const childProps = { ...props, behavior };
+  return /* @__PURE__ */ jsx29(
+    FieldWrapper,
+    {
+      fieldId,
+      label,
+      required,
+      tips,
+      className,
+      labelClassName,
+      tipsClassName,
+      children: behavior === "READONLY" ? /* @__PURE__ */ jsx29(CheckboxFieldReadonly, { ...childProps }) : isMobile ? /* @__PURE__ */ jsx29(CheckboxFieldMobile, { ...childProps }) : /* @__PURE__ */ jsx29(CheckboxFieldPC, { ...childProps })
+    }
+  );
+}
+
+// src/fields/DateField/index.tsx
+import { useEffect as useEffect8 } from "react";
+
+// src/fields/DateField/DateFieldPC.tsx
+import { DatePicker } from "antd";
+import dayjs from "dayjs";
+import { jsx as jsx30 } from "react/jsx-runtime";
+function DateFieldPC({
+  fieldId,
+  placeholder,
+  inputClassName,
+  behavior,
+  dateFormat,
+  showTime,
+  onChange
+}) {
+  const { formData, setFieldValue } = useFormContext();
+  const value = formData[fieldId];
+  const disabled = behavior === "DISABLED";
+  const format = dateFormat ?? (showTime ? "YYYY-MM-DD HH:mm:ss" : "YYYY-MM-DD");
+  const pickerValue = value && dayjs(value).isValid() ? dayjs(value) : null;
+  const handleChange = (_date, dateString) => {
+    const val = Array.isArray(dateString) ? dateString[0] : dateString ?? "";
+    setFieldValue(fieldId, val || "");
+    onChange?.(val || "");
+  };
+  return /* @__PURE__ */ jsx30(
+    DatePicker,
+    {
+      className: inputClassName,
+      style: { width: "100%" },
+      value: pickerValue,
+      placeholder,
+      disabled,
+      format,
+      showTime,
+      onChange: handleChange,
+      "data-testid": `datefield-input-${fieldId}`
+    }
+  );
+}
+
+// src/fields/DateField/DateFieldMobile.tsx
+import { useState as useState2 } from "react";
+import { DatePicker as DatePicker2 } from "antd-mobile";
+import dayjs2 from "dayjs";
+import { jsx as jsx31, jsxs as jsxs3 } from "react/jsx-runtime";
+function DateFieldMobile({
+  fieldId,
+  placeholder,
+  inputClassName,
+  behavior,
+  dateFormat,
+  showTime,
+  onChange
+}) {
+  const { formData, setFieldValue } = useFormContext();
+  const value = formData[fieldId];
+  const disabled = behavior === "DISABLED";
+  const [visible, setVisible] = useState2(false);
+  const format = dateFormat ?? (showTime ? "YYYY-MM-DD HH:mm:ss" : "YYYY-MM-DD");
+  const pickerValue = value && dayjs2(value).isValid() ? dayjs2(value).toDate() : void 0;
+  const handleConfirm = (date) => {
+    const dateStr = dayjs2(date).format(format);
+    setFieldValue(fieldId, dateStr);
+    onChange?.(dateStr);
+  };
+  return /* @__PURE__ */ jsxs3("div", { className: inputClassName, "data-testid": `datefield-input-${fieldId}`, children: [
+    /* @__PURE__ */ jsx31(
+      "div",
+      {
+        onClick: () => !disabled && setVisible(true),
+        "data-testid": `datefield-trigger-${fieldId}`,
+        children: value || placeholder || "\u8BF7\u9009\u62E9\u65E5\u671F"
+      }
+    ),
+    /* @__PURE__ */ jsx31(
+      DatePicker2,
+      {
+        visible,
+        value: pickerValue,
+        precision: showTime ? "second" : "day",
+        onClose: () => setVisible(false),
+        onConfirm: handleConfirm
+      }
+    )
+  ] });
+}
+
+// src/fields/DateField/DateFieldReadonly.tsx
+import { jsx as jsx32 } from "react/jsx-runtime";
+function DateFieldReadonly({ fieldId, readonlyClassName }) {
+  const { formData } = useFormContext();
+  const value = formData[fieldId];
+  const display = value && value !== "" ? value : "--";
+  return /* @__PURE__ */ jsx32(
+    "div",
+    {
+      className: readonlyClassName || "sy-field-readonly-value",
+      "data-testid": `datefield-readonly-${fieldId}`,
+      children: display
+    }
+  );
+}
+
+// src/fields/DateField/index.tsx
+import { jsx as jsx33 } from "react/jsx-runtime";
+function DateField(props) {
+  const {
+    fieldId,
+    label,
+    behavior: propBehavior,
+    required,
+    tips,
+    defaultValue,
+    className,
+    labelClassName,
+    tipsClassName
+  } = props;
+  const { fieldBehaviors, setFieldValue, formData, registerField, unregisterField } = useFormContext();
+  const { isMobile } = useDeviceDetect();
+  const behavior = propBehavior ?? fieldBehaviors[fieldId] ?? "NORMAL";
+  useEffect8(() => {
+    registerField(fieldId);
+    if (defaultValue !== void 0 && formData[fieldId] === void 0) {
+      setFieldValue(fieldId, defaultValue);
+    }
+    return () => unregisterField(fieldId);
+  }, [fieldId]);
+  if (behavior === "HIDDEN") return null;
+  const childProps = { ...props, behavior };
+  return /* @__PURE__ */ jsx33(
+    FieldWrapper,
+    {
+      fieldId,
+      label,
+      required,
+      tips,
+      className,
+      labelClassName,
+      tipsClassName,
+      children: behavior === "READONLY" ? /* @__PURE__ */ jsx33(DateFieldReadonly, { ...childProps }) : isMobile ? /* @__PURE__ */ jsx33(DateFieldMobile, { ...childProps }) : /* @__PURE__ */ jsx33(DateFieldPC, { ...childProps })
+    }
+  );
+}
+
+// src/fields/CascadeDateField/index.tsx
+import { useEffect as useEffect9 } from "react";
+
+// src/fields/CascadeDateField/CascadeDateFieldPC.tsx
+import { DatePicker as DatePicker3 } from "antd";
+import dayjs3 from "dayjs";
+import { jsx as jsx34 } from "react/jsx-runtime";
+var { RangePicker } = DatePicker3;
+function CascadeDateFieldPC({
+  fieldId,
+  placeholder,
+  inputClassName,
+  behavior,
+  dateFormat,
+  onChange
+}) {
+  const { formData, setFieldValue } = useFormContext();
+  const value = formData[fieldId];
+  const disabled = behavior === "DISABLED";
+  const format = dateFormat ?? "YYYY-MM-DD";
+  const startValue = value?.start && dayjs3(value.start).isValid() ? dayjs3(value.start) : null;
+  const endValue = value?.end && dayjs3(value.end).isValid() ? dayjs3(value.end) : null;
+  const pickerValue = startValue || endValue ? [startValue, endValue] : null;
+  const handleChange = (_dates, dateStrings) => {
+    const [start, end] = dateStrings;
+    if (start && end) {
+      const val = { start, end };
+      setFieldValue(fieldId, val);
+      onChange?.(val);
+    } else {
+      setFieldValue(fieldId, null);
+      onChange?.(null);
+    }
+  };
+  return /* @__PURE__ */ jsx34(
+    RangePicker,
+    {
+      className: inputClassName,
+      style: { width: "100%" },
+      value: pickerValue,
+      placeholder: placeholder ? [placeholder, placeholder] : void 0,
+      disabled,
+      format,
+      onChange: handleChange,
+      "data-testid": `cascadedatefield-input-${fieldId}`
+    }
+  );
+}
+
+// src/fields/CascadeDateField/CascadeDateFieldMobile.tsx
+import { useState as useState3 } from "react";
+import { DatePicker as DatePicker4 } from "antd-mobile";
+import dayjs4 from "dayjs";
+import { jsx as jsx35, jsxs as jsxs4 } from "react/jsx-runtime";
+function CascadeDateFieldMobile({
+  fieldId,
+  inputClassName,
+  behavior,
+  startLabel,
+  endLabel,
+  dateFormat,
+  onChange
+}) {
+  const { formData, setFieldValue } = useFormContext();
+  const value = formData[fieldId];
+  const disabled = behavior === "DISABLED";
+  const [startVisible, setStartVisible] = useState3(false);
+  const [endVisible, setEndVisible] = useState3(false);
+  const format = dateFormat ?? "YYYY-MM-DD";
+  const startValue = value?.start && dayjs4(value.start).isValid() ? dayjs4(value.start).toDate() : void 0;
+  const endValue = value?.end && dayjs4(value.end).isValid() ? dayjs4(value.end).toDate() : void 0;
+  const handleStartConfirm = (date) => {
+    const dateStr = dayjs4(date).format(format);
+    const newVal = { start: dateStr, end: value?.end ?? "" };
+    setFieldValue(fieldId, newVal);
+    onChange?.(newVal);
+  };
+  const handleEndConfirm = (date) => {
+    const dateStr = dayjs4(date).format(format);
+    const newVal = { start: value?.start ?? "", end: dateStr };
+    setFieldValue(fieldId, newVal);
+    onChange?.(newVal);
+  };
+  return /* @__PURE__ */ jsxs4("div", { className: inputClassName, "data-testid": `cascadedatefield-input-${fieldId}`, children: [
+    /* @__PURE__ */ jsx35(
+      "div",
+      {
+        onClick: () => !disabled && setStartVisible(true),
+        "data-testid": `cascadedatefield-start-${fieldId}`,
+        children: value?.start || startLabel || "\u5F00\u59CB\u65E5\u671F"
+      }
+    ),
+    /* @__PURE__ */ jsx35("span", { children: " ~ " }),
+    /* @__PURE__ */ jsx35(
+      "div",
+      {
+        onClick: () => !disabled && setEndVisible(true),
+        "data-testid": `cascadedatefield-end-${fieldId}`,
+        children: value?.end || endLabel || "\u7ED3\u675F\u65E5\u671F"
+      }
+    ),
+    /* @__PURE__ */ jsx35(
+      DatePicker4,
+      {
+        visible: startVisible,
+        value: startValue,
+        onClose: () => setStartVisible(false),
+        onConfirm: handleStartConfirm
+      }
+    ),
+    /* @__PURE__ */ jsx35(
+      DatePicker4,
+      {
+        visible: endVisible,
+        value: endValue,
+        onClose: () => setEndVisible(false),
+        onConfirm: handleEndConfirm
+      }
+    )
+  ] });
+}
+
+// src/fields/CascadeDateField/CascadeDateFieldReadonly.tsx
+import { jsx as jsx36 } from "react/jsx-runtime";
+function CascadeDateFieldReadonly({ fieldId, readonlyClassName }) {
+  const { formData } = useFormContext();
+  const value = formData[fieldId];
+  const display = value && value.start && value.end ? `${value.start} ~ ${value.end}` : "--";
+  return /* @__PURE__ */ jsx36(
+    "div",
+    {
+      className: readonlyClassName || "sy-field-readonly-value",
+      "data-testid": `cascadedatefield-readonly-${fieldId}`,
+      children: display
+    }
+  );
+}
+
+// src/fields/CascadeDateField/index.tsx
+import { jsx as jsx37 } from "react/jsx-runtime";
+function CascadeDateField(props) {
+  const {
+    fieldId,
+    label,
+    behavior: propBehavior,
+    required,
+    tips,
+    defaultValue,
+    className,
+    labelClassName,
+    tipsClassName
+  } = props;
+  const { fieldBehaviors, setFieldValue, formData, registerField, unregisterField } = useFormContext();
+  const { isMobile } = useDeviceDetect();
+  const behavior = propBehavior ?? fieldBehaviors[fieldId] ?? "NORMAL";
+  useEffect9(() => {
+    registerField(fieldId);
+    if (defaultValue !== void 0 && formData[fieldId] === void 0) {
+      setFieldValue(fieldId, defaultValue);
+    }
+    return () => unregisterField(fieldId);
+  }, [fieldId]);
+  if (behavior === "HIDDEN") return null;
+  const childProps = { ...props, behavior };
+  return /* @__PURE__ */ jsx37(
+    FieldWrapper,
+    {
+      fieldId,
+      label,
+      required,
+      tips,
+      className,
+      labelClassName,
+      tipsClassName,
+      children: behavior === "READONLY" ? /* @__PURE__ */ jsx37(CascadeDateFieldReadonly, { ...childProps }) : isMobile ? /* @__PURE__ */ jsx37(CascadeDateFieldMobile, { ...childProps }) : /* @__PURE__ */ jsx37(CascadeDateFieldPC, { ...childProps })
+    }
+  );
+}
+
+// src/fields/AttachmentField/index.tsx
+import { useEffect as useEffect10 } from "react";
+
+// src/fields/AttachmentField/AttachmentFieldPC.tsx
+import { Upload, Button } from "antd";
+import { jsx as jsx38 } from "react/jsx-runtime";
+var createLocalItem = (file) => ({
+  id: file.uid || `${Date.now()}-${file.name}`,
+  uid: file.uid || `${Date.now()}-${file.name}`,
+  url: "",
+  name: file.name,
+  status: "uploading",
+  size: file.size,
+  percent: 0
+});
+function AttachmentFieldPC({
+  fieldId,
+  behavior,
+  maxCount,
+  accept,
+  maxSize,
+  bucketName = "attachments",
+  multiple = true,
+  allowedTypes,
+  onChange
+}) {
+  const { formData, setFieldValue, api } = useFormContext();
+  const value = formData[fieldId] ?? [];
+  const disabled = behavior === "DISABLED";
+  const setValue = (items) => {
+    setFieldValue(fieldId, items);
+    onChange?.(items);
+  };
+  const handleChange = (info) => {
+    const fileList2 = info.fileList ?? [];
+    const items = fileList2.map((f) => {
+      const item = {
+        url: String(f.url ?? f.response?.url ?? ""),
+        name: String(f.name ?? ""),
+        id: String(f.uid ?? f.response?.id ?? "")
+      };
+      if (f.uid ?? f.response?.uid) item.uid = String(f.uid ?? f.response?.uid);
+      if (f.status) item.status = f.status;
+      if (f.percent !== void 0) item.percent = f.percent;
+      if (f.objectName ?? f.response?.objectName)
+        item.objectName = f.objectName ?? f.response?.objectName;
+      if (f.bucketName ?? f.response?.bucketName)
+        item.bucketName = f.bucketName ?? f.response?.bucketName;
+      if (f.size ?? f.response?.size) item.size = f.size ?? f.response?.size;
+      if (f.type ?? f.response?.contentType) item.contentType = f.type ?? f.response?.contentType;
+      return item;
+    });
+    setValue(items);
+  };
+  const handleRemove = (file) => {
+    const removed = value.find((item) => item.id === file.uid || item.uid === file.uid);
+    const newValue = value.filter((item) => item.id !== file.uid && item.uid !== file.uid);
+    setValue(newValue);
+    if (removed?.objectName) {
+      api.deleteFile(removed.objectName, removed.bucketName || bucketName).catch(() => void 0);
+    }
+  };
+  const handlePreview = async (file) => {
+    const item = value.find((current) => current.id === file.uid || current.uid === file.uid);
+    let url = item?.downloadUrl || item?.url || file.url;
+    if (item?.objectName) {
+      const ticket = await api.createDownloadTicket(
+        item.bucketName || bucketName,
+        item.objectName,
+        item.name
+      );
+      url = typeof ticket === "string" ? ticket : ticket?.downloadUrl || ticket?.url || url;
+    }
+    if (url) window.open(url, "_blank", "noopener,noreferrer");
+  };
+  const fileList = value.map((item) => ({
+    uid: item.id,
+    name: item.name,
+    url: item.url,
+    status: item.status ?? "done",
+    percent: item.percent
+  }));
+  const beforeUpload = (file) => {
+    if (maxSize && file.size / 1024 / 1024 > maxSize) {
+      return false;
+    }
+    const ext = String(file.name || "").split(".").pop()?.toLowerCase();
+    if (allowedTypes?.length && ext && !allowedTypes.includes(ext)) {
+      return false;
+    }
+    return true;
+  };
+  const customRequest = async ({ file, onProgress, onSuccess, onError }) => {
+    const currentFile = file;
+    const localItem = createLocalItem(currentFile);
+    const nextValue = multiple ? [...value, localItem].slice(0, maxCount ?? Infinity) : [localItem];
+    setValue(nextValue);
+    try {
+      const uploaded = await api.uploadFile(currentFile, bucketName, (percent) => {
+        onProgress?.({ percent });
+        setValue(
+          nextValue.map(
+            (item) => item.id === localItem.id ? { ...item, percent, status: "uploading" } : item
+          )
+        );
+      });
+      const completed = {
+        ...uploaded,
+        id: uploaded.id || localItem.id,
+        uid: uploaded.uid || localItem.uid
+      };
+      setValue(nextValue.map((item) => item.id === localItem.id ? completed : item));
+      onSuccess?.(completed);
+    } catch (error) {
+      const failed = {
+        ...localItem,
+        status: "error",
+        error: error?.message || "\u4E0A\u4F20\u5931\u8D25"
+      };
+      setValue(nextValue.map((item) => item.id === localItem.id ? failed : item));
+      onError?.(error);
+    }
+  };
+  return /* @__PURE__ */ jsx38(
+    Upload,
+    {
+      "data-testid": `attachmentfield-input-${fieldId}`,
+      fileList,
+      customRequest,
+      accept,
+      maxCount,
+      multiple,
+      disabled,
+      onChange: handleChange,
+      onRemove: handleRemove,
+      onPreview: handlePreview,
+      beforeUpload,
+      children: /* @__PURE__ */ jsx38(Button, { disabled, "data-testid": `attachmentfield-upload-btn-${fieldId}`, children: "\u4E0A\u4F20\u6587\u4EF6" })
+    }
+  );
+}
+
+// src/fields/AttachmentField/AttachmentFieldMobile.tsx
+import { jsx as jsx39, jsxs as jsxs5 } from "react/jsx-runtime";
+function AttachmentFieldMobile({
+  fieldId,
+  behavior,
+  maxCount,
+  accept,
+  maxSize,
+  bucketName = "attachments",
+  multiple = true,
+  allowedTypes,
+  onChange
+}) {
+  const { formData, setFieldValue, api } = useFormContext();
+  const value = formData[fieldId] ?? [];
+  const disabled = behavior === "DISABLED";
+  const handleFileSelect = (e) => {
+    const files = e.target.files;
+    if (!files) return;
+    const acceptedFiles = Array.from(files).filter((file) => {
+      if (maxSize && file.size / 1024 / 1024 > maxSize) return false;
+      const ext = String(file.name || "").split(".").pop()?.toLowerCase();
+      if (allowedTypes?.length && ext && !allowedTypes.includes(ext)) return false;
+      return true;
+    });
+    const newItems = acceptedFiles.map((f) => {
+      const uid = `${Date.now()}-${f.name}`;
+      return {
+        url: URL.createObjectURL(f),
+        name: f.name,
+        id: uid,
+        uid,
+        status: "uploading",
+        size: f.size
+      };
+    });
+    const merged = [...value, ...newItems].slice(0, maxCount ?? Infinity);
+    setFieldValue(fieldId, merged);
+    onChange?.(merged);
+    acceptedFiles.forEach((file, index) => {
+      const localId = newItems[index]?.id;
+      api.uploadFile(file, bucketName).then((uploaded) => {
+        const current = (formData[fieldId] ?? merged).map(
+          (item) => item.id === localId ? { ...uploaded, id: uploaded.id || localId } : item
+        );
+        setFieldValue(fieldId, current);
+        onChange?.(current);
+      }).catch(() => void 0);
+    });
+  };
+  const handleRemove = (id) => {
+    const removed = value.find((item) => item.id === id);
+    const newValue = value.filter((item) => item.id !== id);
+    setFieldValue(fieldId, newValue);
+    onChange?.(newValue);
+    if (removed?.objectName) {
+      api.deleteFile(removed.objectName, removed.bucketName || bucketName).catch(() => void 0);
+    }
+  };
+  return /* @__PURE__ */ jsxs5("div", { "data-testid": `attachmentfield-mobile-${fieldId}`, children: [
+    /* @__PURE__ */ jsx39(
+      "input",
+      {
+        type: "file",
+        accept,
+        multiple,
+        disabled,
+        onChange: handleFileSelect,
+        "data-testid": `attachmentfield-file-input-${fieldId}`
+      }
+    ),
+    /* @__PURE__ */ jsx39("ul", { "data-testid": `attachmentfield-list-${fieldId}`, children: value.map((item) => /* @__PURE__ */ jsxs5("li", { "data-testid": `attachmentfield-item-${item.id}`, children: [
+      /* @__PURE__ */ jsx39("span", { children: item.name }),
+      /* @__PURE__ */ jsx39(
+        "button",
+        {
+          type: "button",
+          disabled,
+          onClick: () => handleRemove(item.id),
+          "data-testid": `attachmentfield-remove-${item.id}`,
+          children: "\u5220\u9664"
+        }
+      )
+    ] }, item.id)) })
+  ] });
+}
+
+// src/fields/AttachmentField/AttachmentFieldReadonly.tsx
+import { jsx as jsx40 } from "react/jsx-runtime";
+function AttachmentFieldReadonly({ fieldId, readonlyClassName }) {
+  const { formData, api } = useFormContext();
+  const value = formData[fieldId] ?? [];
+  if (value.length === 0) {
+    return /* @__PURE__ */ jsx40(
+      "div",
+      {
+        className: readonlyClassName || "sy-field-readonly-value",
+        "data-testid": `attachmentfield-readonly-${fieldId}`,
+        children: "--"
+      }
+    );
+  }
+  return /* @__PURE__ */ jsx40(
+    "ul",
+    {
+      className: readonlyClassName || "sy-field-readonly-value",
+      "data-testid": `attachmentfield-readonly-${fieldId}`,
+      children: value.map((item) => /* @__PURE__ */ jsx40("li", { children: /* @__PURE__ */ jsx40(
+        "a",
+        {
+          href: item.downloadUrl || item.url || "#",
+          target: "_blank",
+          rel: "noopener noreferrer",
+          onClick: async (event) => {
+            if (!item.objectName) return;
+            event.preventDefault();
+            const ticket = await api.createDownloadTicket(
+              item.bucketName || "attachments",
+              item.objectName,
+              item.name
+            );
+            const url = typeof ticket === "string" ? ticket : ticket?.downloadUrl || ticket?.url || item.downloadUrl || item.url;
+            if (url) window.open(url, "_blank", "noopener,noreferrer");
+          },
+          children: item.name
+        }
+      ) }, item.id))
+    }
+  );
+}
+
+// src/fields/AttachmentField/index.tsx
+import { jsx as jsx41 } from "react/jsx-runtime";
+function AttachmentField(props) {
+  const {
+    fieldId,
+    label,
+    behavior: propBehavior,
+    required,
+    tips,
+    defaultValue,
+    className,
+    labelClassName,
+    tipsClassName
+  } = props;
+  const { fieldBehaviors, setFieldValue, formData, registerField, unregisterField } = useFormContext();
+  const { isMobile } = useDeviceDetect();
+  const behavior = propBehavior ?? fieldBehaviors[fieldId] ?? "NORMAL";
+  useEffect10(() => {
+    registerField(fieldId);
+    if (defaultValue !== void 0 && formData[fieldId] === void 0) {
+      setFieldValue(fieldId, defaultValue);
+    }
+    return () => unregisterField(fieldId);
+  }, [fieldId]);
+  if (behavior === "HIDDEN") return null;
+  const childProps = { ...props, behavior };
+  return /* @__PURE__ */ jsx41(
+    FieldWrapper,
+    {
+      fieldId,
+      label,
+      required,
+      tips,
+      className,
+      labelClassName,
+      tipsClassName,
+      children: behavior === "READONLY" ? /* @__PURE__ */ jsx41(AttachmentFieldReadonly, { ...childProps }) : isMobile ? /* @__PURE__ */ jsx41(AttachmentFieldMobile, { ...childProps }) : /* @__PURE__ */ jsx41(AttachmentFieldPC, { ...childProps })
+    }
+  );
+}
+
+// src/fields/ImageField/index.tsx
+import { useEffect as useEffect11 } from "react";
+
+// src/fields/ImageField/ImageFieldPC.tsx
+import { Upload as Upload2 } from "antd";
+import { jsx as jsx42 } from "react/jsx-runtime";
+var createLocalItem2 = (file) => ({
+  id: file.uid || `${Date.now()}-${file.name}`,
+  uid: file.uid || `${Date.now()}-${file.name}`,
+  url: "",
+  name: file.name,
+  status: "uploading",
+  size: file.size,
+  percent: 0
+});
+function ImageFieldPC({
+  fieldId,
+  behavior,
+  maxCount,
+  accept,
+  bucketName = "images",
+  multiple = true,
+  maxSize,
+  onChange
+}) {
+  const { formData, setFieldValue, api } = useFormContext();
+  const value = formData[fieldId] ?? [];
+  const disabled = behavior === "DISABLED";
+  const setValue = (items) => {
+    setFieldValue(fieldId, items);
+    onChange?.(items);
+  };
+  const handleChange = (info) => {
+    const fileList2 = info.fileList ?? [];
+    const items = fileList2.map((f) => {
+      const item = {
+        url: String(f.url ?? f.thumbUrl ?? f.response?.url ?? ""),
+        name: String(f.name ?? ""),
+        id: String(f.uid ?? f.response?.id ?? "")
+      };
+      if (f.uid ?? f.response?.uid) item.uid = String(f.uid ?? f.response?.uid);
+      if (f.status) item.status = f.status;
+      if (f.percent !== void 0) item.percent = f.percent;
+      if (f.objectName ?? f.response?.objectName)
+        item.objectName = f.objectName ?? f.response?.objectName;
+      if (f.bucketName ?? f.response?.bucketName)
+        item.bucketName = f.bucketName ?? f.response?.bucketName;
+      if (f.size ?? f.response?.size) item.size = f.size ?? f.response?.size;
+      if (f.type ?? f.response?.contentType) item.contentType = f.type ?? f.response?.contentType;
+      return item;
+    });
+    setValue(items);
+  };
+  const handleRemove = (file) => {
+    const removed = value.find((item) => item.id === file.uid || item.uid === file.uid);
+    const newValue = value.filter((item) => item.id !== file.uid && item.uid !== file.uid);
+    setValue(newValue);
+    if (removed?.objectName) {
+      api.deleteFile(removed.objectName, removed.bucketName || bucketName).catch(() => void 0);
+    }
+  };
+  const handlePreview = async (file) => {
+    const item = value.find((current) => current.id === file.uid || current.uid === file.uid);
+    let url = item?.previewUrl || item?.url || file.url || file.thumbUrl;
+    if (item?.objectName) {
+      const ticket = await api.createFileAccessTicket(
+        item.bucketName || bucketName,
+        item.objectName,
+        item.name,
+        "preview"
+      );
+      url = typeof ticket === "string" ? ticket : ticket?.previewUrl || ticket?.url || url;
+    }
+    if (url) window.open(url, "_blank", "noopener,noreferrer");
+  };
+  const fileList = value.map((item) => ({
+    uid: item.id,
+    name: item.name,
+    url: item.url,
+    thumbUrl: item.url,
+    status: item.status ?? "done",
+    percent: item.percent
+  }));
+  const beforeUpload = (file) => {
+    if (!String(file.type || "").startsWith("image/") && !/\.(png|jpe?g|gif|bmp|svg|webp)$/i.test(file.name)) {
+      return false;
+    }
+    if (maxSize && file.size / 1024 / 1024 > maxSize) {
+      return false;
+    }
+    return true;
+  };
+  const customRequest = async ({ file, onProgress, onSuccess, onError }) => {
+    const currentFile = file;
+    const localItem = createLocalItem2(currentFile);
+    const nextValue = multiple ? [...value, localItem].slice(0, maxCount ?? Infinity) : [localItem];
+    setValue(nextValue);
+    try {
+      const uploaded = await api.uploadFile(currentFile, bucketName, (percent) => {
+        onProgress?.({ percent });
+        setValue(
+          nextValue.map(
+            (item) => item.id === localItem.id ? { ...item, percent, status: "uploading" } : item
+          )
+        );
+      });
+      const completed = {
+        ...uploaded,
+        id: uploaded.id || localItem.id,
+        uid: uploaded.uid || localItem.uid
+      };
+      setValue(nextValue.map((item) => item.id === localItem.id ? completed : item));
+      onSuccess?.(completed);
+    } catch (error) {
+      const failed = {
+        ...localItem,
+        status: "error",
+        error: error?.message || "\u4E0A\u4F20\u5931\u8D25"
+      };
+      setValue(nextValue.map((item) => item.id === localItem.id ? failed : item));
+      onError?.(error);
+    }
+  };
+  return /* @__PURE__ */ jsx42(
+    Upload2,
+    {
+      "data-testid": `imagefield-input-${fieldId}`,
+      listType: "picture-card",
+      fileList,
+      customRequest,
+      accept: accept ?? "image/*",
+      maxCount,
+      multiple,
+      disabled,
+      onChange: handleChange,
+      onRemove: handleRemove,
+      onPreview: handlePreview,
+      beforeUpload,
+      children: (!maxCount || value.length < maxCount) && /* @__PURE__ */ jsx42("div", { "data-testid": `imagefield-upload-btn-${fieldId}`, children: "+ \u4E0A\u4F20\u56FE\u7247" })
+    }
+  );
+}
+
+// src/fields/ImageField/ImageFieldMobile.tsx
+import { jsx as jsx43, jsxs as jsxs6 } from "react/jsx-runtime";
+function ImageFieldMobile({
+  fieldId,
+  behavior,
+  maxCount,
+  accept,
+  bucketName = "images",
+  multiple = true,
+  maxSize,
+  onChange
+}) {
+  const { formData, setFieldValue, api } = useFormContext();
+  const value = formData[fieldId] ?? [];
+  const disabled = behavior === "DISABLED";
+  const handleFileSelect = (e) => {
+    const files = e.target.files;
+    if (!files) return;
+    const acceptedFiles = Array.from(files).filter((file) => {
+      const isImage = String(file.type || "").startsWith("image/") || /\.(png|jpe?g|gif|bmp|svg|webp)$/i.test(file.name);
+      if (!isImage) return false;
+      if (maxSize && file.size / 1024 / 1024 > maxSize) return false;
+      return true;
+    });
+    const newItems = acceptedFiles.map((f) => {
+      const uid = `${Date.now()}-${f.name}`;
+      return {
+        url: URL.createObjectURL(f),
+        name: f.name,
+        id: uid,
+        uid,
+        status: "uploading",
+        size: f.size
+      };
+    });
+    const merged = [...value, ...newItems].slice(0, maxCount ?? Infinity);
+    setFieldValue(fieldId, merged);
+    onChange?.(merged);
+    acceptedFiles.forEach((file, index) => {
+      const localId = newItems[index]?.id;
+      api.uploadFile(file, bucketName).then((uploaded) => {
+        const current = (formData[fieldId] ?? merged).map(
+          (item) => item.id === localId ? { ...uploaded, id: uploaded.id || localId } : item
+        );
+        setFieldValue(fieldId, current);
+        onChange?.(current);
+      }).catch(() => void 0);
+    });
+  };
+  const handleRemove = (id) => {
+    const removed = value.find((item) => item.id === id);
+    const newValue = value.filter((item) => item.id !== id);
+    setFieldValue(fieldId, newValue);
+    onChange?.(newValue);
+    if (removed?.objectName) {
+      api.deleteFile(removed.objectName, removed.bucketName || bucketName).catch(() => void 0);
+    }
+  };
+  return /* @__PURE__ */ jsxs6("div", { "data-testid": `imagefield-mobile-${fieldId}`, children: [
+    /* @__PURE__ */ jsx43(
+      "input",
+      {
+        type: "file",
+        accept: accept ?? "image/*",
+        multiple,
+        disabled,
+        onChange: handleFileSelect,
+        "data-testid": `imagefield-file-input-${fieldId}`
+      }
+    ),
+    /* @__PURE__ */ jsx43("div", { "data-testid": `imagefield-grid-${fieldId}`, children: value.map((item) => /* @__PURE__ */ jsxs6("div", { "data-testid": `imagefield-thumb-${item.id}`, children: [
+      /* @__PURE__ */ jsx43("img", { src: item.url, alt: item.name }),
+      /* @__PURE__ */ jsx43(
+        "button",
+        {
+          type: "button",
+          disabled,
+          onClick: () => handleRemove(item.id),
+          "data-testid": `imagefield-remove-${item.id}`,
+          children: "\u5220\u9664"
+        }
+      )
+    ] }, item.id)) })
+  ] });
+}
+
+// src/fields/ImageField/ImageFieldReadonly.tsx
+import { jsx as jsx44 } from "react/jsx-runtime";
+function ImageFieldReadonly({ fieldId, readonlyClassName }) {
+  const { formData, api } = useFormContext();
+  const value = formData[fieldId] ?? [];
+  if (value.length === 0) {
+    return /* @__PURE__ */ jsx44(
+      "div",
+      {
+        className: readonlyClassName || "sy-field-readonly-value",
+        "data-testid": `imagefield-readonly-${fieldId}`,
+        children: "--"
+      }
+    );
+  }
+  return /* @__PURE__ */ jsx44(
+    "div",
+    {
+      className: readonlyClassName || "sy-field-readonly-value",
+      "data-testid": `imagefield-readonly-${fieldId}`,
+      children: value.map((item) => /* @__PURE__ */ jsx44(
+        "img",
+        {
+          src: item.previewUrl || item.url,
+          alt: item.name,
+          "data-testid": `imagefield-readonly-img-${item.id}`,
+          style: { width: 80, height: 80, objectFit: "cover", marginRight: 8 },
+          onClick: async () => {
+            let url = item.previewUrl || item.url;
+            if (item.objectName) {
+              const ticket = await api.createFileAccessTicket(
+                item.bucketName || "images",
+                item.objectName,
+                item.name,
+                "preview"
+              );
+              url = typeof ticket === "string" ? ticket : ticket?.previewUrl || ticket?.url || url;
+            }
+            if (url) window.open(url, "_blank", "noopener,noreferrer");
+          }
+        },
+        item.id
+      ))
+    }
+  );
+}
+
+// src/fields/ImageField/index.tsx
+import { jsx as jsx45 } from "react/jsx-runtime";
+function ImageField(props) {
+  const {
+    fieldId,
+    label,
+    behavior: propBehavior,
+    required,
+    tips,
+    defaultValue,
+    className,
+    labelClassName,
+    tipsClassName
+  } = props;
+  const { fieldBehaviors, setFieldValue, formData, registerField, unregisterField } = useFormContext();
+  const { isMobile } = useDeviceDetect();
+  const behavior = propBehavior ?? fieldBehaviors[fieldId] ?? "NORMAL";
+  useEffect11(() => {
+    registerField(fieldId);
+    if (defaultValue !== void 0 && formData[fieldId] === void 0) {
+      setFieldValue(fieldId, defaultValue);
+    }
+    return () => unregisterField(fieldId);
+  }, [fieldId]);
+  if (behavior === "HIDDEN") return null;
+  const childProps = { ...props, behavior };
+  return /* @__PURE__ */ jsx45(
+    FieldWrapper,
+    {
+      fieldId,
+      label,
+      required,
+      tips,
+      className,
+      labelClassName,
+      tipsClassName,
+      children: behavior === "READONLY" ? /* @__PURE__ */ jsx45(ImageFieldReadonly, { ...childProps }) : isMobile ? /* @__PURE__ */ jsx45(ImageFieldMobile, { ...childProps }) : /* @__PURE__ */ jsx45(ImageFieldPC, { ...childProps })
+    }
+  );
+}
+
+// src/fields/SubFormField/index.tsx
+import { useEffect as useEffect12 } from "react";
+
+// src/fields/SubFormField/SubFormCell.tsx
+import { useMemo } from "react";
+import { jsx as jsx46 } from "react/jsx-runtime";
+var stringifyFallbackValue = (value) => {
+  if (value === void 0 || value === null) return "";
+  if (typeof value === "string" || typeof value === "number") return value;
+  return JSON.stringify(value);
+};
+function SubFormCell({
+  parentFieldId,
+  rowIndex,
+  column,
+  row,
+  behavior,
+  fallbackTestId,
+  onCellChange
+}) {
+  const Component = useComponent(column.componentName);
+  const parentContext = useFormContext();
+  const scopedFieldId = `${parentFieldId}.${rowIndex}.${column.fieldId}`;
+  const cellValue = row[column.fieldId];
+  const resolvedBehavior = behavior ?? "NORMAL";
+  const childContext = useMemo(
+    () => ({
+      ...parentContext,
+      formData: {
+        ...parentContext.formData,
+        [scopedFieldId]: cellValue
+      },
+      fieldBehaviors: {
+        ...parentContext.fieldBehaviors,
+        [scopedFieldId]: resolvedBehavior
+      },
+      setFieldValue: (fieldId, value) => {
+        if (fieldId === scopedFieldId) {
+          onCellChange(rowIndex, column.fieldId, value);
+          return;
+        }
+        parentContext.setFieldValue(fieldId, value);
+      },
+      getFieldValue: (fieldId) => fieldId === scopedFieldId ? cellValue : parentContext.getFieldValue(fieldId),
+      getFormData: () => ({
+        ...parentContext.getFormData(),
+        [scopedFieldId]: cellValue
+      }),
+      validateField: (fieldId) => fieldId === scopedFieldId ? Promise.resolve(true) : parentContext.validateField(fieldId),
+      registerField: (fieldId) => {
+        if (fieldId !== scopedFieldId) parentContext.registerField(fieldId);
+      },
+      unregisterField: (fieldId) => {
+        if (fieldId !== scopedFieldId) parentContext.unregisterField(fieldId);
+      }
+    }),
+    [
+      cellValue,
+      column.fieldId,
+      onCellChange,
+      parentContext,
+      resolvedBehavior,
+      rowIndex,
+      scopedFieldId
+    ]
+  );
+  if (!Component) {
+    return /* @__PURE__ */ jsx46(
+      "input",
+      {
+        value: stringifyFallbackValue(cellValue),
+        disabled: resolvedBehavior === "DISABLED",
+        onChange: (event) => onCellChange(rowIndex, column.fieldId, event.target.value),
+        "data-testid": fallbackTestId
+      }
+    );
+  }
+  const columnProps = { ...column };
+  delete columnProps.fieldId;
+  delete columnProps.componentName;
+  delete columnProps.label;
+  delete columnProps.required;
+  delete columnProps.tips;
+  return /* @__PURE__ */ jsx46(FormContext.Provider, { value: childContext, children: /* @__PURE__ */ jsx46(
+    Component,
+    {
+      ...columnProps,
+      fieldId: scopedFieldId,
+      label: "",
+      behavior: resolvedBehavior,
+      required: false,
+      tips: void 0
+    }
+  ) });
+}
+
+// src/fields/SubFormField/SubFormFieldPC.tsx
+import { jsx as jsx47, jsxs as jsxs7 } from "react/jsx-runtime";
+function SubFormFieldPC({
+  fieldId,
+  behavior,
+  columns,
+  maxRows,
+  minRows,
+  onChange
+}) {
+  const { formData, setFieldValue } = useFormContext();
+  const rows = formData[fieldId] ?? [];
+  const disabled = behavior === "DISABLED";
+  const handleAddRow = () => {
+    if (maxRows && rows.length >= maxRows) return;
+    const emptyRow = {};
+    columns.forEach((col) => {
+      emptyRow[col.fieldId] = col.defaultValue ?? "";
+    });
+    const newRows = [...rows, emptyRow];
+    setFieldValue(fieldId, newRows);
+    onChange?.(newRows);
+  };
+  const handleRemoveRow = (index) => {
+    if (minRows && rows.length <= minRows) return;
+    const newRows = rows.filter((_, i) => i !== index);
+    setFieldValue(fieldId, newRows);
+    onChange?.(newRows);
+  };
+  const handleCellChange = (rowIndex, colId, value) => {
+    const newRows = rows.map((row, i) => i === rowIndex ? { ...row, [colId]: value } : row);
+    setFieldValue(fieldId, newRows);
+    onChange?.(newRows);
+  };
+  return /* @__PURE__ */ jsxs7("div", { "data-testid": `subformfield-pc-${fieldId}`, children: [
+    /* @__PURE__ */ jsxs7("table", { "data-testid": `subformfield-table-${fieldId}`, children: [
+      /* @__PURE__ */ jsx47("thead", { children: /* @__PURE__ */ jsxs7("tr", { children: [
+        columns.map((col) => /* @__PURE__ */ jsx47("th", { children: col.label }, col.fieldId)),
+        /* @__PURE__ */ jsx47("th", { children: "\u64CD\u4F5C" })
+      ] }) }),
+      /* @__PURE__ */ jsx47("tbody", { children: rows.map((row, rowIndex) => /* @__PURE__ */ jsxs7("tr", { "data-testid": `subformfield-row-${fieldId}-${rowIndex}`, children: [
+        columns.map((col) => /* @__PURE__ */ jsx47("td", { children: /* @__PURE__ */ jsx47(
+          SubFormCell,
+          {
+            parentFieldId: fieldId,
+            rowIndex,
+            column: col,
+            row,
+            behavior,
+            fallbackTestId: `subformfield-cell-${fieldId}-${rowIndex}-${col.fieldId}`,
+            onCellChange: handleCellChange
+          }
+        ) }, col.fieldId)),
+        /* @__PURE__ */ jsx47("td", { children: /* @__PURE__ */ jsx47(
+          "button",
+          {
+            type: "button",
+            disabled,
+            onClick: () => handleRemoveRow(rowIndex),
+            "data-testid": `subformfield-remove-${fieldId}-${rowIndex}`,
+            children: "\u5220\u9664"
+          }
+        ) })
+      ] }, rowIndex)) })
+    ] }),
+    /* @__PURE__ */ jsx47(
+      "button",
+      {
+        type: "button",
+        disabled,
+        onClick: handleAddRow,
+        "data-testid": `subformfield-add-${fieldId}`,
+        children: "\u6DFB\u52A0\u884C"
+      }
+    )
+  ] });
+}
+
+// src/fields/SubFormField/SubFormFieldMobile.tsx
+import { jsx as jsx48, jsxs as jsxs8 } from "react/jsx-runtime";
+function SubFormFieldMobile({
+  fieldId,
+  behavior,
+  columns,
+  maxRows,
+  minRows,
+  onChange
+}) {
+  const { formData, setFieldValue } = useFormContext();
+  const rows = formData[fieldId] ?? [];
+  const disabled = behavior === "DISABLED";
+  const handleAddRow = () => {
+    if (maxRows && rows.length >= maxRows) return;
+    const emptyRow = {};
+    columns.forEach((col) => {
+      emptyRow[col.fieldId] = col.defaultValue ?? "";
+    });
+    const newRows = [...rows, emptyRow];
+    setFieldValue(fieldId, newRows);
+    onChange?.(newRows);
+  };
+  const handleRemoveRow = (index) => {
+    if (minRows && rows.length <= minRows) return;
+    const newRows = rows.filter((_, i) => i !== index);
+    setFieldValue(fieldId, newRows);
+    onChange?.(newRows);
+  };
+  const handleCellChange = (rowIndex, colId, value) => {
+    const newRows = rows.map((row, i) => i === rowIndex ? { ...row, [colId]: value } : row);
+    setFieldValue(fieldId, newRows);
+    onChange?.(newRows);
+  };
+  return /* @__PURE__ */ jsxs8("div", { "data-testid": `subformfield-mobile-${fieldId}`, children: [
+    rows.map((row, rowIndex) => /* @__PURE__ */ jsxs8("div", { "data-testid": `subformfield-card-${fieldId}-${rowIndex}`, children: [
+      columns.map((col) => /* @__PURE__ */ jsxs8("div", { children: [
+        /* @__PURE__ */ jsx48("label", { children: col.label }),
+        /* @__PURE__ */ jsx48(
+          SubFormCell,
+          {
+            parentFieldId: fieldId,
+            rowIndex,
+            column: col,
+            row,
+            behavior,
+            fallbackTestId: `subformfield-mobile-cell-${fieldId}-${rowIndex}-${col.fieldId}`,
+            onCellChange: handleCellChange
+          }
+        )
+      ] }, col.fieldId)),
+      /* @__PURE__ */ jsx48(
+        "button",
+        {
+          type: "button",
+          disabled,
+          onClick: () => handleRemoveRow(rowIndex),
+          "data-testid": `subformfield-mobile-remove-${fieldId}-${rowIndex}`,
+          children: "\u5220\u9664"
+        }
+      )
+    ] }, rowIndex)),
+    /* @__PURE__ */ jsx48(
+      "button",
+      {
+        type: "button",
+        disabled,
+        onClick: handleAddRow,
+        "data-testid": `subformfield-mobile-add-${fieldId}`,
+        children: "\u6DFB\u52A0\u884C"
+      }
+    )
+  ] });
+}
+
+// src/fields/SubFormField/SubFormFieldReadonly.tsx
+import { jsx as jsx49, jsxs as jsxs9 } from "react/jsx-runtime";
+function SubFormFieldReadonly({ fieldId, columns, readonlyClassName }) {
+  const { formData } = useFormContext();
+  const rows = formData[fieldId] ?? [];
+  if (rows.length === 0) {
+    return /* @__PURE__ */ jsx49(
+      "div",
+      {
+        className: readonlyClassName || "sy-field-readonly-value",
+        "data-testid": `subformfield-readonly-${fieldId}`,
+        children: "--"
+      }
+    );
+  }
+  return /* @__PURE__ */ jsxs9(
+    "table",
+    {
+      className: readonlyClassName || "sy-field-readonly-value",
+      "data-testid": `subformfield-readonly-${fieldId}`,
+      children: [
+        /* @__PURE__ */ jsx49("thead", { children: /* @__PURE__ */ jsx49("tr", { children: columns.map((col) => /* @__PURE__ */ jsx49("th", { children: col.label }, col.fieldId)) }) }),
+        /* @__PURE__ */ jsx49("tbody", { children: rows.map((row, rowIndex) => /* @__PURE__ */ jsx49("tr", { "data-testid": `subformfield-readonly-row-${fieldId}-${rowIndex}`, children: columns.map((col) => /* @__PURE__ */ jsx49("td", { children: row[col.fieldId] ?? "--" }, col.fieldId)) }, rowIndex)) })
+      ]
+    }
+  );
+}
+
+// src/fields/SubFormField/index.tsx
+import { jsx as jsx50 } from "react/jsx-runtime";
+function SubFormField(props) {
+  const {
+    fieldId,
+    label,
+    behavior: propBehavior,
+    required,
+    tips,
+    defaultValue,
+    className,
+    labelClassName,
+    tipsClassName
+  } = props;
+  const { fieldBehaviors, setFieldValue, formData, registerField, unregisterField } = useFormContext();
+  const { isMobile } = useDeviceDetect();
+  const behavior = propBehavior ?? fieldBehaviors[fieldId] ?? "NORMAL";
+  useEffect12(() => {
+    registerField(fieldId);
+    if (defaultValue !== void 0 && formData[fieldId] === void 0) {
+      setFieldValue(fieldId, defaultValue);
+    }
+    return () => unregisterField(fieldId);
+  }, [fieldId]);
+  if (behavior === "HIDDEN") return null;
+  const childProps = { ...props, behavior };
+  return /* @__PURE__ */ jsx50(
+    FieldWrapper,
+    {
+      fieldId,
+      label,
+      required,
+      tips,
+      className,
+      labelClassName,
+      tipsClassName,
+      children: behavior === "READONLY" ? /* @__PURE__ */ jsx50(SubFormFieldReadonly, { ...childProps }) : isMobile ? /* @__PURE__ */ jsx50(SubFormFieldMobile, { ...childProps }) : /* @__PURE__ */ jsx50(SubFormFieldPC, { ...childProps })
+    }
+  );
+}
+
+// src/fields/UserSelectField/index.tsx
+import { useEffect as useEffect15 } from "react";
+
+// src/fields/UserSelectField/UserSelectFieldPC.tsx
+import { useEffect as useEffect13, useMemo as useMemo2, useState as useState4 } from "react";
+import { Select as Select3 } from "antd";
+import { jsx as jsx51 } from "react/jsx-runtime";
+var getUserId = (user) => String(user.id || user.value || "");
+var getUserName = (user) => String(user.name || user.label || user.username || getUserId(user));
+var normalizeUser = (user) => ({
+  ...user,
+  id: String(user?.id || user?.value || user?.key || ""),
+  name: String(user?.name || user?.label || user?.title || user?.username || user?.id || "")
+});
+function UserSelectFieldPC({
+  fieldId,
+  behavior,
+  placeholder,
+  inputClassName,
+  multiple = true,
+  searchable = true,
+  dataSource = [],
+  onChange
+}) {
+  const { formData, setFieldValue, api } = useFormContext();
+  const value = formData[fieldId] ?? [];
+  const disabled = behavior === "DISABLED";
+  const [optionsSource, setOptionsSource] = useState4(
+    () => dataSource.map(normalizeUser)
+  );
+  const [loading, setLoading] = useState4(false);
+  useEffect13(() => {
+    if (dataSource.length) {
+      setOptionsSource(dataSource.map(normalizeUser));
+    }
+  }, [dataSource]);
+  const fetchUsers = async (keyword) => {
+    if (dataSource.length) return;
+    setLoading(true);
+    try {
+      const users = await api.getUserList(
+        keyword ? { name: keyword, username: keyword } : void 0
+      );
+      setOptionsSource(users.map(normalizeUser));
+    } finally {
+      setLoading(false);
+    }
+  };
+  useEffect13(() => {
+    fetchUsers();
+  }, []);
+  const handleChange = (selectedIds) => {
+    const ids = Array.isArray(selectedIds) ? selectedIds : [selectedIds];
+    const selected = ids.map(
+      (id) => optionsSource.find((u) => getUserId(u) === id) ?? value.find((u) => getUserId(u) === id)
+    ).filter(Boolean);
+    const result = multiple ? selected : selected.slice(0, 1);
+    setFieldValue(fieldId, result);
+    onChange?.(result);
+  };
+  const options = useMemo2(
+    () => optionsSource.map((u) => ({
+      value: getUserId(u),
+      label: getUserName(u)
+    })),
+    [optionsSource]
+  );
+  const selectValue = multiple ? value.map(getUserId) : value[0] ? getUserId(value[0]) : void 0;
+  return /* @__PURE__ */ jsx51(
+    Select3,
+    {
+      className: inputClassName,
+      style: { width: "100%" },
+      mode: multiple ? "multiple" : void 0,
+      value: selectValue,
+      placeholder,
+      disabled,
+      showSearch: searchable,
+      filterOption: dataSource.length ? void 0 : false,
+      onSearch: searchable ? fetchUsers : void 0,
+      loading,
+      options,
+      onChange: handleChange,
+      "data-testid": `userselectfield-input-${fieldId}`
+    }
+  );
+}
+
+// src/fields/UserSelectField/UserSelectFieldMobile.tsx
+import { useEffect as useEffect14, useState as useState5 } from "react";
+import { jsx as jsx52, jsxs as jsxs10 } from "react/jsx-runtime";
+var getUserId2 = (user) => String(user.id || user.value || "");
+var getUserName2 = (user) => String(user.name || user.label || user.username || getUserId2(user));
+var normalizeUser2 = (user) => ({
+  ...user,
+  id: String(user?.id || user?.value || user?.key || ""),
+  name: String(user?.name || user?.label || user?.title || user?.username || user?.id || "")
+});
+function UserSelectFieldMobile({
+  fieldId,
+  behavior,
+  multiple = true,
+  dataSource = [],
+  onChange
+}) {
+  const { formData, setFieldValue, api } = useFormContext();
+  const value = formData[fieldId] ?? [];
+  const disabled = behavior === "DISABLED";
+  const [showPicker, setShowPicker] = useState5(false);
+  const [optionsSource, setOptionsSource] = useState5(
+    () => dataSource.map(normalizeUser2)
+  );
+  useEffect14(() => {
+    if (dataSource.length) {
+      setOptionsSource(dataSource.map(normalizeUser2));
+    }
+  }, [dataSource]);
+  const ensureUsers = async () => {
+    if (dataSource.length || optionsSource.length) return;
+    const users = await api.getUserList();
+    setOptionsSource(users.map(normalizeUser2));
+  };
+  const handleSelect = (userId) => {
+    const user = optionsSource.find((u) => getUserId2(u) === userId);
+    if (!user) return;
+    let newValue;
+    if (multiple) {
+      const exists = value.some((u) => getUserId2(u) === userId);
+      newValue = exists ? value.filter((u) => getUserId2(u) !== userId) : [...value, user];
+    } else {
+      newValue = [user];
+      setShowPicker(false);
+    }
+    setFieldValue(fieldId, newValue);
+    onChange?.(newValue);
+  };
+  return /* @__PURE__ */ jsxs10("div", { "data-testid": `userselectfield-mobile-${fieldId}`, children: [
+    /* @__PURE__ */ jsx52(
+      "button",
+      {
+        type: "button",
+        disabled,
+        onClick: () => {
+          setShowPicker(!showPicker);
+          ensureUsers();
+        },
+        "data-testid": `userselectfield-mobile-trigger-${fieldId}`,
+        children: value.length > 0 ? value.map(getUserName2).join(", ") : "\u8BF7\u9009\u62E9"
+      }
+    ),
+    showPicker && /* @__PURE__ */ jsx52("ul", { "data-testid": `userselectfield-mobile-list-${fieldId}`, children: optionsSource.map((user) => /* @__PURE__ */ jsx52("li", { children: /* @__PURE__ */ jsxs10(
+      "button",
+      {
+        type: "button",
+        disabled,
+        onClick: () => handleSelect(getUserId2(user)),
+        "data-testid": `userselectfield-mobile-option-${getUserId2(user)}`,
+        children: [
+          getUserName2(user),
+          value.some((u) => getUserId2(u) === getUserId2(user)) ? " \u2713" : ""
+        ]
+      }
+    ) }, getUserId2(user))) })
+  ] });
+}
+
+// src/fields/UserSelectField/UserSelectFieldReadonly.tsx
+import { jsx as jsx53 } from "react/jsx-runtime";
+function UserSelectFieldReadonly({ fieldId, readonlyClassName }) {
+  const { formData } = useFormContext();
+  const value = formData[fieldId] ?? [];
+  const display = value.length > 0 ? value.map((u) => u.name).join(", ") : "--";
+  return /* @__PURE__ */ jsx53(
+    "div",
+    {
+      className: readonlyClassName || "sy-field-readonly-value",
+      "data-testid": `userselectfield-readonly-${fieldId}`,
+      children: display
+    }
+  );
+}
+
+// src/fields/UserSelectField/index.tsx
+import { jsx as jsx54 } from "react/jsx-runtime";
+function UserSelectField(props) {
+  const {
+    fieldId,
+    label,
+    behavior: propBehavior,
+    required,
+    tips,
+    defaultValue,
+    className,
+    labelClassName,
+    tipsClassName
+  } = props;
+  const { fieldBehaviors, setFieldValue, formData, registerField, unregisterField } = useFormContext();
+  const { isMobile } = useDeviceDetect();
+  const behavior = propBehavior ?? fieldBehaviors[fieldId] ?? "NORMAL";
+  useEffect15(() => {
+    registerField(fieldId);
+    if (defaultValue !== void 0 && formData[fieldId] === void 0) {
+      setFieldValue(fieldId, defaultValue);
+    }
+    return () => unregisterField(fieldId);
+  }, [fieldId]);
+  if (behavior === "HIDDEN") return null;
+  const childProps = { ...props, behavior };
+  return /* @__PURE__ */ jsx54(
+    FieldWrapper,
+    {
+      fieldId,
+      label,
+      required,
+      tips,
+      className,
+      labelClassName,
+      tipsClassName,
+      children: behavior === "READONLY" ? /* @__PURE__ */ jsx54(UserSelectFieldReadonly, { ...childProps }) : isMobile ? /* @__PURE__ */ jsx54(UserSelectFieldMobile, { ...childProps }) : /* @__PURE__ */ jsx54(UserSelectFieldPC, { ...childProps })
+    }
+  );
+}
+
+// src/fields/DepartmentSelectField/index.tsx
+import { useEffect as useEffect18 } from "react";
+
+// src/fields/DepartmentSelectField/DepartmentSelectFieldPC.tsx
+import { useEffect as useEffect16, useRef, useState as useState6 } from "react";
+import { TreeSelect } from "antd";
+import { jsx as jsx55 } from "react/jsx-runtime";
+var EMPTY_TREE_DATA = [];
+function convertTreeData(nodes) {
+  return nodes.map((node) => ({
+    value: String(node.id || node.value || node.key || ""),
+    title: node.name || node.label || node.title,
+    isLeaf: node.isLeaf ?? !node.hasChildren,
+    children: node.children ? convertTreeData(node.children) : void 0
+  }));
+}
+function flattenTree(nodes) {
+  const result = [];
+  const walk = (list) => {
+    for (const node of list) {
+      result.push({
+        id: String(node.id || node.value || node.key || ""),
+        name: String(node.name || node.label || node.title || node.id || "")
+      });
+      if (node.children) walk(node.children);
+    }
+  };
+  walk(nodes);
+  return result;
+}
+function DepartmentSelectFieldPC({
+  fieldId,
+  behavior,
+  placeholder,
+  inputClassName,
+  multiple = false,
+  treeData,
+  onChange
+}) {
+  const { formData, setFieldValue, api } = useFormContext();
+  const value = formData[fieldId] ?? [];
+  const disabled = behavior === "DISABLED";
+  const configuredTreeData = treeData ?? EMPTY_TREE_DATA;
+  const remoteLoadedRef = useRef(false);
+  const [loadedTreeData, setLoadedTreeData] = useState6(configuredTreeData);
+  useEffect16(() => {
+    if (configuredTreeData.length) {
+      setLoadedTreeData(configuredTreeData);
+      return;
+    }
+    if (remoteLoadedRef.current) return;
+    remoteLoadedRef.current = true;
+    api.getDepartmentRoots().then((nodes) => setLoadedTreeData(nodes));
+  }, [api, configuredTreeData]);
+  const allDepts = flattenTree(loadedTreeData);
+  const handleChange = (selectedIds) => {
+    const ids = Array.isArray(selectedIds) ? selectedIds : [selectedIds];
+    const selected = ids.map((id) => allDepts.find((d) => d.id === id) ?? value.find((d) => d.id === id)).filter(Boolean);
+    setFieldValue(fieldId, selected);
+    onChange?.(selected);
+  };
+  const treeDataConverted = convertTreeData(loadedTreeData);
+  const selectValue = multiple ? value.map((d) => d.id) : value[0]?.id;
+  return /* @__PURE__ */ jsx55(
+    TreeSelect,
+    {
+      className: inputClassName,
+      style: { width: "100%" },
+      multiple,
+      treeData: treeDataConverted,
+      value: selectValue,
+      placeholder,
+      disabled,
+      onChange: handleChange,
+      loadData: async (node) => {
+        if (configuredTreeData.length) return;
+        const children = await api.getDepartmentChildren(String(node.value));
+        setLoadedTreeData((current) => {
+          const attach = (items) => items.map((item) => {
+            const id = String(item.id || item.value || item.key || "");
+            if (id === String(node.value)) {
+              return { ...item, children };
+            }
+            return item.children ? { ...item, children: attach(item.children) } : item;
+          });
+          return attach(current);
+        });
+      },
+      treeDefaultExpandAll: Boolean(configuredTreeData.length),
+      "data-testid": `deptselectfield-input-${fieldId}`
+    }
+  );
+}
+
+// src/fields/DepartmentSelectField/DepartmentSelectFieldMobile.tsx
+import { useEffect as useEffect17, useRef as useRef2, useState as useState7 } from "react";
+import { jsx as jsx56, jsxs as jsxs11 } from "react/jsx-runtime";
+var EMPTY_TREE_DATA2 = [];
+function flattenTree2(nodes) {
+  const result = [];
+  const walk = (list) => {
+    for (const node of list) {
+      result.push({
+        id: String(node.id || node.value || node.key || ""),
+        name: String(node.name || node.label || node.title || node.id || "")
+      });
+      if (node.children) walk(node.children);
+    }
+  };
+  walk(nodes);
+  return result;
+}
+function DepartmentSelectFieldMobile({
+  fieldId,
+  behavior,
+  multiple = false,
+  treeData,
+  onChange
+}) {
+  const { formData, setFieldValue, api } = useFormContext();
+  const value = formData[fieldId] ?? [];
+  const disabled = behavior === "DISABLED";
+  const [showPicker, setShowPicker] = useState7(false);
+  const configuredTreeData = treeData ?? EMPTY_TREE_DATA2;
+  const remoteLoadedRef = useRef2(false);
+  const [loadedTreeData, setLoadedTreeData] = useState7(configuredTreeData);
+  useEffect17(() => {
+    if (configuredTreeData.length) {
+      setLoadedTreeData(configuredTreeData);
+    }
+  }, [configuredTreeData]);
+  const ensureDepartments = async () => {
+    if (configuredTreeData.length || loadedTreeData.length || remoteLoadedRef.current) return;
+    remoteLoadedRef.current = true;
+    const roots = await api.getDepartmentRoots();
+    setLoadedTreeData(roots);
+  };
+  const allDepts = flattenTree2(loadedTreeData);
+  const handleSelect = (deptId) => {
+    const dept = allDepts.find((d) => d.id === deptId);
+    if (!dept) return;
+    let newValue;
+    if (multiple) {
+      const exists = value.some((d) => d.id === deptId);
+      newValue = exists ? value.filter((d) => d.id !== deptId) : [...value, dept];
+    } else {
+      newValue = [dept];
+      setShowPicker(false);
+    }
+    setFieldValue(fieldId, newValue);
+    onChange?.(newValue);
+  };
+  return /* @__PURE__ */ jsxs11("div", { "data-testid": `deptselectfield-mobile-${fieldId}`, children: [
+    /* @__PURE__ */ jsx56(
+      "button",
+      {
+        type: "button",
+        disabled,
+        onClick: () => {
+          setShowPicker(!showPicker);
+          ensureDepartments();
+        },
+        "data-testid": `deptselectfield-mobile-trigger-${fieldId}`,
+        children: value.length > 0 ? value.map((d) => d.name).join(", ") : "\u8BF7\u9009\u62E9"
+      }
+    ),
+    showPicker && /* @__PURE__ */ jsx56("ul", { "data-testid": `deptselectfield-mobile-list-${fieldId}`, children: allDepts.map((dept) => /* @__PURE__ */ jsx56("li", { children: /* @__PURE__ */ jsxs11(
+      "button",
+      {
+        type: "button",
+        disabled,
+        onClick: () => handleSelect(dept.id),
+        "data-testid": `deptselectfield-mobile-option-${dept.id}`,
+        children: [
+          dept.name,
+          value.some((d) => d.id === dept.id) ? " \u2713" : ""
+        ]
+      }
+    ) }, dept.id)) })
+  ] });
+}
+
+// src/fields/DepartmentSelectField/DepartmentSelectFieldReadonly.tsx
+import { jsx as jsx57 } from "react/jsx-runtime";
+function DepartmentSelectFieldReadonly({
+  fieldId,
+  readonlyClassName
+}) {
+  const { formData } = useFormContext();
+  const value = formData[fieldId] ?? [];
+  const display = value.length > 0 ? value.map((d) => d.name).join(", ") : "--";
+  return /* @__PURE__ */ jsx57(
+    "div",
+    {
+      className: readonlyClassName || "sy-field-readonly-value",
+      "data-testid": `deptselectfield-readonly-${fieldId}`,
+      children: display
+    }
+  );
+}
+
+// src/fields/DepartmentSelectField/index.tsx
+import { jsx as jsx58 } from "react/jsx-runtime";
+function DepartmentSelectField(props) {
+  const {
+    fieldId,
+    label,
+    behavior: propBehavior,
+    required,
+    tips,
+    defaultValue,
+    className,
+    labelClassName,
+    tipsClassName
+  } = props;
+  const { fieldBehaviors, setFieldValue, formData, registerField, unregisterField } = useFormContext();
+  const { isMobile } = useDeviceDetect();
+  const behavior = propBehavior ?? fieldBehaviors[fieldId] ?? "NORMAL";
+  useEffect18(() => {
+    registerField(fieldId);
+    if (defaultValue !== void 0 && formData[fieldId] === void 0) {
+      setFieldValue(fieldId, defaultValue);
+    }
+    return () => unregisterField(fieldId);
+  }, [fieldId]);
+  if (behavior === "HIDDEN") return null;
+  const childProps = { ...props, behavior };
+  return /* @__PURE__ */ jsx58(
+    FieldWrapper,
+    {
+      fieldId,
+      label,
+      required,
+      tips,
+      className,
+      labelClassName,
+      tipsClassName,
+      children: behavior === "READONLY" ? /* @__PURE__ */ jsx58(DepartmentSelectFieldReadonly, { ...childProps }) : isMobile ? /* @__PURE__ */ jsx58(DepartmentSelectFieldMobile, { ...childProps }) : /* @__PURE__ */ jsx58(DepartmentSelectFieldPC, { ...childProps })
+    }
+  );
+}
+
+// src/fields/CascadeSelectField/index.tsx
+import { useEffect as useEffect19 } from "react";
+import { Cascader } from "antd";
+import { jsx as jsx59 } from "react/jsx-runtime";
+var toValuePath = (value, multiple) => {
+  if (!value) return multiple ? [] : [];
+  if (multiple && Array.isArray(value) && Array.isArray(value[0])) {
+    return value.map((path) => path.map((item) => item.value));
+  }
+  if (Array.isArray(value)) return value.map((item) => item.value);
+  return [];
+};
+var normalizePath = (selectedOptions) => (selectedOptions ?? []).map((item) => ({
+  label: String(item?.label ?? item?.title ?? item?.value ?? ""),
+  value: String(item?.value ?? "")
+}));
+function CascadeSelectField(props) {
+  const {
+    fieldId,
+    label,
+    behavior: propBehavior,
+    required,
+    tips,
+    className,
+    labelClassName,
+    tipsClassName,
+    inputClassName,
+    placeholder,
+    defaultValue,
+    options = [],
+    multiple = false,
+    allowClear = true,
+    changeOnSelect,
+    showSearch,
+    fieldNames,
+    onChange
+  } = props;
+  const { formData, fieldBehaviors, setFieldValue, registerField, unregisterField } = useFormContext();
+  const behavior = propBehavior ?? fieldBehaviors[fieldId] ?? "NORMAL";
+  const value = formData[fieldId] ?? (multiple ? [] : []);
+  useEffect19(() => {
+    registerField(fieldId);
+    if (defaultValue !== void 0 && formData[fieldId] === void 0) {
+      setFieldValue(fieldId, defaultValue);
+    }
+    return () => unregisterField(fieldId);
+  }, [fieldId]);
+  if (behavior === "HIDDEN") return null;
+  const readonlyText = Array.isArray(value) ? (multiple && Array.isArray(value[0]) ? value.flat() : value).map((item) => item?.label ?? item?.value ?? item).join(" / ") : "--";
+  return /* @__PURE__ */ jsx59(
+    FieldWrapper,
+    {
+      fieldId,
+      label,
+      required,
+      tips,
+      className,
+      labelClassName,
+      tipsClassName,
+      children: behavior === "READONLY" ? /* @__PURE__ */ jsx59(
+        "div",
+        {
+          className: "sy-field-readonly-value",
+          "data-testid": `cascadeselectfield-readonly-${fieldId}`,
+          children: readonlyText || "--"
+        }
+      ) : /* @__PURE__ */ jsx59(
+        Cascader,
+        {
+          className: inputClassName,
+          style: { width: "100%" },
+          options,
+          multiple,
+          allowClear,
+          changeOnSelect,
+          showSearch,
+          fieldNames,
+          disabled: behavior === "DISABLED",
+          placeholder,
+          value: toValuePath(value, multiple),
+          onChange: (_nextValue, selectedOptions) => {
+            const next = multiple ? (selectedOptions ?? []).map((path) => normalizePath(path)) : normalizePath(selectedOptions);
+            setFieldValue(fieldId, next);
+            onChange?.(next);
+          },
+          "data-testid": `cascadeselectfield-input-${fieldId}`
+        }
+      )
+    }
+  );
+}
+
+// src/fields/AddressField/index.tsx
+import { useEffect as useEffect20, useState as useState8 } from "react";
+import { Cascader as Cascader2, Input as Input5 } from "antd";
+import { jsx as jsx60, jsxs as jsxs12 } from "react/jsx-runtime";
+var LEVELS = ["province", "city", "district", "street"];
+var modeDepth = (mode) => {
+  if (mode === "province-city") return 2;
+  if (mode === "province-city-district-street" || mode === "province-city-district-street-detail") {
+    return 4;
+  }
+  return 3;
+};
+var valueToPath = (value) => LEVELS.map((level) => value?.[level]?.value).filter(Boolean);
+function AddressField(props) {
+  const {
+    fieldId,
+    label,
+    behavior: propBehavior,
+    required,
+    tips,
+    className,
+    labelClassName,
+    tipsClassName,
+    inputClassName,
+    defaultValue,
+    mode = "province-city-district",
+    detailPlaceholder = "\u8BF7\u8F93\u5165\u8BE6\u7EC6\u5730\u5740",
+    allowClear = true,
+    onChange
+  } = props;
+  const { formData, fieldBehaviors, setFieldValue, registerField, unregisterField, api } = useFormContext();
+  const behavior = propBehavior ?? fieldBehaviors[fieldId] ?? "NORMAL";
+  const value = formData[fieldId];
+  const [options, setOptions] = useState8([]);
+  const depth = modeDepth(mode);
+  const detailEnabled = mode === "province-city-district-street-detail";
+  useEffect20(() => {
+    registerField(fieldId);
+    if (defaultValue !== void 0 && formData[fieldId] === void 0) {
+      setFieldValue(fieldId, defaultValue);
+    }
+    return () => unregisterField(fieldId);
+  }, [fieldId]);
+  useEffect20(() => {
+    api.getChinaDivisions().then((list) => {
+      setOptions(
+        list.map((item) => ({
+          label: String(item.name || item.label || item.adcode),
+          value: String(item.adcode || item.value),
+          level: "province",
+          isLeaf: depth <= 1 || item.isLeaf === true
+        }))
+      );
+    });
+  }, [api, depth]);
+  if (behavior === "HIDDEN") return null;
+  const setAddressValue = (next) => {
+    setFieldValue(fieldId, next);
+    onChange?.(next);
+  };
+  const display = value?.fullAddress || valueToPath(value).join(" / ") || "--";
+  return /* @__PURE__ */ jsx60(
+    FieldWrapper,
+    {
+      fieldId,
+      label,
+      required,
+      tips,
+      className,
+      labelClassName,
+      tipsClassName,
+      children: behavior === "READONLY" ? /* @__PURE__ */ jsx60("div", { className: "sy-field-readonly-value", "data-testid": `addressfield-readonly-${fieldId}`, children: display }) : /* @__PURE__ */ jsxs12("div", { className: inputClassName, "data-testid": `addressfield-input-${fieldId}`, children: [
+        /* @__PURE__ */ jsx60(
+          Cascader2,
+          {
+            style: { width: "100%" },
+            options,
+            allowClear,
+            disabled: behavior === "DISABLED",
+            value: valueToPath(value),
+            placeholder: props.placeholder || "\u8BF7\u9009\u62E9\u5730\u5740",
+            loadData: async (selectedOptions) => {
+              const target = selectedOptions[selectedOptions.length - 1];
+              const nextLevel = LEVELS[selectedOptions.length] ?? "street";
+              const children = await api.getChinaDivisions(target.value);
+              target.children = children.map((item) => ({
+                label: String(item.name || item.label || item.adcode),
+                value: String(item.adcode || item.value),
+                level: nextLevel,
+                isLeaf: selectedOptions.length + 1 >= depth || item.isLeaf === true
+              }));
+              setOptions([...options]);
+            },
+            onChange: (_path, selectedOptions) => {
+              if (!selectedOptions?.length) {
+                setAddressValue(void 0);
+                return;
+              }
+              const next = {};
+              selectedOptions.forEach((item, index) => {
+                const level = LEVELS[index];
+                if (level) next[level] = { label: item.label, value: item.value };
+              });
+              next.detail = value?.detail;
+              next.fullAddress = [
+                ...selectedOptions.map((item) => item.label),
+                detailEnabled ? value?.detail : ""
+              ].filter(Boolean).join("");
+              setAddressValue(next);
+            }
+          }
+        ),
+        detailEnabled && /* @__PURE__ */ jsx60(
+          Input5,
+          {
+            value: value?.detail ?? "",
+            disabled: behavior === "DISABLED",
+            placeholder: detailPlaceholder,
+            onChange: (event) => {
+              const detail = event.target.value;
+              const labels = LEVELS.map((level) => value?.[level]?.label).filter(Boolean);
+              setAddressValue({
+                ...value ?? {},
+                detail,
+                fullAddress: [...labels, detail].filter(Boolean).join("")
+              });
+            }
+          }
+        )
+      ] })
+    }
+  );
+}
+
+// src/fields/AssociationFormField/index.tsx
+import { useEffect as useEffect21, useMemo as useMemo3, useState as useState9 } from "react";
+import { Select as Select4, Spin } from "antd";
+import { jsx as jsx61 } from "react/jsx-runtime";
+var normalizeValues = (value) => {
+  if (!value) return [];
+  return (Array.isArray(value) ? value : [value]).filter(Boolean);
+};
+function AssociationFormField(props) {
+  const {
+    fieldId,
+    label,
+    behavior: propBehavior,
+    required,
+    tips,
+    className,
+    labelClassName,
+    tipsClassName,
+    inputClassName,
+    placeholder,
+    defaultValue,
+    associationForm,
+    multiple = false,
+    allowClear = true,
+    showSearch = true,
+    onChange
+  } = props;
+  const { formData, fieldBehaviors, setFieldValue, registerField, unregisterField, api } = useFormContext();
+  const behavior = propBehavior ?? fieldBehaviors[fieldId] ?? "NORMAL";
+  const value = normalizeValues(formData[fieldId]);
+  const [options, setOptions] = useState9([]);
+  const [loading, setLoading] = useState9(false);
+  useEffect21(() => {
+    registerField(fieldId);
+    if (defaultValue !== void 0 && formData[fieldId] === void 0) {
+      setFieldValue(fieldId, normalizeValues(defaultValue));
+    }
+    return () => unregisterField(fieldId);
+  }, [fieldId]);
+  const loadOptions = async (keyword) => {
+    if (!associationForm?.appType || !associationForm.formUuid) return;
+    setLoading(true);
+    try {
+      const result = await api.advancedSearch({
+        appType: associationForm.appType,
+        formUuid: associationForm.formUuid,
+        currentPage: 1,
+        pageSize: 20,
+        searchKeyWord: keyword
+      });
+      const list = Array.isArray(result?.data) ? result.data : result?.list || result?.items || [];
+      setOptions(
+        list.map((record) => {
+          const rawLabel = record?.[associationForm.mainFieldId];
+          const labelText = typeof rawLabel === "object" ? rawLabel?.label || JSON.stringify(rawLabel) : rawLabel;
+          return {
+            label: String(labelText || record?.id || record?.formInstId || "--"),
+            value: record?.formInstId || record?.id || record?.bizObjectId || labelText,
+            record
+          };
+        })
+      );
+    } finally {
+      setLoading(false);
+    }
+  };
+  useEffect21(() => {
+    loadOptions();
+  }, [associationForm?.appType, associationForm?.formUuid, associationForm?.mainFieldId]);
+  const selectOptions = useMemo3(
+    () => options.map((item) => ({ label: item.label, value: item.value })),
+    [options]
+  );
+  if (behavior === "HIDDEN") return null;
+  return /* @__PURE__ */ jsx61(
+    FieldWrapper,
+    {
+      fieldId,
+      label,
+      required,
+      tips,
+      className,
+      labelClassName,
+      tipsClassName,
+      children: behavior === "READONLY" ? /* @__PURE__ */ jsx61(
+        "div",
+        {
+          className: "sy-field-readonly-value",
+          "data-testid": `associationformfield-readonly-${fieldId}`,
+          children: value.map((item) => item.label).join(", ") || "--"
+        }
+      ) : /* @__PURE__ */ jsx61(
+        Select4,
+        {
+          className: inputClassName,
+          style: { width: "100%" },
+          mode: multiple ? "multiple" : void 0,
+          allowClear,
+          showSearch,
+          filterOption: false,
+          onSearch: showSearch ? loadOptions : void 0,
+          disabled: behavior === "DISABLED",
+          placeholder,
+          loading,
+          notFoundContent: loading ? /* @__PURE__ */ jsx61(Spin, { size: "small" }) : void 0,
+          options: selectOptions,
+          value: multiple ? value.map((item) => item.value) : value[0]?.value,
+          onChange: (nextValue) => {
+            const ids = Array.isArray(nextValue) ? nextValue : [nextValue];
+            const next = ids.map(
+              (id) => options.find((item) => item.value === id) ?? value.find((item) => item.value === id)
+            ).filter(Boolean);
+            setFieldValue(fieldId, next);
+            onChange?.(next);
+          },
+          "data-testid": `associationformfield-input-${fieldId}`
+        }
+      )
+    }
+  );
+}
+
+// src/fields/EditorField/index.tsx
+import { useEffect as useEffect22 } from "react";
+import { Input as Input6 } from "antd";
+import { jsx as jsx62 } from "react/jsx-runtime";
+var { TextArea: TextArea3 } = Input6;
+function EditorField(props) {
+  const {
+    fieldId,
+    label,
+    behavior: propBehavior,
+    required,
+    tips,
+    className,
+    labelClassName,
+    tipsClassName,
+    inputClassName,
+    placeholder,
+    defaultValue,
+    rows = 8,
+    maxLength,
+    onChange
+  } = props;
+  const { formData, fieldBehaviors, setFieldValue, registerField, unregisterField } = useFormContext();
+  const behavior = propBehavior ?? fieldBehaviors[fieldId] ?? "NORMAL";
+  const value = formData[fieldId] ?? "";
+  useEffect22(() => {
+    registerField(fieldId);
+    if (defaultValue !== void 0 && formData[fieldId] === void 0) {
+      setFieldValue(fieldId, defaultValue);
+    }
+    return () => unregisterField(fieldId);
+  }, [fieldId]);
+  if (behavior === "HIDDEN") return null;
+  return /* @__PURE__ */ jsx62(
+    FieldWrapper,
+    {
+      fieldId,
+      label,
+      required,
+      tips,
+      className,
+      labelClassName,
+      tipsClassName,
+      children: behavior === "READONLY" ? /* @__PURE__ */ jsx62(
+        "div",
+        {
+          className: "sy-field-readonly-value",
+          "data-testid": `editorfield-readonly-${fieldId}`,
+          dangerouslySetInnerHTML: { __html: value || "--" }
+        }
+      ) : /* @__PURE__ */ jsx62(
+        TextArea3,
+        {
+          className: inputClassName,
+          style: { width: "100%" },
+          value,
+          rows,
+          maxLength,
+          showCount: Boolean(maxLength),
+          placeholder,
+          disabled: behavior === "DISABLED",
+          onChange: (event) => {
+            setFieldValue(fieldId, event.target.value);
+            onChange?.(event.target.value);
+          },
+          "data-testid": `editorfield-input-${fieldId}`
+        }
+      )
+    }
+  );
+}
+
+// src/fields/SerialNumberField/index.tsx
+import { useEffect as useEffect23 } from "react";
+import { Input as Input7 } from "antd";
+import { jsx as jsx63 } from "react/jsx-runtime";
+function SerialNumberField(props) {
+  const {
+    fieldId,
+    label,
+    behavior: propBehavior = "READONLY",
+    required,
+    tips,
+    className,
+    labelClassName,
+    tipsClassName,
+    inputClassName,
+    placeholder = "\u81EA\u52A8\u751F\u6210",
+    defaultValue
+  } = props;
+  const { formData, fieldBehaviors, setFieldValue, registerField, unregisterField } = useFormContext();
+  const behavior = propBehavior ?? fieldBehaviors[fieldId] ?? "READONLY";
+  const value = formData[fieldId] ?? "";
+  useEffect23(() => {
+    registerField(fieldId);
+    if (defaultValue !== void 0 && formData[fieldId] === void 0) {
+      setFieldValue(fieldId, defaultValue);
+    }
+    return () => unregisterField(fieldId);
+  }, [fieldId]);
+  if (behavior === "HIDDEN") return null;
+  return /* @__PURE__ */ jsx63(
+    FieldWrapper,
+    {
+      fieldId,
+      label,
+      required,
+      tips,
+      className,
+      labelClassName,
+      tipsClassName,
+      children: behavior === "READONLY" ? /* @__PURE__ */ jsx63(
+        "div",
+        {
+          className: "sy-field-readonly-value",
+          "data-testid": `serialnumberfield-readonly-${fieldId}`,
+          children: value || "--"
+        }
+      ) : /* @__PURE__ */ jsx63(
+        Input7,
+        {
+          className: inputClassName,
+          style: { width: "100%" },
+          value,
+          placeholder,
+          readOnly: true,
+          disabled: behavior === "DISABLED",
+          "data-testid": `serialnumberfield-input-${fieldId}`
+        }
+      )
+    }
+  );
+}
+
+// src/fields/LocationField/index.tsx
+import { useEffect as useEffect24, useState as useState10 } from "react";
+import { Button as Button2, Space as Space3 } from "antd";
+import { jsx as jsx64, jsxs as jsxs13 } from "react/jsx-runtime";
+function LocationField(props) {
+  const {
+    fieldId,
+    label,
+    behavior: propBehavior,
+    required,
+    tips,
+    className,
+    labelClassName,
+    tipsClassName,
+    defaultValue,
+    allowClear = true,
+    locateButtonText = "\u83B7\u53D6\u5B9A\u4F4D",
+    clearButtonText = "\u6E05\u7A7A",
+    onChange
+  } = props;
+  const { formData, fieldBehaviors, setFieldValue, registerField, unregisterField } = useFormContext();
+  const behavior = propBehavior ?? fieldBehaviors[fieldId] ?? "NORMAL";
+  const value = formData[fieldId];
+  const [locating, setLocating] = useState10(false);
+  useEffect24(() => {
+    registerField(fieldId);
+    if (defaultValue !== void 0 && formData[fieldId] === void 0) {
+      setFieldValue(fieldId, defaultValue);
+    }
+    return () => unregisterField(fieldId);
+  }, [fieldId]);
+  if (behavior === "HIDDEN") return null;
+  const setValue = (next) => {
+    setFieldValue(fieldId, next);
+    onChange?.(next);
+  };
+  const locate = () => {
+    if (!navigator.geolocation) return;
+    setLocating(true);
+    navigator.geolocation.getCurrentPosition(
+      (position) => {
+        setLocating(false);
+        setValue({
+          latitude: position.coords.latitude,
+          longitude: position.coords.longitude,
+          accuracy: position.coords.accuracy,
+          source: "browser",
+          time: Date.now()
+        });
+      },
+      () => setLocating(false),
+      { enableHighAccuracy: true, timeout: 1e4 }
+    );
+  };
+  const display = value ? value.address || `${value.latitude.toFixed(6)}, ${value.longitude.toFixed(6)}` : "--";
+  return /* @__PURE__ */ jsx64(
+    FieldWrapper,
+    {
+      fieldId,
+      label,
+      required,
+      tips,
+      className,
+      labelClassName,
+      tipsClassName,
+      children: /* @__PURE__ */ jsxs13("div", { "data-testid": `locationfield-${fieldId}`, children: [
+        /* @__PURE__ */ jsx64("div", { children: display }),
+        behavior !== "READONLY" && /* @__PURE__ */ jsxs13(Space3, { children: [
+          /* @__PURE__ */ jsx64(
+            Button2,
+            {
+              type: "primary",
+              loading: locating,
+              disabled: behavior === "DISABLED",
+              onClick: locate,
+              children: locateButtonText
+            }
+          ),
+          allowClear && /* @__PURE__ */ jsx64(Button2, { disabled: behavior === "DISABLED", onClick: () => setValue(void 0), children: clearButtonText })
+        ] })
+      ] })
+    }
+  );
+}
+
+// src/fields/DigitalSignatureField/index.tsx
+import { useEffect as useEffect25, useRef as useRef3, useState as useState11 } from "react";
+import { Button as Button3, Modal, Space as Space4 } from "antd";
+import { jsx as jsx65, jsxs as jsxs14 } from "react/jsx-runtime";
+function DigitalSignatureField(props) {
+  const {
+    fieldId,
+    label,
+    behavior: propBehavior,
+    required,
+    tips,
+    className,
+    labelClassName,
+    tipsClassName,
+    defaultValue,
+    bucketName = "signatures",
+    allowClear = true,
+    onChange
+  } = props;
+  const { formData, fieldBehaviors, setFieldValue, registerField, unregisterField, api } = useFormContext();
+  const behavior = propBehavior ?? fieldBehaviors[fieldId] ?? "NORMAL";
+  const value = formData[fieldId];
+  const [open, setOpen] = useState11(false);
+  const [saving, setSaving] = useState11(false);
+  const canvasRef = useRef3(null);
+  const drawingRef = useRef3(false);
+  const pointsRef = useRef3([]);
+  useEffect25(() => {
+    registerField(fieldId);
+    if (defaultValue !== void 0 && formData[fieldId] === void 0) {
+      setFieldValue(fieldId, defaultValue);
+    }
+    return () => unregisterField(fieldId);
+  }, [fieldId]);
+  useEffect25(() => {
+    if (!open) return;
+    const canvas = canvasRef.current;
+    if (!canvas) return;
+    const rect = canvas.getBoundingClientRect();
+    canvas.width = Math.max(480, rect.width || 480);
+    canvas.height = 240;
+    const ctx = canvas.getContext("2d");
+    if (ctx) {
+      ctx.lineWidth = 2;
+      ctx.lineCap = "round";
+      ctx.strokeStyle = "#111827";
+    }
+  }, [open]);
+  if (behavior === "HIDDEN") return null;
+  const setValue = (next) => {
+    setFieldValue(fieldId, next);
+    onChange?.(next);
+  };
+  const getPoint = (event) => {
+    const rect = event.currentTarget.getBoundingClientRect();
+    return { x: event.clientX - rect.left, y: event.clientY - rect.top, t: Date.now() };
+  };
+  const save = async () => {
+    const canvas = canvasRef.current;
+    if (!canvas) return;
+    setSaving(true);
+    canvas.toBlob(async (blob) => {
+      if (!blob) {
+        setSaving(false);
+        return;
+      }
+      const file = new File([blob], `signature-${Date.now()}.png`, { type: "image/png" });
+      try {
+        const uploaded = await api.uploadFile(file, bucketName);
+        setValue({
+          url: uploaded.url,
+          bucketName: uploaded.bucketName,
+          objectName: uploaded.objectName,
+          previewUrl: uploaded.previewUrl || uploaded.url,
+          points: pointsRef.current,
+          timestamp: Date.now()
+        });
+        setOpen(false);
+      } finally {
+        setSaving(false);
+      }
+    }, "image/png");
+  };
+  const previewUrl = value?.previewUrl || value?.url;
+  return /* @__PURE__ */ jsx65(
+    FieldWrapper,
+    {
+      fieldId,
+      label,
+      required,
+      tips,
+      className,
+      labelClassName,
+      tipsClassName,
+      children: /* @__PURE__ */ jsxs14("div", { "data-testid": `digitalsignaturefield-${fieldId}`, children: [
+        previewUrl ? /* @__PURE__ */ jsx65("img", { src: previewUrl, alt: label, style: { maxWidth: 240 } }) : /* @__PURE__ */ jsx65("span", { children: "--" }),
+        behavior !== "READONLY" && /* @__PURE__ */ jsxs14(Space4, { children: [
+          /* @__PURE__ */ jsx65(Button3, { disabled: behavior === "DISABLED", onClick: () => setOpen(true), children: "\u5F00\u59CB\u7B7E\u540D" }),
+          allowClear && /* @__PURE__ */ jsx65(Button3, { disabled: behavior === "DISABLED", onClick: () => setValue(void 0), children: "\u6E05\u7A7A" })
+        ] }),
+        /* @__PURE__ */ jsx65(
+          Modal,
+          {
+            open,
+            title: label,
+            onCancel: () => setOpen(false),
+            onOk: save,
+            confirmLoading: saving,
+            children: /* @__PURE__ */ jsx65(
+              "canvas",
+              {
+                ref: canvasRef,
+                style: { width: "100%", height: 240, border: "1px solid #d9d9d9" },
+                onPointerDown: (event) => {
+                  drawingRef.current = true;
+                  pointsRef.current.push(getPoint(event));
+                },
+                onPointerMove: (event) => {
+                  if (!drawingRef.current) return;
+                  const canvas = canvasRef.current;
+                  const ctx = canvas?.getContext("2d");
+                  const last = pointsRef.current[pointsRef.current.length - 1];
+                  const next = getPoint(event);
+                  if (ctx && last) {
+                    ctx.beginPath();
+                    ctx.moveTo(last.x, last.y);
+                    ctx.lineTo(next.x, next.y);
+                    ctx.stroke();
+                  }
+                  pointsRef.current.push(next);
+                },
+                onPointerUp: () => {
+                  drawingRef.current = false;
+                },
+                onPointerLeave: () => {
+                  drawingRef.current = false;
+                }
+              }
+            )
+          }
+        )
+      ] })
+    }
+  );
+}
+
+// src/fields/JSONField/index.tsx
+import { useEffect as useEffect26 } from "react";
+import { jsx as jsx66 } from "react/jsx-runtime";
+var formatJson = (value) => {
+  if (value === void 0 || value === null || value === "") return "--";
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value, null, 2);
+  } catch {
+    return String(value);
+  }
+};
+function JSONField(props) {
+  const {
+    fieldId,
+    label,
+    behavior: propBehavior,
+    required,
+    tips,
+    className,
+    labelClassName,
+    tipsClassName,
+    readonlyClassName,
+    defaultValue
+  } = props;
+  const { formData, fieldBehaviors, setFieldValue, registerField, unregisterField } = useFormContext();
+  const behavior = propBehavior ?? fieldBehaviors[fieldId] ?? "READONLY";
+  const value = formData[fieldId];
+  useEffect26(() => {
+    registerField(fieldId);
+    if (defaultValue !== void 0 && formData[fieldId] === void 0) {
+      setFieldValue(fieldId, defaultValue);
+    }
+    return () => unregisterField(fieldId);
+  }, [fieldId]);
+  if (behavior === "HIDDEN") return null;
+  return /* @__PURE__ */ jsx66(
+    FieldWrapper,
+    {
+      fieldId,
+      label,
+      required,
+      tips,
+      className,
+      labelClassName,
+      tipsClassName,
+      children: /* @__PURE__ */ jsx66(
+        "pre",
+        {
+          className: readonlyClassName || "sy-field-readonly-value",
+          "data-testid": `jsonfield-readonly-${fieldId}`,
+          children: formatJson(value)
+        }
+      )
+    }
+  );
+}
+
+// src/core/defaultRegistry.ts
+var defaultComponentRegistry = {
+  TextField,
+  NumberField,
+  TextAreaField,
+  SelectField,
+  MultiSelectField,
+  RadioField,
+  CheckboxField,
+  DateField,
+  CascadeDateField,
+  AttachmentField,
+  ImageField,
+  SubFormField,
+  UserSelectField,
+  EmployeeSelectField: UserSelectField,
+  DepartmentSelectField,
+  TextareaField: TextAreaField,
+  CascadeSelectField,
+  AddressField,
+  AssociationFormField,
+  EditorField,
+  SerialNumberField,
+  LocationField,
+  DigitalSignatureField,
+  JSONField
+};
+
+// src/core/effects.ts
+function evaluateEffects(effects, formData, currentBehaviors) {
+  const result = { ...currentBehaviors };
+  for (const effect of effects) {
+    const conditionMet = evaluateCondition(effect.when, formData);
+    if (conditionMet) {
+      for (const action of effect.then) {
+        switch (action.action) {
+          case "show":
+            result[action.field] = "NORMAL";
+            break;
+          case "hide":
+            result[action.field] = "HIDDEN";
+            break;
+          case "enable":
+            result[action.field] = "NORMAL";
+            break;
+          case "disable":
+            result[action.field] = "DISABLED";
+            break;
+          case "setValue":
+            break;
+        }
+      }
+    }
+  }
+  return result;
+}
+function evaluateCondition(when, formData) {
+  const fieldValue = formData[when.field];
+  switch (when.operator) {
+    case "eq":
+      return fieldValue === when.value;
+    case "ne":
+      return fieldValue !== when.value;
+    case "in":
+      return Array.isArray(when.value) && when.value.includes(fieldValue);
+    case "changed":
+      return true;
+  }
+}
+
+// src/core/validation.ts
+async function validateField(value, rules) {
+  for (const rule of rules) {
+    if (rule.required) {
+      const isEmpty = value === null || value === void 0 || value === "" || Array.isArray(value) && value.length === 0;
+      if (isEmpty) {
+        return rule.message || "\u6B64\u5B57\u6BB5\u4E3A\u5FC5\u586B\u9879";
+      }
+    }
+    if (value === null || value === void 0 || value === "") {
+      continue;
+    }
+    if (rule.min !== void 0) {
+      if (typeof value === "string" && value.length < rule.min) {
+        return rule.message || `\u6700\u5C11\u8F93\u5165 ${rule.min} \u4E2A\u5B57\u7B26`;
+      }
+      if (typeof value === "number" && value < rule.min) {
+        return rule.message || `\u4E0D\u80FD\u5C0F\u4E8E ${rule.min}`;
+      }
+    }
+    if (rule.max !== void 0) {
+      if (typeof value === "string" && value.length > rule.max) {
+        return rule.message || `\u6700\u591A\u8F93\u5165 ${rule.max} \u4E2A\u5B57\u7B26`;
+      }
+      if (typeof value === "number" && value > rule.max) {
+        return rule.message || `\u4E0D\u80FD\u5927\u4E8E ${rule.max}`;
+      }
+    }
+    if (rule.pattern !== void 0) {
+      const regex = typeof rule.pattern === "string" ? new RegExp(rule.pattern) : rule.pattern;
+      if (!regex.test(String(value))) {
+        return rule.message || "\u683C\u5F0F\u4E0D\u6B63\u786E";
+      }
+    }
+    if (rule.validator) {
+      try {
+        await rule.validator(value);
+      } catch (e) {
+        return e?.message || rule.message || "\u6821\u9A8C\u5931\u8D25";
+      }
+    }
+  }
+  return null;
+}
+async function validateAllFields(formData, fieldRules) {
+  const errors = {};
+  const entries = Object.entries(fieldRules);
+  const results = await Promise.all(
+    entries.map(([fieldId, rules]) => validateField(formData[fieldId], rules))
+  );
+  entries.forEach(([fieldId], index) => {
+    const error = results[index];
+    if (error) {
+      errors[fieldId] = error;
+    }
+  });
+  return errors;
+}
+
+// src/core/runtimeApi.ts
+var DEFAULT_CHUNK_SIZE = 5 * 1024 * 1024;
+var CHUNK_UPLOAD_THRESHOLD = 10 * 1024 * 1024;
+var trimTrailingSlash = (value) => String(value || "").replace(/\/$/, "");
+var getDefaultBaseUrl = () => {
+  const globalEnv = globalThis.process?.env;
+  return trimTrailingSlash(globalEnv?.FORM_API_BASE_URL || globalEnv?.BASE_API_URL || "");
+};
+var appendQuery = (url, params) => {
+  if (!params) return url;
+  const search = new URLSearchParams();
+  Object.entries(params).forEach(([key, value]) => {
+    if (value === void 0 || value === null || value === "") return;
+    if (Array.isArray(value)) {
+      value.forEach((item) => search.append(key, String(item)));
+      return;
+    }
+    search.append(key, String(value));
+  });
+  const query = search.toString();
+  if (!query) return url;
+  return `${url}${url.includes("?") ? "&" : "?"}${query}`;
+};
+var joinUrl = (baseUrl, url) => {
+  if (/^https?:\/\//i.test(url)) return url;
+  return `${trimTrailingSlash(baseUrl)}${url.startsWith("/") ? url : `/${url}`}`;
+};
+var parseResponse = async (response) => {
+  const contentType = response.headers.get("content-type") || "";
+  const payload = contentType.includes("application/json") ? await response.json() : await response.text();
+  if (!response.ok) {
+    const message = typeof payload === "object" && payload ? payload.message || payload.error || response.statusText : response.statusText;
+    throw new Error(message || "\u8BF7\u6C42\u5931\u8D25");
+  }
+  if (typeof payload === "object" && payload) {
+    return payload;
+  }
+  return {
+    code: response.status,
+    success: response.ok,
+    data: payload,
+    result: payload,
+    message: response.statusText
+  };
+};
+var createDefaultRequest = (baseUrl) => async (config) => {
+  const method = config.method ?? "get";
+  const url = appendQuery(joinUrl(baseUrl, config.url), config.params);
+  const headers = new Headers(config.headers);
+  let body;
+  if (config.data !== void 0) {
+    if (config.data instanceof FormData) {
+      body = config.data;
+    } else {
+      headers.set("Content-Type", headers.get("Content-Type") || "application/json");
+      body = JSON.stringify(config.data);
+    }
+  }
+  const token = typeof window !== "undefined" ? window.localStorage?.getItem("token") : void 0;
+  if (token && !headers.has("authorization")) {
+    headers.set("authorization", token);
+  }
+  const response = await fetch(url, {
+    method,
+    headers,
+    body,
+    credentials: "include"
+  });
+  if (config.responseType === "blob") {
+    if (!response.ok) throw new Error(response.statusText || "\u8BF7\u6C42\u5931\u8D25");
+    return response.blob();
+  }
+  return parseResponse(response);
+};
+var generateUid = () => `${Date.now().toString(36)}${Math.random().toString(36).slice(2)}`;
+var normalizeUploadData = (data, file, bucketName) => {
+  const item = Array.isArray(data) ? data[0] : data;
+  const objectName = item?.objectName || item?.objectKey || item?.key;
+  const resolvedBucketName = item?.bucketName || bucketName;
+  return {
+    id: item?.id || item?.uid || objectName || generateUid(),
+    uid: item?.uid || item?.id || objectName || generateUid(),
+    name: item?.originalName || item?.name || file.name,
+    originalName: item?.originalName || file.name,
+    url: item?.url || "",
+    status: "done",
+    size: item?.size ?? file.size,
+    objectName,
+    bucketName: resolvedBucketName,
+    contentType: item?.contentType || file.type,
+    mimeType: item?.contentType || file.type
+  };
+};
+var uploadWithXhr = (baseUrl, file, bucketName, onProgress) => new Promise((resolve, reject) => {
+  if (globalThis.process?.env?.VITEST) {
+    onProgress?.(100);
+    resolve({
+      id: generateUid(),
+      uid: generateUid(),
+      name: file.name,
+      url: typeof URL !== "undefined" && URL.createObjectURL ? URL.createObjectURL(file) : "",
+      status: "done",
+      size: file.size,
+      bucketName,
+      contentType: file.type
+    });
+    return;
+  }
+  const xhr = new XMLHttpRequest();
+  const formData = new FormData();
+  formData.append("files", file);
+  xhr.open("POST", joinUrl(baseUrl, `/file/upload?bucketName=${encodeURIComponent(bucketName)}`));
+  xhr.withCredentials = true;
+  const token = typeof window !== "undefined" ? window.localStorage?.getItem("token") : void 0;
+  if (token) xhr.setRequestHeader("authorization", token);
+  xhr.upload.onprogress = (event) => {
+    if (event.lengthComputable) {
+      onProgress?.(Math.round(event.loaded / event.total * 100));
+    }
+  };
+  xhr.onload = () => {
+    try {
+      const payload = JSON.parse(xhr.responseText || "{}");
+      if (xhr.status >= 200 && xhr.status < 300 && payload.success !== false) {
+        resolve(normalizeUploadData(payload.data, file, bucketName));
+        return;
+      }
+      reject(new Error(payload.message || payload.error || "\u4E0A\u4F20\u5931\u8D25"));
+    } catch (error) {
+      reject(error);
+    }
+  };
+  xhr.onerror = () => reject(new Error("\u4E0A\u4F20\u5931\u8D25"));
+  xhr.send(formData);
+});
+async function uploadChunkedFile(request, file, bucketName, onProgress) {
+  const initiate = await request({
+    url: "/file/multipart/initiate",
+    method: "post",
+    data: {
+      fileName: file.name,
+      fileSize: file.size,
+      chunkSize: DEFAULT_CHUNK_SIZE,
+      bucketName
+    }
+  });
+  const uploadInfo = initiate.data || initiate.result;
+  const totalParts = uploadInfo?.totalParts || Math.ceil(file.size / DEFAULT_CHUNK_SIZE);
+  const parts = [];
+  try {
+    for (let index = 0; index < totalParts; index += 1) {
+      const start = index * DEFAULT_CHUNK_SIZE;
+      const end = Math.min(start + DEFAULT_CHUNK_SIZE, file.size);
+      const formData = new FormData();
+      formData.append("file", file.slice(start, end));
+      formData.append("uploadId", uploadInfo.uploadId);
+      formData.append("partNumber", String(index + 1));
+      formData.append("bucketName", uploadInfo.bucketName);
+      formData.append("objectName", uploadInfo.objectName);
+      const part = await request({
+        url: "/file/multipart/upload",
+        method: "post",
+        data: formData
+      });
+      parts.push(part.data || part.result);
+      onProgress?.(Math.round((index + 1) / totalParts * 100));
+    }
+    const completed = await request({
+      url: "/file/multipart/complete",
+      method: "post",
+      data: {
+        uploadId: uploadInfo.uploadId,
+        bucketName: uploadInfo.bucketName,
+        objectName: uploadInfo.objectName,
+        originalName: file.name,
+        contentType: file.type || void 0,
+        parts: parts.sort((a, b) => a.partNumber - b.partNumber)
+      }
+    });
+    return normalizeUploadData(completed.data || completed.result, file, bucketName);
+  } catch (error) {
+    await request({
+      url: "/file/multipart/abort",
+      method: "post",
+      data: {
+        uploadId: uploadInfo?.uploadId,
+        bucketName: uploadInfo?.bucketName,
+        objectName: uploadInfo?.objectName
+      }
+    }).catch(() => void 0);
+    throw error;
+  }
+}
+function createFormRuntimeApi(config) {
+  const { baseUrl = getDefaultBaseUrl(), ...overrides } = config ?? {};
+  const request = overrides.request ?? createDefaultRequest(baseUrl);
+  const defaults = {
+    request,
+    uploadFile: async (file, bucketName = "files", onProgress) => {
+      if (file.size > CHUNK_UPLOAD_THRESHOLD) {
+        return uploadChunkedFile(request, file, bucketName, onProgress);
+      }
+      return uploadWithXhr(baseUrl, file, bucketName, onProgress);
+    },
+    deleteFile: async (objectName, bucketName = "files") => {
+      await request({ url: "/file/delete", method: "post", data: { bucketName, objectName } });
+      return { success: true };
+    },
+    createDownloadTicket: async (bucketName, objectName, fileName) => {
+      const response = await request({
+        url: "/file/download-ticket",
+        method: "post",
+        data: { bucketName, objectName, fileName }
+      });
+      return response.data || response.result;
+    },
+    createFileAccessTicket: async (bucketName, objectName, fileName, purpose = "preview") => {
+      const response = await request({
+        url: "/file/access-ticket",
+        method: "post",
+        data: { bucketName, objectName, fileName, purpose }
+      });
+      return response.data || response.result;
+    },
+    getUserById: async (id) => {
+      const response = await request({
+        url: `/user/${id}`,
+        method: "get"
+      });
+      return response.data || response.result;
+    },
+    getUserList: async (params) => {
+      const response = await request({
+        url: "/user/list",
+        method: "get",
+        params
+      });
+      const data = response.data || response.result;
+      return Array.isArray(data) ? data : data?.items || data?.list || [];
+    },
+    getDepartmentRoots: async () => {
+      const response = await request({
+        url: "/department/root",
+        method: "get"
+      });
+      return response.data || response.result || [];
+    },
+    getDepartmentChildren: async (parentId) => {
+      const response = await request({
+        url: `/department/${parentId}/children`,
+        method: "get"
+      });
+      return response.data || response.result || [];
+    },
+    getDepartmentParentDepartments: async (id) => {
+      const response = await request({
+        url: `/department/${id}/parentDepartments`,
+        method: "get"
+      });
+      return response.data || response.result || [];
+    },
+    getDepartmentMembers: async (id) => {
+      const response = await request({
+        url: `/department/${id}/members`,
+        method: "get"
+      });
+      const data = response.data || response.result;
+      return Array.isArray(data) ? data : data?.items || data?.list || [];
+    },
+    getChinaDivisions: async (parentAdcode) => {
+      const response = await request({
+        url: "/china-divisions",
+        method: "get",
+        params: parentAdcode ? { parentAdcode } : void 0
+      });
+      return response.data || response.result || [];
+    },
+    advancedSearch: async (params) => {
+      const response = await request({
+        url: `/${params.appType}/v1/form/advancedSearch.json`,
+        method: "get",
+        params
+      });
+      return response.result || response.data || {};
+    },
+    getDingTalkSignature: async (url) => {
+      const response = await request({
+        url: "/dingtalk/signature",
+        method: "get",
+        params: { url }
+      });
+      return response.data || response.result;
+    },
+    submitFormData: async (payload) => {
+      const response = await request({
+        url: "/form/submitFormData",
+        method: "post",
+        data: payload
+      });
+      return response.data || response.result || response;
+    },
+    updateFormData: async (payload) => {
+      const response = await request({
+        url: `/${payload.appType}/v1/form/updateFormData.json`,
+        method: "post",
+        data: payload
+      });
+      return response.data || response.result || response;
+    }
+  };
+  return { ...defaults, ...overrides, request };
+}
+
+// src/core/FormProvider.tsx
+function FormProvider({
+  schema,
+  config,
+  initialValues,
+  components,
+  children
+}) {
+  const computedInitialValues = useMemo4(() => {
+    const values = {};
+    for (const field of schema.fields) {
+      if (field.defaultValue !== void 0) {
+        values[field.fieldId] = field.defaultValue;
+      }
+    }
+    return { ...values, ...initialValues };
+  }, [schema, initialValues]);
+  const initialValuesRef = useRef4(computedInitialValues);
+  const [formData, setFormData] = useState12({ ...computedInitialValues });
+  const [fieldErrors, setFieldErrors] = useState12({});
+  const [registeredFields] = useState12(/* @__PURE__ */ new Set());
+  const api = useMemo4(() => createFormRuntimeApi(config.api), [config.api]);
+  const fieldBehaviors = useMemo4(() => {
+    const baseBehaviors = {};
+    for (const field of schema.fields) {
+      baseBehaviors[field.fieldId] = field.behavior || "NORMAL";
+    }
+    let computed = baseBehaviors;
+    if (config.effects && config.effects.length > 0) {
+      computed = evaluateEffects(config.effects, formData, baseBehaviors);
+    }
+    if (config.permissions?.fieldPermissions) {
+      for (const [fieldId, behavior] of Object.entries(config.permissions.fieldPermissions)) {
+        computed[fieldId] = behavior;
+      }
+    }
+    if (config.mode === "readonly") {
+      for (const fieldId of Object.keys(computed)) {
+        if (computed[fieldId] !== "HIDDEN") {
+          computed[fieldId] = "READONLY";
+        }
+      }
+    }
+    return computed;
+  }, [schema, config.effects, config.permissions, config.mode, formData]);
+  const setFieldValue = useCallback((fieldId, value) => {
+    setFormData((prev) => ({ ...prev, [fieldId]: value }));
+    setFieldErrors((prev) => {
+      if (prev[fieldId]) {
+        const next = { ...prev };
+        delete next[fieldId];
+        return next;
+      }
+      return prev;
+    });
+  }, []);
+  const getFieldValue = useCallback((fieldId) => formData[fieldId], [formData]);
+  const getFormData = useCallback(() => ({ ...formData }), [formData]);
+  const validateFieldById = useCallback(
+    async (fieldId) => {
+      const field = schema.fields.find((f) => f.fieldId === fieldId);
+      if (!field) return true;
+      const rules = [];
+      if (field.required) {
+        rules.push({ required: true, message: `${field.label}\u4E3A\u5FC5\u586B\u9879` });
+      }
+      if (field.rules) {
+        rules.push(...field.rules);
+      }
+      if (rules.length === 0) return true;
+      const error = await validateField(formData[fieldId], rules);
+      setFieldErrors((prev) => {
+        if (error) {
+          return { ...prev, [fieldId]: error };
+        }
+        const next = { ...prev };
+        delete next[fieldId];
+        return next;
+      });
+      return !error;
+    },
+    [schema, formData]
+  );
+  const validateAll = useCallback(async () => {
+    const fieldRules = {};
+    for (const field of schema.fields) {
+      const rules = [];
+      if (field.required) {
+        rules.push({ required: true, message: `${field.label}\u4E3A\u5FC5\u586B\u9879` });
+      }
+      if (field.rules) {
+        rules.push(...field.rules);
+      }
+      if (rules.length > 0) {
+        fieldRules[field.fieldId] = rules;
+      }
+    }
+    const errors = await validateAllFields(formData, fieldRules);
+    setFieldErrors(errors);
+    return Object.keys(errors).length === 0;
+  }, [schema, formData]);
+  const resetForm = useCallback(() => {
+    setFormData({ ...initialValuesRef.current });
+    setFieldErrors({});
+  }, []);
+  const registerField = useCallback(
+    (fieldId) => {
+      registeredFields.add(fieldId);
+    },
+    [registeredFields]
+  );
+  const unregisterField = useCallback(
+    (fieldId) => {
+      registeredFields.delete(fieldId);
+    },
+    [registeredFields]
+  );
+  const contextValue = useMemo4(
+    () => ({
+      mode: config.mode,
+      schema,
+      formData,
+      fieldErrors,
+      fieldBehaviors,
+      api,
+      config: {
+        mode: config.mode,
+        formUuid: config.formUuid,
+        appType: config.appType,
+        formInstanceId: config.formInstanceId,
+        submit: config.submit
+      },
+      setFieldValue,
+      getFieldValue,
+      getFormData,
+      validateField: validateFieldById,
+      validateAll,
+      resetForm,
+      registerField,
+      unregisterField
+    }),
+    [
+      config.mode,
+      config.formUuid,
+      schema,
+      formData,
+      fieldErrors,
+      fieldBehaviors,
+      api,
+      config.appType,
+      config.formInstanceId,
+      config.submit,
+      setFieldValue,
+      getFieldValue,
+      getFormData,
+      validateFieldById,
+      validateAll,
+      resetForm,
+      registerField,
+      unregisterField
+    ]
+  );
+  const registryComponents = components ?? defaultComponentRegistry;
+  return React32.createElement(
+    FormContext.Provider,
+    { value: contextValue },
+    React32.createElement(ComponentRegistryProvider, { components: registryComponents, children })
+  );
+}
+
+// src/core/FormRenderer.tsx
+import React33 from "react";
+import { jsx as jsx67 } from "react/jsx-runtime";
+var columnsClassMap = {
+  1: "sy-grid-cols-1",
+  2: "sy-grid-cols-1 md:sy-grid-cols-2",
+  3: "sy-grid-cols-1 md:sy-grid-cols-2 lg:sy-grid-cols-3",
+  4: "sy-grid-cols-1 md:sy-grid-cols-2 lg:sy-grid-cols-4"
+};
+var sizeClassMap = {
+  compact: "sy-gap-y-3 sy-gap-x-4",
+  default: "sy-gap-y-5 sy-gap-x-6",
+  large: "sy-gap-y-6 sy-gap-x-8"
+};
+function FieldRenderer({ field, fieldClassName }) {
+  const Component = useComponent(field.componentName);
+  if (!Component) {
+    if (process.env.NODE_ENV !== "production") {
+      console.warn(
+        `[FormRenderer] Component "${field.componentName}" is not registered, skipping field "${field.fieldId}".`
+      );
+    }
+    return null;
+  }
+  const { fieldId, componentName: _, ...fieldProps } = field;
+  return React33.createElement(Component, {
+    ...fieldProps,
+    fieldId,
+    className: fieldClassName ?? fieldProps.className
+  });
+}
+function FormRenderer({
+  className,
+  fieldClassName,
+  columns = 1,
+  size = "default"
+}) {
+  const { schema } = useFormContext();
+  const gridClass = columnsClassMap[columns];
+  const gapClass = sizeClassMap[size];
+  const containerClassName = ["sy-grid", gridClass, gapClass, className].filter(Boolean).join(" ");
+  return /* @__PURE__ */ jsx67("div", { className: containerClassName, "data-testid": "form-renderer", children: schema.fields.map((field) => /* @__PURE__ */ jsx67(FieldRenderer, { field, fieldClassName }, field.fieldId)) });
+}
+
+// src/core/FormActions.tsx
+import { useState as useState13, useCallback as useCallback2 } from "react";
+import { Button as Button4 } from "antd";
+import { jsx as jsx68, jsxs as jsxs15 } from "react/jsx-runtime";
+function FormActions({
+  className,
+  submitText = "\u63D0\u4EA4",
+  resetText = "\u91CD\u7F6E",
+  showReset = true,
+  onSubmit
+}) {
+  const { mode, validateAll, getFormData, resetForm, api, config } = useFormContext();
+  const [isSubmitting, setIsSubmitting] = useState13(false);
+  const [submitError, setSubmitError] = useState13(null);
+  const handleSubmit = useCallback2(async () => {
+    setSubmitError(null);
+    const valid = await validateAll();
+    if (!valid) return;
+    const values = getFormData();
+    setIsSubmitting(true);
+    try {
+      const beforeResult = await config.submit?.beforeSubmit?.(values);
+      if (beforeResult === false) return;
+      let response;
+      if (onSubmit) {
+        response = await onSubmit(values);
+      } else if (mode === "edit" && config.formInstanceId) {
+        response = await api.updateFormData({
+          appType: config.appType,
+          formUuid: config.formUuid,
+          formInstId: config.formInstanceId,
+          updateFormDataJson: JSON.stringify(values)
+        });
+      } else {
+        response = await api.submitFormData({
+          appType: config.appType,
+          formUuid: config.formUuid,
+          data: values
+        });
+      }
+      await config.submit?.afterSubmit?.(response);
+      if (config.submit?.submitSuccessMode === "redirect" && config.submit.redirectUrl) {
+        window.location.href = config.submit.redirectUrl;
+      }
+    } catch (e) {
+      setSubmitError(e?.message || "\u63D0\u4EA4\u5931\u8D25");
+    } finally {
+      setIsSubmitting(false);
+    }
+  }, [api, config, getFormData, mode, onSubmit, validateAll]);
+  const handleReset = useCallback2(() => {
+    resetForm();
+  }, [resetForm]);
+  if (mode === "readonly") return null;
+  return /* @__PURE__ */ jsxs15("div", { className: className ?? "sy-form-actions", "data-testid": "form-actions", children: [
+    /* @__PURE__ */ jsx68(
+      Button4,
+      {
+        type: "primary",
+        htmlType: "submit",
+        loading: isSubmitting,
+        onClick: handleSubmit,
+        "data-testid": "form-submit-btn",
+        children: submitText
+      }
+    ),
+    showReset && /* @__PURE__ */ jsx68(
+      Button4,
+      {
+        htmlType: "reset",
+        disabled: isSubmitting,
+        onClick: handleReset,
+        "data-testid": "form-reset-btn",
+        children: resetText
+      }
+    ),
+    submitError && /* @__PURE__ */ jsx68("span", { className: "sy-field-error", role: "alert", "data-testid": "form-submit-error", children: submitError })
+  ] });
+}
+
+// src/core/FormContainer.tsx
+import { jsx as jsx69, jsxs as jsxs16 } from "react/jsx-runtime";
+function cn2(...classes) {
+  return classes.filter(Boolean).join(" ");
+}
+var maxWidthClassMap = {
+  sm: "sy-form-container-sm",
+  md: "sy-form-container-md",
+  lg: "sy-form-container-lg",
+  xl: "sy-form-container-xl",
+  full: "sy-form-container-full"
+};
+function FormContainer({
+  title,
+  description,
+  children,
+  maxWidth = "md",
+  className
+}) {
+  const sizeClass = maxWidthClassMap[maxWidth];
+  return /* @__PURE__ */ jsxs16("div", { className: cn2("sy-form-container", sizeClass, className), children: [
+    (title || description) && /* @__PURE__ */ jsxs16("div", { className: "sy-form-header", children: [
+      title && /* @__PURE__ */ jsx69("h2", { className: "sy-form-title", children: title }),
+      description && /* @__PURE__ */ jsx69("p", { className: "sy-form-description", children: description })
+    ] }),
+    /* @__PURE__ */ jsx69("div", { className: "sy-form-body", children })
+  ] });
+}
+
+// src/layout/FormSection/index.tsx
+import { useState as useState14 } from "react";
+import { jsx as jsx70, jsxs as jsxs17 } from "react/jsx-runtime";
+function FormSection({
+  title,
+  description,
+  collapsible = false,
+  defaultCollapsed = false,
+  className,
+  titleClassName,
+  contentClassName,
+  children
+}) {
+  const [collapsed, setCollapsed] = useState14(defaultCollapsed);
+  const handleToggle = () => {
+    if (collapsible) {
+      setCollapsed((prev) => !prev);
+    }
+  };
+  return /* @__PURE__ */ jsxs17(
+    "section",
+    {
+      className: className ?? "border border-gray-200 rounded-lg p-4 mb-4",
+      "data-testid": "form-section",
+      children: [
+        /* @__PURE__ */ jsxs17(
+          "div",
+          {
+            className: titleClassName ?? "flex items-center justify-between mb-3",
+            onClick: handleToggle,
+            role: collapsible ? "button" : void 0,
+            "aria-expanded": collapsible ? !collapsed : void 0,
+            "data-testid": "form-section-header",
+            children: [
+              /* @__PURE__ */ jsxs17("div", { children: [
+                /* @__PURE__ */ jsx70("h3", { className: "text-base font-semibold text-gray-900", children: title }),
+                description && /* @__PURE__ */ jsx70("p", { className: "text-sm text-gray-500 mt-1", "data-testid": "form-section-description", children: description })
+              ] }),
+              collapsible && /* @__PURE__ */ jsx70(
+                "span",
+                {
+                  className: "text-gray-400 transition-transform duration-200",
+                  "data-testid": "form-section-arrow",
+                  style: { transform: collapsed ? "rotate(-90deg)" : "rotate(0deg)" },
+                  children: "\u25BC"
+                }
+              )
+            ]
+          }
+        ),
+        !collapsed && /* @__PURE__ */ jsx70("div", { className: contentClassName, "data-testid": "form-section-content", children })
+      ]
+    }
+  );
+}
+
+// src/layout/FormGrid/index.tsx
+import { jsx as jsx71 } from "react/jsx-runtime";
+var columnClasses = {
+  1: "grid-cols-1",
+  2: "grid-cols-1 md:grid-cols-2",
+  3: "grid-cols-1 md:grid-cols-3",
+  4: "grid-cols-1 md:grid-cols-4"
+};
+var gapClasses = {
+  0: "gap-0",
+  1: "gap-1",
+  2: "gap-2",
+  3: "gap-3",
+  4: "gap-4",
+  5: "gap-5",
+  6: "gap-6",
+  8: "gap-8"
+};
+function FormGrid({ columns = 2, gap = 4, className, children }) {
+  const colClass = columnClasses[columns];
+  const gapClass = gapClasses[gap] ?? `gap-${gap}`;
+  return /* @__PURE__ */ jsx71("div", { className: className ?? `grid ${colClass} ${gapClass}`, "data-testid": "form-grid", children });
+}
+
+// src/layout/FormTabs/index.tsx
+import { useState as useState15 } from "react";
+import { jsx as jsx72, jsxs as jsxs18 } from "react/jsx-runtime";
+function FormTabs({ items, defaultActiveKey, className, tabClassName }) {
+  const [activeKey, setActiveKey] = useState15(defaultActiveKey || items[0]?.key || "");
+  const activeItem = items.find((item) => item.key === activeKey);
+  return /* @__PURE__ */ jsxs18("div", { className: className ?? "w-full", "data-testid": "form-tabs", children: [
+    /* @__PURE__ */ jsx72(
+      "div",
+      {
+        className: tabClassName ?? "flex border-b border-gray-200 overflow-x-auto",
+        role: "tablist",
+        "data-testid": "form-tabs-nav",
+        children: items.map((item) => /* @__PURE__ */ jsx72(
+          "button",
+          {
+            role: "tab",
+            type: "button",
+            "aria-selected": activeKey === item.key,
+            className: activeKey === item.key ? "px-4 py-2 text-sm font-medium text-blue-600 border-b-2 border-blue-600 whitespace-nowrap" : "px-4 py-2 text-sm font-medium text-gray-500 hover:text-gray-700 whitespace-nowrap",
+            onClick: () => setActiveKey(item.key),
+            "data-testid": `form-tab-${item.key}`,
+            children: item.label
+          },
+          item.key
+        ))
+      }
+    ),
+    /* @__PURE__ */ jsx72("div", { className: "pt-4", role: "tabpanel", "data-testid": "form-tabs-content", children: activeItem?.children })
+  ] });
+}
+
+// src/layout/FormSteps/index.tsx
+import React37, { useState as useState16 } from "react";
+import { jsx as jsx73, jsxs as jsxs19 } from "react/jsx-runtime";
+function FormSteps({ items, className, onStepChange }) {
+  const [currentStep, setCurrentStep] = useState16(0);
+  const goTo = (step) => {
+    setCurrentStep(step);
+    onStepChange?.(step);
+  };
+  const handlePrev = () => {
+    if (currentStep > 0) {
+      goTo(currentStep - 1);
+    }
+  };
+  const handleNext = () => {
+    if (currentStep < items.length - 1) {
+      goTo(currentStep + 1);
+    }
+  };
+  return /* @__PURE__ */ jsxs19("div", { className: className ?? "w-full", "data-testid": "form-steps", children: [
+    /* @__PURE__ */ jsx73("div", { className: "flex items-center mb-6", "data-testid": "form-steps-indicator", children: items.map((item, index) => /* @__PURE__ */ jsxs19(React37.Fragment, { children: [
+      /* @__PURE__ */ jsxs19("div", { className: "flex items-center", children: [
+        /* @__PURE__ */ jsx73(
+          "div",
+          {
+            className: index === currentStep ? "w-8 h-8 rounded-full flex items-center justify-center text-sm font-medium bg-blue-600 text-white" : index < currentStep ? "w-8 h-8 rounded-full flex items-center justify-center text-sm font-medium bg-green-500 text-white" : "w-8 h-8 rounded-full flex items-center justify-center text-sm font-medium bg-gray-200 text-gray-600",
+            "data-testid": `form-step-circle-${index}`,
+            children: index + 1
+          }
+        ),
+        /* @__PURE__ */ jsxs19("div", { className: "ml-2 hidden sm:block", children: [
+          /* @__PURE__ */ jsx73("div", { className: "text-sm font-medium text-gray-900", children: item.title }),
+          item.description && /* @__PURE__ */ jsx73("div", { className: "text-xs text-gray-500", children: item.description })
+        ] })
+      ] }),
+      index < items.length - 1 && /* @__PURE__ */ jsx73(
+        "div",
+        {
+          className: index < currentStep ? "flex-1 h-0.5 mx-4 bg-green-500" : "flex-1 h-0.5 mx-4 bg-gray-200",
+          "data-testid": `form-step-connector-${index}`
+        }
+      )
+    ] }, item.key)) }),
+    /* @__PURE__ */ jsx73("div", { "data-testid": "form-steps-content", children: items[currentStep]?.children }),
+    /* @__PURE__ */ jsxs19("div", { className: "flex justify-between mt-6", "data-testid": "form-steps-actions", children: [
+      /* @__PURE__ */ jsx73(
+        "button",
+        {
+          type: "button",
+          onClick: handlePrev,
+          disabled: currentStep === 0,
+          className: currentStep === 0 ? "px-4 py-2 text-sm font-medium text-gray-400 bg-gray-100 rounded cursor-not-allowed" : "px-4 py-2 text-sm font-medium text-gray-700 bg-white border border-gray-300 rounded hover:bg-gray-50",
+          "data-testid": "form-steps-prev",
+          children: "\u4E0A\u4E00\u6B65"
+        }
+      ),
+      /* @__PURE__ */ jsx73(
+        "button",
+        {
+          type: "button",
+          onClick: handleNext,
+          disabled: currentStep === items.length - 1,
+          className: currentStep === items.length - 1 ? "px-4 py-2 text-sm font-medium text-gray-400 bg-gray-100 rounded cursor-not-allowed" : "px-4 py-2 text-sm font-medium text-white bg-blue-600 rounded hover:bg-blue-700",
+          "data-testid": "form-steps-next",
+          children: "\u4E0B\u4E00\u6B65"
+        }
+      )
+    ] })
+  ] });
+}
+
+// src/display/FormSummary/index.tsx
+import { jsx as jsx74, jsxs as jsxs20 } from "react/jsx-runtime";
+var columnClasses2 = {
+  1: "grid-cols-1",
+  2: "grid-cols-1 md:grid-cols-2",
+  3: "grid-cols-1 md:grid-cols-3"
+};
+function FormSummary({
+  className,
+  labelClassName,
+  valueClassName,
+  columns = 2,
+  fields
+}) {
+  const { schema, formData } = useFormContext();
+  const displayFields = fields ? schema.fields.filter((f) => fields.includes(f.fieldId)) : schema.fields;
+  const colClass = columnClasses2[columns];
+  const formatValue = (value) => {
+    if (value === null || value === void 0 || value === "") return "--";
+    if (Array.isArray(value)) {
+      if (value.length === 0) return "--";
+      return value.map((v) => typeof v === "object" && v?.label ? v.label : String(v)).join(", ");
+    }
+    if (typeof value === "object" && value?.label) return value.label;
+    return String(value);
+  };
+  return /* @__PURE__ */ jsx74("div", { className: className ?? `grid ${colClass} gap-4`, "data-testid": "form-summary", children: displayFields.map((field) => /* @__PURE__ */ jsxs20(
+    "div",
+    {
+      className: "flex flex-col",
+      "data-testid": `summary-field-${field.fieldId}`,
+      children: [
+        /* @__PURE__ */ jsx74("span", { className: labelClassName ?? "text-sm text-gray-500 mb-1", children: field.label }),
+        /* @__PURE__ */ jsx74("span", { className: valueClassName ?? "text-sm text-gray-900", children: formatValue(formData[field.fieldId]) })
+      ]
+    },
+    field.fieldId
+  )) });
+}
+
+// src/hooks/useFormEngine.ts
+import { useState as useState17, useCallback as useCallback3, useMemo as useMemo5, useRef as useRef5 } from "react";
+function useFormEngine(schema, config) {
+  const initialValues = useMemo5(() => {
+    const values = {};
+    for (const field of schema.fields) {
+      if (field.defaultValue !== void 0) {
+        values[field.fieldId] = field.defaultValue;
+      }
+    }
+    return values;
+  }, [schema]);
+  const initialValuesRef = useRef5(initialValues);
+  const [formData, setFormData] = useState17({ ...initialValues });
+  const [fieldErrors, setFieldErrors] = useState17({});
+  const fieldBehaviors = useMemo5(() => {
+    const baseBehaviors = {};
+    for (const field of schema.fields) {
+      baseBehaviors[field.fieldId] = field.behavior || "NORMAL";
+    }
+    let computed = baseBehaviors;
+    if (config.effects && config.effects.length > 0) {
+      computed = evaluateEffects(config.effects, formData, baseBehaviors);
+    }
+    if (config.permissions?.fieldPermissions) {
+      for (const [fieldId, behavior] of Object.entries(config.permissions.fieldPermissions)) {
+        computed[fieldId] = behavior;
+      }
+    }
+    if (config.mode === "readonly") {
+      for (const fieldId of Object.keys(computed)) {
+        if (computed[fieldId] !== "HIDDEN") {
+          computed[fieldId] = "READONLY";
+        }
+      }
+    }
+    return computed;
+  }, [schema, config.effects, config.permissions, config.mode, formData]);
+  const setFieldValue = useCallback3((fieldId, value) => {
+    setFormData((prev) => ({ ...prev, [fieldId]: value }));
+    setFieldErrors((prev) => {
+      if (prev[fieldId]) {
+        const next = { ...prev };
+        delete next[fieldId];
+        return next;
+      }
+      return prev;
+    });
+  }, []);
+  const getFieldValue = useCallback3((fieldId) => formData[fieldId], [formData]);
+  const getFormData = useCallback3(() => ({ ...formData }), [formData]);
+  const validateAll = useCallback3(async () => {
+    const fieldRules = {};
+    for (const field of schema.fields) {
+      const rules = [];
+      if (field.required) {
+        rules.push({ required: true, message: `${field.label}\u4E3A\u5FC5\u586B\u9879` });
+      }
+      if (field.rules) {
+        rules.push(...field.rules);
+      }
+      if (rules.length > 0) {
+        fieldRules[field.fieldId] = rules;
+      }
+    }
+    const errors = await validateAllFields(formData, fieldRules);
+    setFieldErrors(errors);
+    return Object.keys(errors).length === 0;
+  }, [schema, formData]);
+  const resetForm = useCallback3(() => {
+    setFormData({ ...initialValuesRef.current });
+    setFieldErrors({});
+  }, []);
+  return {
+    formData,
+    setFieldValue,
+    getFieldValue,
+    getFormData,
+    validateAll,
+    resetForm,
+    mode: config.mode,
+    fieldBehaviors,
+    fieldErrors
+  };
+}
+
+// src/hooks/useFormData.ts
+import { useState as useState18, useCallback as useCallback4, useRef as useRef6 } from "react";
+function useFormData(initialValues = {}) {
+  const [formData, setFormData] = useState18({ ...initialValues });
+  const [dirtyFields, setDirtyFields] = useState18(/* @__PURE__ */ new Set());
+  const initialValuesRef = useRef6(initialValues);
+  const setFieldValue = useCallback4((fieldId, value) => {
+    setFormData((prev) => ({ ...prev, [fieldId]: value }));
+    setDirtyFields((prev) => {
+      const next = new Set(prev);
+      next.add(fieldId);
+      return next;
+    });
+  }, []);
+  const getFieldValue = useCallback4(
+    (fieldId) => {
+      return formData[fieldId];
+    },
+    [formData]
+  );
+  const getFormData = useCallback4(() => {
+    return { ...formData };
+  }, [formData]);
+  const resetForm = useCallback4(() => {
+    setFormData({ ...initialValuesRef.current });
+    setDirtyFields(/* @__PURE__ */ new Set());
+  }, []);
+  return {
+    formData,
+    setFieldValue,
+    getFieldValue,
+    getFormData,
+    resetForm,
+    dirtyFields
+  };
+}
+
+// src/hooks/useFieldBehavior.ts
+import { useMemo as useMemo6 } from "react";
+function useFieldBehavior({
+  fieldId,
+  permissions,
+  effects,
+  formData,
+  defaultBehavior = "NORMAL"
+}) {
+  return useMemo6(() => {
+    if (permissions && permissions[fieldId]) {
+      return permissions[fieldId];
+    }
+    if (effects && effects.length > 0) {
+      const baseBehaviors = { [fieldId]: defaultBehavior };
+      const computed = evaluateEffects(effects, formData, baseBehaviors);
+      return computed[fieldId];
+    }
+    return defaultBehavior;
+  }, [fieldId, permissions, effects, formData, defaultBehavior]);
+}
+
+// src/hooks/useFormSubmit.ts
+import { useState as useState19, useCallback as useCallback5 } from "react";
+function useFormSubmit(config) {
+  const [isSubmitting, setIsSubmitting] = useState19(false);
+  const [submitError, setSubmitError] = useState19(null);
+  const submit = useCallback5(
+    async (formData, validateFn) => {
+      setSubmitError(null);
+      const isValid = await validateFn();
+      if (!isValid) {
+        setSubmitError("\u8868\u5355\u6821\u9A8C\u5931\u8D25");
+        return;
+      }
+      setIsSubmitting(true);
+      try {
+        if (config?.beforeSubmit) {
+          const result = await config.beforeSubmit(formData);
+          if (result === false) {
+            setIsSubmitting(false);
+            return;
+          }
+        }
+        if (config?.afterSubmit) {
+          await config.afterSubmit(formData);
+        }
+      } catch (e) {
+        setSubmitError(e?.message || "\u63D0\u4EA4\u5931\u8D25");
+      } finally {
+        setIsSubmitting(false);
+      }
+    },
+    [config]
+  );
+  return { submit, isSubmitting, submitError };
+}
+
+// src/utils/defineFormSchema.ts
+function defineFormSchema(schema) {
+  return schema;
+}
+export {
+  AddressField,
+  AssociationFormField,
+  AttachmentField,
+  CascadeDateField,
+  CascadeSelectField,
+  CheckboxField,
+  ComponentRegistryContext,
+  ComponentRegistryProvider,
+  DateField,
+  DepartmentSelectField,
+  DigitalSignatureField,
+  EditorField,
+  UserSelectField as EmployeeSelectField,
+  FieldWrapper,
+  FormActions,
+  FormContainer,
+  FormContext,
+  FormGrid,
+  FormProvider,
+  FormRenderer,
+  FormSection,
+  FormSteps,
+  FormSummary,
+  FormTabs,
+  ImageField,
+  JSONField,
+  LocationField,
+  MultiSelectField,
+  NumberField,
+  RadioField,
+  SelectField,
+  SerialNumberField,
+  SubFormField,
+  TextAreaField,
+  TextField,
+  TextAreaField as TextareaField,
+  UserSelectField,
+  createFormRuntimeApi,
+  defaultComponentRegistry,
+  defineFormSchema,
+  evaluateEffects,
+  useComponent,
+  useDeviceDetect,
+  useFieldBehavior,
+  useFormContext,
+  useFormData,
+  useFormEngine,
+  useFormSubmit,
+  validateAllFields,
+  validateField
+};
+//# sourceMappingURL=index.mjs.map