react-native-system-ui 0.0.1 → 0.0.2

package/dist/cjs/flex/FlexItem.js

@@ -0,0 +1,95 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.FlexItem = void 0;
+function _react() {
+  const data = _interopRequireWildcard(require("react"));
+  _react = function () {
+    return data;
+  };
+  return data;
+}
+function _reactNative() {
+  const data = require("react-native");
+  _reactNative = function () {
+    return data;
+  };
+  return data;
+}
+var _FlexContext = require("./FlexContext");
+var _utils = require("../../utils");
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+const parseFlex = value => {
+  if ((0, _utils.isNumber)(value)) return {
+    flex: value
+  };
+  if (!value) return undefined;
+  const str = value.trim();
+  if (!str) return undefined;
+  if (str === 'auto') return {
+    flexGrow: 1,
+    flexShrink: 1,
+    flexBasis: 'auto'
+  };
+  if (str === 'none') return {
+    flexGrow: 0,
+    flexShrink: 0,
+    flexBasis: 'auto'
+  };
+  const num = Number(str);
+  if ((0, _utils.isNumber)(num)) return {
+    flex: num
+  };
+  const parts = str.split(/\s+/);
+  if (parts.length >= 2) {
+    const [grow, shrink] = parts.map(Number);
+    if ((0, _utils.isNumber)(grow) && (0, _utils.isNumber)(shrink)) {
+      const basisStr = parts.slice(2).join(' ');
+      let flexBasis;
+      if (basisStr === 'auto') flexBasis = 'auto';else if (basisStr) {
+        const pxMatch = basisStr.match(/^(-?\d+(?:\.\d+)?)px$/);
+        const basisNum = pxMatch ? Number(pxMatch[1]) : Number(basisStr);
+        if ((0, _utils.isNumber)(basisNum)) {
+          flexBasis = basisNum;
+        }
+      }
+      return {
+        flexGrow: grow,
+        flexShrink: shrink,
+        flexBasis
+      };
+    }
+  }
+  return undefined;
+};
+const FlexItem = ({
+  span,
+  flex,
+  style,
+  children
+}) => {
+  const {
+    horizontalGap,
+    verticalGap,
+    columns
+  } = (0, _react().useContext)(_FlexContext.FlexContext);
+  const supportsGap = _reactNative().Platform.OS === 'web';
+  if ((0, _utils.isNumber)(span) && span <= 0) return null;
+  const widthStyle = {};
+  if ((0, _utils.isNumber)(span)) {
+    const safeColumns = Math.max(1, columns);
+    const percent = Math.min(Math.max(span, 0), safeColumns) / safeColumns;
+    widthStyle.width = `${percent * 100}%`;
+    widthStyle.flexGrow = 0;
+    widthStyle.flexShrink = 0;
+  }
+  return /*#__PURE__*/_react().default.createElement(_reactNative().View, {
+    style: [supportsGap ? null : {
+      paddingHorizontal: horizontalGap / 2,
+      paddingVertical: verticalGap / 2
+    }, widthStyle, parseFlex(flex), style]
+  }, children);
+};
+exports.FlexItem = FlexItem;

package/dist/cjs/form/Form.js

@@ -0,0 +1,372 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useWatch = exports.default = exports.FormSubscribe = void 0;
+function _react() {
+  const data = _interopRequireWildcard(require("react"));
+  _react = function () {
+    return data;
+  };
+  return data;
+}
+function _reactNative() {
+  const data = require("react-native");
+  _reactNative = function () {
+    return data;
+  };
+  return data;
+}
+var _promise = require("../../utils/promise");
+var _validate = require("../../utils/validate");
+var _FormContext = require("./FormContext");
+var _utils = require("./utils");
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+function _extends() { return _extends = Object.assign ? Object.assign.bind() : function (n) { for (var e = 1; e < arguments.length; e++) { var t = arguments[e]; for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); } return n; }, _extends.apply(null, arguments); }
+const runRuleValidation = (rule, value, values) => {
+  const message = rule.message ?? '表单验证未通过';
+  const empty = value == null || value === '' || Array.isArray(value) && value.length === 0;
+  if (rule.required && (empty || rule.whitespace && (0, _validate.isString)(value) && value.trim().length === 0)) {
+    return message;
+  }
+  if (empty) return null;
+  if (rule.pattern && (0, _validate.isString)(value) && !rule.pattern.test(value)) return message;
+  if (rule.len !== undefined || rule.min !== undefined || rule.max !== undefined) {
+    const length = (0, _validate.isNumber)(value) ? value : (0, _validate.isString)(value) || Array.isArray(value) ? value.length : 0;
+    if (rule.len !== undefined && length !== rule.len) return message;
+    if (rule.min !== undefined && length < rule.min) return message;
+    if (rule.max !== undefined && length > rule.max) return message;
+  }
+  if (!rule.validator) return null;
+  const handle = result => (0, _validate.isString)(result) ? result : result === false ? message : null;
+  const result = rule.validator(value, values);
+  return (0, _promise.isPromiseLike)(result) ? result.then(handle) : handle(result);
+};
+const shallowEqual = (prev, next) => {
+  if (prev === next) return true;
+  if (!prev || !next) return false;
+  const prevKeys = Object.keys(prev);
+  const nextKeys = Object.keys(next);
+  if (prevKeys.length !== nextKeys.length) {
+    return false;
+  }
+  for (const key of prevKeys) {
+    if (prev[key] !== next[key]) {
+      return false;
+    }
+  }
+  return true;
+};
+const InternalForm = /*#__PURE__*/_react().default.forwardRef((props, ref) => {
+  const {
+    initialValues: initialValuesProp,
+    colon,
+    labelWidth,
+    showValidateMessage = true,
+    onValuesChange,
+    onFinish,
+    style,
+    footer,
+    children,
+    ...rest
+  } = props;
+  const defaultInitialValuesRef = (0, _react().useRef)({});
+  const mergedInitialValues = initialValuesProp ?? defaultInitialValuesRef.current;
+  const [values, setValues] = (0, _react().useState)(mergedInitialValues);
+  const [errors, setErrors] = (0, _react().useState)({});
+  const lastInitialValuesRef = (0, _react().useRef)(mergedInitialValues);
+  const fieldsRef = (0, _react().useRef)({});
+  const dependencyGraphRef = (0, _react().useRef)(new Map());
+  const valuesRef = (0, _react().useRef)(values);
+  const errorsRef = (0, _react().useRef)(errors);
+  const validationSeqRef = (0, _react().useRef)({});
+  const subscribersRef = (0, _react().useRef)(new Set());
+  (0, _react().useEffect)(() => {
+    if (shallowEqual(lastInitialValuesRef.current, mergedInitialValues)) {
+      return;
+    }
+    lastInitialValuesRef.current = mergedInitialValues;
+    valuesRef.current = mergedInitialValues;
+    errorsRef.current = {};
+    setValues(mergedInitialValues);
+    setErrors({});
+  }, [mergedInitialValues]);
+  const setFieldErrors = (0, _react().useCallback)((name, nextErrors) => {
+    const key = (0, _utils.serializeNamePath)(name);
+    setErrors(prev => {
+      const prevErrors = prev[key];
+      if (!nextErrors.length) {
+        if (!prevErrors) return prev;
+        const clone = {
+          ...prev
+        };
+        delete clone[key];
+        errorsRef.current = clone;
+        return clone;
+      }
+      if (prevErrors?.[0] === nextErrors[0] && prevErrors.length === nextErrors.length) {
+        return prev;
+      }
+      const clone = {
+        ...prev,
+        [key]: nextErrors
+      };
+      errorsRef.current = clone;
+      return clone;
+    });
+  }, []);
+  const registerField = (0, _react().useCallback)((name, options) => {
+    const key = (0, _utils.serializeNamePath)(name);
+    const prev = fieldsRef.current[key];
+    if (prev?.dependencies?.length) {
+      for (const dep of prev.dependencies) {
+        const depKey = (0, _utils.serializeNamePath)(dep);
+        const set = dependencyGraphRef.current.get(depKey);
+        if (!set) continue;
+        set.delete(key);
+        if (!set.size) dependencyGraphRef.current.delete(depKey);
+      }
+    }
+    fieldsRef.current[key] = {
+      ...options,
+      name
+    };
+    if (options.dependencies?.length) {
+      for (const dep of options.dependencies) {
+        const depKey = (0, _utils.serializeNamePath)(dep);
+        const set = dependencyGraphRef.current.get(depKey);
+        if (set) {
+          set.add(key);
+        } else {
+          dependencyGraphRef.current.set(depKey, new Set([key]));
+        }
+      }
+    }
+    if (options.initialValue !== undefined) {
+      const existsInInitial = (0, _utils.getValueByName)(lastInitialValuesRef.current, name);
+      if (existsInInitial === undefined) {
+        lastInitialValuesRef.current = (0, _utils.setValueByName)(lastInitialValuesRef.current, name, options.initialValue);
+      }
+      const existsInState = (0, _utils.getValueByName)(valuesRef.current, name);
+      if (existsInState === undefined) {
+        setValues(prev => {
+          if ((0, _utils.getValueByName)(prev, name) !== undefined) return prev;
+          const next = (0, _utils.setValueByName)(prev, name, options.initialValue);
+          valuesRef.current = next;
+          return next;
+        });
+      }
+    }
+    return () => {
+      const current = fieldsRef.current[key];
+      delete fieldsRef.current[key];
+      if (current?.dependencies?.length) {
+        for (const dep of current.dependencies) {
+          const depKey = (0, _utils.serializeNamePath)(dep);
+          const set = dependencyGraphRef.current.get(depKey);
+          if (!set) continue;
+          set.delete(key);
+          if (!set.size) dependencyGraphRef.current.delete(depKey);
+        }
+      }
+      setFieldErrors(name, []);
+    };
+  }, [setFieldErrors]);
+  const notify = (0, _react().useCallback)((changedValues, nextValues) => {
+    subscribersRef.current.forEach(listener => listener(changedValues, nextValues));
+  }, []);
+  const runFieldValidation = (0, _react().useCallback)(async (name, trigger, valueOverride, valuesOverride) => {
+    const key = (0, _utils.serializeNamePath)(name);
+    const validationSeq = (validationSeqRef.current[key] ?? 0) + 1;
+    validationSeqRef.current[key] = validationSeq;
+    const fieldOptions = fieldsRef.current[key];
+    const fieldRules = fieldOptions?.rules ?? [];
+    if (!fieldRules.length) {
+      setFieldErrors(name, []);
+      return true;
+    }
+    let activeRules = trigger ? fieldRules.filter(rule => {
+      const ruleTrigger = rule.validateTrigger ?? fieldOptions.validateTrigger;
+      return !ruleTrigger || (0, _utils.normalizeTrigger)(ruleTrigger).includes(trigger);
+    }) : fieldRules;
+    if (!activeRules.length) {
+      if (!errorsRef.current[key]?.length) return true;
+      activeRules = fieldRules;
+    }
+    const currentValues = valuesOverride ?? valuesRef.current;
+    const value = valueOverride ?? (0, _utils.getValueByName)(currentValues, name);
+    for (const rule of activeRules) {
+      const result = runRuleValidation(rule, value, currentValues);
+      const error = (0, _promise.isPromiseLike)(result) ? await result : result;
+      if (validationSeqRef.current[key] !== validationSeq) {
+        return true;
+      }
+      if (error) {
+        setFieldErrors(name, [error]);
+        return false;
+      }
+    }
+    if (validationSeqRef.current[key] !== validationSeq) {
+      return true;
+    }
+    setFieldErrors(name, []);
+    return true;
+  }, [setFieldErrors]);
+  const validateFields = (0, _react().useCallback)(async names => {
+    const fieldNames = names ?? Object.values(fieldsRef.current).map(item => item.name);
+    const results = await Promise.all(fieldNames.map(name => runFieldValidation(name)));
+    const hasError = results.some(result => !result);
+    if (hasError) {
+      throw errorsRef.current;
+    }
+    return valuesRef.current;
+  }, [runFieldValidation]);
+  const setFieldValue = (0, _react().useCallback)((name, value, trigger) => {
+    const nameKey = (0, _utils.serializeNamePath)(name);
+    setValues(prev => {
+      const prevValue = (0, _utils.getValueByName)(prev, name);
+      if (prevValue === value) return prev;
+      const next = (0, _utils.setValueByName)(prev, name, value);
+      valuesRef.current = next;
+      onValuesChange?.(next, nameKey, value);
+      runFieldValidation(name, trigger, value, next);
+      const dependents = dependencyGraphRef.current.get(nameKey);
+      if (dependents?.size) {
+        for (const dependentKey of dependents) {
+          const meta = fieldsRef.current[dependentKey];
+          if (!meta) continue;
+          runFieldValidation(meta.name, trigger, (0, _utils.getValueByName)(next, meta.name), next);
+        }
+      }
+      notify({
+        [nameKey]: value
+      }, next);
+      return next;
+    });
+  }, [notify, onValuesChange, runFieldValidation]);
+  const formApi = (0, _react().useMemo)(() => ({
+    submit: async () => {
+      try {
+        const result = await validateFields();
+        onFinish?.(result);
+        return result;
+      } catch (error) {
+        return undefined;
+      }
+    },
+    getFieldsValue: () => valuesRef.current,
+    setFieldsValue: next => {
+      setValues(prev => {
+        let merged = prev;
+        const changed = {};
+        Object.keys(next).forEach(key => {
+          const newVal = next[key];
+          if ((0, _utils.getValueByName)(merged, key) === newVal) return;
+          changed[key] = newVal;
+          merged = (0, _utils.setValueByName)(merged, key, newVal);
+          onValuesChange?.(merged, key, newVal);
+          runFieldValidation(key, undefined, newVal, merged);
+          const dependents = dependencyGraphRef.current.get(key);
+          if (dependents?.size) {
+            for (const dependentKey of dependents) {
+              const meta = fieldsRef.current[dependentKey];
+              if (!meta) continue;
+              runFieldValidation(meta.name, undefined, (0, _utils.getValueByName)(merged, meta.name), merged);
+            }
+          }
+        });
+        if (merged === prev) return prev;
+        valuesRef.current = merged;
+        notify(changed, merged);
+        return merged;
+      });
+    },
+    resetFields: () => {
+      let next = lastInitialValuesRef.current;
+      Object.values(fieldsRef.current).forEach(meta => {
+        if (meta.initialValue === undefined) return;
+        if ((0, _utils.getValueByName)(next, meta.name) !== undefined) return;
+        next = (0, _utils.setValueByName)(next, meta.name, meta.initialValue);
+      });
+      valuesRef.current = next;
+      errorsRef.current = {};
+      setValues(next);
+      setErrors({});
+      notify(next, next);
+    },
+    validateFields,
+    getFieldError: name => errorsRef.current[(0, _utils.serializeNamePath)(name)] ?? []
+  }), [notify, onFinish, onValuesChange, validateFields, runFieldValidation]);
+  (0, _react().useImperativeHandle)(ref, () => formApi, [formApi]);
+  const getFieldError = (0, _react().useCallback)(name => errors[(0, _utils.serializeNamePath)(name)], [errors]);
+  const getFieldValue = (0, _react().useCallback)(name => (0, _utils.getValueByName)(values, name), [values]);
+  const contextValidateField = (0, _react().useCallback)((name, trigger) => runFieldValidation(name, trigger), [runFieldValidation]);
+  const contextValue = (0, _react().useMemo)(() => ({
+    values,
+    getFieldValue,
+    setFieldValue,
+    registerField,
+    getFieldError,
+    validateField: contextValidateField,
+    getFieldsValue: () => values,
+    subscribe: listener => {
+      subscribersRef.current.add(listener);
+      return () => subscribersRef.current.delete(listener);
+    },
+    form: formApi,
+    colon,
+    labelWidth,
+    showValidateMessage
+  }), [values, setFieldValue, registerField, getFieldError, contextValidateField, formApi, colon, labelWidth, showValidateMessage]);
+  return /*#__PURE__*/_react().default.createElement(_FormContext.FormContext.Provider, {
+    value: contextValue
+  }, /*#__PURE__*/_react().default.createElement(_reactNative().View, _extends({
+    style: style
+  }, rest), children, footer));
+});
+InternalForm.displayName = 'Form';
+const useWatch = (name, formRef) => {
+  const context = (0, _react().useContext)(_FormContext.FormContext);
+  const names = (0, _react().useMemo)(() => {
+    if (name === undefined) return undefined;
+    if (!Array.isArray(name)) return [name];
+    return name.length && (0, _validate.isText)(name[0]) ? [name] : name;
+  }, [name]);
+  const getSnapshot = (0, _react().useCallback)(allValues => {
+    const source = allValues ?? context?.getFieldsValue?.() ?? formRef?.current?.getFieldsValue?.() ?? {};
+    if (!names) return source;
+    if (names.length === 1) return (0, _utils.getValueByName)(source, names[0]);
+    const picked = {};
+    for (const key of names) picked[(0, _utils.serializeNamePath)(key)] = (0, _utils.getValueByName)(source, key);
+    return picked;
+  }, [context, formRef, names]);
+  const [value, setValue] = (0, _react().useState)(() => getSnapshot());
+  (0, _react().useEffect)(() => {
+    if (!context?.subscribe) return undefined;
+    return context.subscribe((changed, all) => {
+      if (!names || names.some(key => (0, _utils.serializeNamePath)(key) in changed)) {
+        setValue(getSnapshot(all));
+      }
+    });
+  }, [context, getSnapshot, names]);
+  return value;
+};
+exports.useWatch = useWatch;
+const FormSubscribe = ({
+  to,
+  children
+}) => {
+  const context = (0, _react().useContext)(_FormContext.FormContext);
+  const [changed, setChanged] = (0, _react().useState)({});
+  (0, _react().useEffect)(() => {
+    if (!context?.subscribe) return undefined;
+    return context.subscribe(next => {
+      if (to && !Object.keys(next).some(key => to.includes(key))) return;
+      setChanged(next);
+    });
+  }, [context, to]);
+  return /*#__PURE__*/_react().default.createElement(_react().default.Fragment, null, children(changed, context?.form || null));
+};
+exports.FormSubscribe = FormSubscribe;
+var _default = exports.default = InternalForm;

package/dist/cjs/form/FormItem.js

@@ -0,0 +1,147 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.FormItem = void 0;
+function _react() {
+  const data = _interopRequireWildcard(require("react"));
+  _react = function () {
+    return data;
+  };
+  return data;
+}
+var _utils = require("../../utils");
+var _FormContext = require("./FormContext");
+var _utils2 = require("./utils");
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+const EMPTY_RULES = [];
+const FormItem = ({
+  name,
+  label,
+  description,
+  intro,
+  tooltip,
+  rules,
+  dependencies,
+  valuePropName = 'value',
+  trigger = 'onChangeText',
+  validateTrigger,
+  showValidateMessage,
+  required,
+  shouldUpdate,
+  initialValue,
+  children
+}) => {
+  const renderProps = typeof children === 'function';
+  const context = (0, _react().useContext)(_FormContext.FormContext);
+  if (!context) {
+    if (renderProps) {
+      return /*#__PURE__*/_react().default.createElement(_react().default.Fragment, null, children({
+        getFieldValue: () => undefined,
+        getFieldsValue: () => ({}),
+        form: null
+      }));
+    }
+    return /*#__PURE__*/_react().default.createElement(_react().default.Fragment, null, children);
+  }
+  const normalizedRules = rules ?? EMPTY_RULES;
+  const prevValuesRef = (0, _react().useRef)(context.values);
+  (0, _react().useEffect)(() => {
+    prevValuesRef.current = context.values;
+  }, [context.values]);
+  const shouldRender = !shouldUpdate || shouldUpdate(prevValuesRef.current, context.values);
+  (0, _react().useEffect)(() => {
+    if (!name) return undefined;
+    return context.registerField(name, {
+      rules: normalizedRules,
+      dependencies,
+      initialValue,
+      validateTrigger: validateTrigger ?? trigger
+    });
+  }, [context.registerField, name, normalizedRules, dependencies, initialValue, validateTrigger, trigger]);
+  const mergedValue = name ? context.getFieldValue(name) : undefined;
+  const mergedShowMessage = showValidateMessage ?? context.showValidateMessage ?? true;
+  const fieldErrors = name ? context.getFieldError(name) : undefined;
+  const firstError = mergedShowMessage ? fieldErrors?.[0] : undefined;
+  const mergedRequired = required ?? normalizedRules.some(rule => rule.required);
+  const mergedValidateTriggers = (0, _utils2.normalizeTrigger)(validateTrigger ?? trigger);
+  if (renderProps) {
+    if (!shouldRender) return null;
+    const node = children({
+      getFieldValue: context.getFieldValue,
+      getFieldsValue: context.getFieldsValue,
+      form: context.form || null
+    });
+    return /*#__PURE__*/_react().default.createElement(_react().default.Fragment, null, node);
+  }
+  if (!name) {
+    return /*#__PURE__*/_react().default.createElement(_react().default.Fragment, null, children);
+  }
+  if (!shouldRender) return null;
+  const childArray = _react().default.Children.toArray(children);
+  if (childArray.length !== 1) {
+    return /*#__PURE__*/_react().default.createElement(_react().default.Fragment, null, children);
+  }
+  const child = childArray[0];
+  const handleChange = next => {
+    context.setFieldValue(name, next, trigger);
+    const original = child.props[trigger];
+    if ((0, _utils.isFunction)(original)) {
+      original(next);
+    }
+  };
+  const isFieldLike = (() => {
+    const displayName = child.type.displayName;
+    return (0, _utils.isString)(displayName) && (displayName.includes('Field') || displayName.includes('Input'));
+  })();
+  const resolveValue = () => {
+    const childValue = child.props[valuePropName];
+    if (childValue !== undefined) return childValue;
+    if (mergedValue !== undefined) return mergedValue;
+    if (isFieldLike && valuePropName === 'value') return '';
+    return mergedValue;
+  };
+  const injectedProps = {
+    [valuePropName]: resolveValue(),
+    [trigger]: handleChange
+  };
+  mergedValidateTriggers.forEach(eventName => {
+    if (!eventName || eventName === trigger) return;
+    const original = child.props[eventName];
+    injectedProps[eventName] = (...args) => {
+      if ((0, _utils.isFunction)(original)) {
+        original(...args);
+      }
+      context.validateField(name, eventName);
+    };
+  });
+  if (label !== undefined && child.props.label === undefined) {
+    injectedProps.label = label;
+  }
+  if (context.colon !== undefined && injectedProps.label !== undefined && child.props.colon === undefined) {
+    injectedProps.colon = context.colon;
+  }
+  if (context.labelWidth !== undefined && child.props.labelWidth === undefined) {
+    injectedProps.labelWidth = context.labelWidth;
+  }
+  if (description && child.props.description === undefined) {
+    injectedProps.description = description;
+  }
+  if (intro && child.props.intro === undefined) {
+    injectedProps.intro = intro;
+  }
+  if (tooltip && child.props.tooltip === undefined) {
+    injectedProps.tooltip = tooltip;
+  }
+  if (mergedRequired && child.props.required === undefined) {
+    injectedProps.required = true;
+  }
+  if (firstError && child.props.errorMessage === undefined) {
+    injectedProps.error = true;
+    injectedProps.errorMessage = firstError;
+  }
+  return /*#__PURE__*/_react().default.cloneElement(child, injectedProps);
+};
+exports.FormItem = FormItem;
+FormItem.displayName = 'FormItem';

package/dist/cjs/form/FormList.js

@@ -0,0 +1,70 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.FormList = void 0;
+function _react() {
+  const data = _interopRequireWildcard(require("react"));
+  _react = function () {
+    return data;
+  };
+  return data;
+}
+var _FormContext = require("./FormContext");
+var _utils = require("./utils");
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+const FormList = ({
+  name,
+  initialValue,
+  children
+}) => {
+  const context = (0, _react().useContext)(_FormContext.FormContext);
+  const keyRef = (0, _react().useRef)(0);
+  const ensureInitial = (0, _react().useCallback)(() => {
+    if (!context) return;
+    const current = (0, _utils.getValueByName)(context.values, name);
+    if (current === undefined && initialValue !== undefined) {
+      context.setFieldValue(name, initialValue);
+    }
+  }, [context, initialValue, name]);
+  (0, _react().useEffect)(() => {
+    ensureInitial();
+  }, [ensureInitial]);
+  if (!context) {
+    return null;
+  }
+  const listValueRaw = (0, _utils.getValueByName)(context.values, name);
+  const listValue = Array.isArray(listValueRaw) ? listValueRaw : [];
+  const fields = listValue.map((_, index) => ({
+    name: index,
+    key: keyRef.current + index,
+    isListField: true
+  }));
+  const add = (defaultValue, index) => {
+    const insertIndex = typeof index === 'number' ? index : listValue.length;
+    const next = [...listValue];
+    next.splice(insertIndex, 0, defaultValue);
+    context.setFieldValue(name, next);
+    keyRef.current += 1;
+  };
+  const remove = index => {
+    if (index < 0 || index >= listValue.length) return;
+    const next = listValue.slice(0, index).concat(listValue.slice(index + 1));
+    context.setFieldValue(name, next);
+  };
+  const move = (from, to) => {
+    if (from === to || from < 0 || to < 0 || from >= listValue.length || to >= listValue.length) return;
+    const next = [...listValue];
+    const item = next.splice(from, 1)[0];
+    next.splice(to, 0, item);
+    context.setFieldValue(name, next);
+  };
+  return /*#__PURE__*/_react().default.createElement(_react().default.Fragment, null, children(fields, {
+    add,
+    remove,
+    move
+  }));
+};
+exports.FormList = FormList;
+FormList.displayName = 'Form.List';