@qsxy/element-plus-react 1.0.0-next.1

package/dist/Form/FormContext.js

@@ -0,0 +1,101 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/Form/FormContext.tsx
+var FormContext_exports = {};
+__export(FormContext_exports, {
+  FormProvider: () => FormProvider,
+  default: () => FormContext_default
+});
+module.exports = __toCommonJS(FormContext_exports);
+var import_noop = __toESM(require("lodash/noop"));
+var import_react = __toESM(require("react"));
+var FormContext = (0, import_react.createContext)({
+  triggerFormChange: import_noop.default,
+  triggerFormFinish: import_noop.default,
+  registerForm: import_noop.default,
+  unregisterForm: import_noop.default
+});
+var FormProvider = ({ validateMessages, onFormChange, onFormFinish, children }) => {
+  const formContext = (0, import_react.useContext)(FormContext);
+  const formsRef = (0, import_react.useRef)({});
+  return /* @__PURE__ */ import_react.default.createElement(
+    FormContext.Provider,
+    {
+      value: {
+        ...formContext,
+        validateMessages: {
+          ...formContext.validateMessages,
+          ...validateMessages
+        },
+        // =========================================================
+        // =                  Global Form Control                  =
+        // =========================================================
+        triggerFormChange: (name, changedFields) => {
+          if (onFormChange) {
+            onFormChange(name, {
+              changedFields,
+              forms: formsRef.current
+            });
+          }
+          formContext.triggerFormChange(name, changedFields);
+        },
+        triggerFormFinish: (name, values) => {
+          if (onFormFinish) {
+            onFormFinish(name, {
+              values,
+              forms: formsRef.current
+            });
+          }
+          formContext.triggerFormFinish(name, values);
+        },
+        registerForm: (name, form) => {
+          if (name) {
+            formsRef.current = {
+              ...formsRef.current,
+              [name]: form
+            };
+          }
+          formContext.registerForm(name, form);
+        },
+        unregisterForm: (name) => {
+          const newForms = { ...formsRef.current };
+          delete newForms[name];
+          formsRef.current = newForms;
+          formContext.unregisterForm(name);
+        }
+      }
+    },
+    children
+  );
+};
+var FormContext_default = FormContext;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FormProvider
+});

package/dist/Form/FormItem.d.ts

@@ -0,0 +1,47 @@
+import React from 'react';
+import { ComponentChildren } from '../types/common';
+import type { EventArgs, FormInstance, FormItemProps, InternalFormInstance, InternalNamePath, Meta, NamePath, Rule, Store, StoreValue } from './typings';
+export type ShouldUpdate<Values = any> = boolean | ((prevValues: Values, nextValues: Values, info: {
+    source?: string;
+}) => boolean);
+interface ChildProps {
+    [name: string]: any;
+}
+export interface InternalFieldProps<Values = any> extends Omit<FormItemProps<Values>, 'children'> {
+    children?: ComponentChildren | ((control: ChildProps, meta: Meta, form: FormInstance<Values>) => React.ReactElement);
+    dependencies?: NamePath[];
+    getValueFromEvent?: (...args: EventArgs) => StoreValue;
+    name?: InternalNamePath;
+    normalize?: (value: StoreValue, prevValue: StoreValue, allValues: Store) => StoreValue;
+    rules?: Rule[];
+    shouldUpdate?: ShouldUpdate<Values>;
+    trigger?: string;
+    validateTrigger?: string | string[] | false;
+    validateFirst?: boolean | 'parallel';
+    valuePropName?: string;
+    getValueProps?: (value: StoreValue) => Record<string, unknown>;
+    messageVariables?: Record<string, string>;
+    initialValue?: any;
+    onReset?: () => void;
+    onMetaChange?: (meta: Meta & {
+        destroy?: boolean;
+    }) => void;
+    preserve?: boolean;
+    isListField?: boolean;
+    isList?: boolean;
+    fieldContext?: InternalFormInstance;
+}
+export interface FieldProps<Values = any> extends Omit<InternalFieldProps<Values>, 'name' | 'fieldContext'> {
+    name?: NamePath;
+}
+export interface FieldState {
+    resetCount: number;
+}
+declare function InternalFormItem<Values = any>({ name, rules, ...restProps }: FieldProps<Values>): React.JSX.Element;
+type InternalFormItemType = typeof InternalFormItem;
+interface FormItemInterface extends InternalFormItemType {
+    displayName?: string;
+    defaultProps?: Partial<FieldProps<any>>;
+}
+declare const FormItem: FormItemInterface;
+export default FormItem;

package/dist/Form/FormItem.js

@@ -0,0 +1,461 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/Form/FormItem.tsx
+var FormItem_exports = {};
+__export(FormItem_exports, {
+  default: () => FormItem_default
+});
+module.exports = __toCommonJS(FormItem_exports);
+var import_classnames = __toESM(require("classnames"));
+var import_head = __toESM(require("lodash/head"));
+var import_react = __toESM(require("react"));
+var import_Icon = require("../Icon");
+var import_Tooltip = __toESM(require("../Tooltip/Tooltip"));
+var import_Transition = require("../Transition");
+var import_Util = require("../Util");
+var import_FieldContext = __toESM(require("./FieldContext"));
+var import_FormItemContext = require("./FormItemContext");
+var import_classUtil = require("./utils/classUtil");
+var import_typeUtil = require("./utils/typeUtil");
+var import_validateUtil = require("./utils/validateUtil");
+var import_valueUtil = require("./utils/valueUtil");
+var EMPTY_ERRORS = [];
+function requireUpdate(shouldUpdate, prev, next, prevValue, nextValue, info) {
+  if (typeof shouldUpdate === "function") {
+    return shouldUpdate(prev, next, "source" in info ? { source: info.source } : {});
+  }
+  return prevValue !== nextValue;
+}
+var Field = class extends import_react.default.Component {
+  // ============================== Subscriptions ==============================
+  constructor(props) {
+    super(props);
+    this.state = {
+      resetCount: 0
+    };
+    this.cancelRegisterFunc = null;
+    this.mounted = false;
+    /**
+     * Follow state should not management in State since it will async update by
+     * This makes first render of form can not get correct state value.
+     */
+    this.touched = false;
+    /**
+     * Mark when touched & validated. Currently only used for `dependencies`.
+     * Note that we do not think field with `initialValue` is dirty
+     * but this will be by `isFieldDirty` func.
+     */
+    this.dirty = false;
+    this.validatePromise = null;
+    this.errors = EMPTY_ERRORS;
+    this.warnings = EMPTY_ERRORS;
+    this.cancelRegister = () => {
+      const { preserve, isListField, name } = this.props;
+      if (this.cancelRegisterFunc) {
+        this.cancelRegisterFunc(isListField, preserve, (0, import_valueUtil.getNamePath)(name));
+      }
+      this.cancelRegisterFunc = null;
+    };
+    // ================================== Utils ==================================
+    this.getNamePath = () => {
+      const { name, fieldContext } = this.props;
+      const { prefixName = [] } = fieldContext;
+      return name !== void 0 ? [...prefixName, ...name] : [];
+    };
+    this.getRules = () => {
+      const { rules = [], fieldContext } = this.props;
+      return rules.map((rule) => {
+        if (typeof rule === "function") {
+          return rule(fieldContext);
+        }
+        return rule;
+      });
+    };
+    this.refresh = () => {
+      if (!this.mounted) {
+        return;
+      }
+      this.setState(({ resetCount }) => ({
+        resetCount: resetCount + 1
+      }));
+    };
+    this.triggerMetaEvent = (destroy) => {
+      const { onMetaChange } = this.props;
+      onMetaChange == null ? void 0 : onMetaChange({ ...this.getMeta(), destroy });
+    };
+    // ========================= Field Entity Interfaces =========================
+    // Trigger by store update. Check if need update the component
+    this.onStoreChange = (prevStore, namePathList, info) => {
+      const { shouldUpdate, dependencies = [], onReset } = this.props;
+      const { store } = info;
+      const namePath = this.getNamePath();
+      const prevValue = this.getValue(prevStore);
+      const curValue = this.getValue(store);
+      const namePathMatch = namePathList && (0, import_valueUtil.containsNamePath)(namePathList, namePath);
+      if (info.type === "valueUpdate" && info.source === "external" && prevValue !== curValue) {
+        this.touched = true;
+        this.dirty = true;
+        this.validatePromise = null;
+        this.errors = EMPTY_ERRORS;
+        this.warnings = EMPTY_ERRORS;
+        this.triggerMetaEvent();
+      }
+      switch (info.type) {
+        case "reset":
+          if (!namePathList || namePathMatch) {
+            this.touched = false;
+            this.dirty = false;
+            this.validatePromise = null;
+            this.errors = EMPTY_ERRORS;
+            this.warnings = EMPTY_ERRORS;
+            this.triggerMetaEvent();
+            onReset == null ? void 0 : onReset();
+            this.refresh();
+            return;
+          }
+          break;
+        case "remove": {
+          if (shouldUpdate) {
+            this.reRender();
+            return;
+          }
+          break;
+        }
+        case "setField": {
+          if (namePathMatch) {
+            const { data } = info;
+            if ("touched" in data) {
+              this.touched = data.touched;
+            }
+            if ("validating" in data && !("originRCField" in data)) {
+              this.validatePromise = data.validating ? Promise.resolve([]) : null;
+            }
+            if ("errors" in data) {
+              this.errors = data.errors || EMPTY_ERRORS;
+            }
+            if ("warnings" in data) {
+              this.warnings = data.warnings || EMPTY_ERRORS;
+            }
+            this.dirty = true;
+            this.triggerMetaEvent();
+            this.reRender();
+            return;
+          }
+          if (shouldUpdate && !namePath.length && requireUpdate(shouldUpdate, prevStore, store, prevValue, curValue, info)) {
+            this.reRender();
+            return;
+          }
+          break;
+        }
+        case "dependenciesUpdate": {
+          const dependencyList = dependencies.map(import_valueUtil.getNamePath);
+          if (dependencyList.some((dependency) => (0, import_valueUtil.containsNamePath)(info.relatedFields, dependency))) {
+            this.reRender();
+            return;
+          }
+          break;
+        }
+        default:
+          if (namePathMatch || (!dependencies.length || namePath.length || shouldUpdate) && requireUpdate(shouldUpdate, prevStore, store, prevValue, curValue, info)) {
+            this.reRender();
+            return;
+          }
+          break;
+      }
+      if (shouldUpdate === true) {
+        this.reRender();
+      }
+    };
+    this.validateRules = (options) => {
+      const namePath = this.getNamePath();
+      const currentValue = this.getValue();
+      const rootPromise = Promise.resolve().then(() => {
+        if (!this.mounted) {
+          return [];
+        }
+        const { validateFirst = false, messageVariables } = this.props;
+        const { triggerName } = options || {};
+        let filteredRules = this.getRules();
+        if (triggerName) {
+          filteredRules = filteredRules.filter((rule) => rule).filter((rule) => {
+            const { validateTrigger } = rule;
+            if (!validateTrigger) {
+              return true;
+            }
+            const triggerList = (0, import_typeUtil.toArray)(validateTrigger);
+            return triggerList.includes(triggerName);
+          });
+        }
+        const promise = (0, import_validateUtil.validateRules)(namePath, currentValue, filteredRules, options, validateFirst, messageVariables);
+        promise.catch((e2) => e2).then((ruleErrors = EMPTY_ERRORS) => {
+          var _a;
+          if (this.validatePromise === rootPromise) {
+            this.validatePromise = null;
+            const nextErrors = [];
+            const nextWarnings = [];
+            (_a = ruleErrors.forEach) == null ? void 0 : _a.call(ruleErrors, ({ rule: { warningOnly }, errors = EMPTY_ERRORS }) => {
+              if (warningOnly) {
+                nextWarnings.push(...errors);
+              } else {
+                nextErrors.push(...errors);
+              }
+            });
+            this.errors = nextErrors;
+            this.warnings = nextWarnings;
+            this.triggerMetaEvent();
+            this.reRender();
+          }
+        });
+        return promise;
+      });
+      this.validatePromise = rootPromise;
+      this.dirty = true;
+      this.errors = EMPTY_ERRORS;
+      this.warnings = EMPTY_ERRORS;
+      this.triggerMetaEvent();
+      this.reRender();
+      return rootPromise;
+    };
+    this.isFieldValidating = () => !!this.validatePromise;
+    this.isFieldTouched = () => this.touched;
+    this.isFieldDirty = () => {
+      if (this.dirty || this.props.initialValue !== void 0) {
+        return true;
+      }
+      const { fieldContext } = this.props;
+      const { getInitialValue } = fieldContext.getInternalHooks(import_FieldContext.HOOK_MARK);
+      if (getInitialValue(this.getNamePath()) !== void 0) {
+        return true;
+      }
+      return false;
+    };
+    this.getErrors = () => this.errors;
+    this.getWarnings = () => this.warnings;
+    this.isListField = () => this.props.isListField;
+    this.isList = () => this.props.isList;
+    this.isPreserve = () => this.props.preserve;
+    // ============================= Child Component =============================
+    this.getMeta = () => {
+      this.prevValidating = this.isFieldValidating();
+      const meta = {
+        touched: this.isFieldTouched(),
+        validating: this.prevValidating,
+        errors: this.errors,
+        warnings: this.warnings,
+        name: this.getNamePath()
+      };
+      return meta;
+    };
+    // Only return validate child node. If invalidate, will do nothing about field.
+    this.getOnlyChild = (children) => {
+      if (typeof children === "function") {
+        const meta = this.getMeta();
+        return {
+          ...this.getOnlyChild(children(this.getControlled(), meta, this.props.fieldContext)),
+          isFunction: true
+        };
+      }
+      const childList = import_react.Children.toArray(children);
+      if (childList.length !== 1 || !(0, import_react.isValidElement)(childList[0])) {
+        return { child: childList, isFunction: false };
+      }
+      return { child: childList[0], isFunction: false };
+    };
+    // ============================== Field Control ==============================
+    this.getValue = (store) => {
+      const { getFieldsValue } = this.props.fieldContext;
+      const namePath = this.getNamePath();
+      return (0, import_valueUtil.getValue)(store || getFieldsValue(true), namePath);
+    };
+    this.getControlled = (childProps = {}) => {
+      const { trigger, validateTrigger, getValueFromEvent, normalize, valuePropName, getValueProps, fieldContext } = this.props;
+      const mergedValidateTrigger = validateTrigger !== void 0 ? validateTrigger : fieldContext.validateTrigger;
+      const namePath = this.getNamePath();
+      const { getInternalHooks, getFieldsValue } = fieldContext;
+      const { dispatch } = getInternalHooks(import_FieldContext.HOOK_MARK);
+      const value = this.getValue();
+      const mergedGetValueProps = getValueProps || ((val) => ({ [valuePropName]: val }));
+      const originTriggerFunc = childProps[trigger];
+      const control = {
+        ...childProps,
+        ...mergedGetValueProps(value),
+        error: this.errors.length > 0,
+        warning: this.warnings.length > 0,
+        onClear: this.onClear
+      };
+      control[trigger] = (...args) => {
+        this.touched = true;
+        this.dirty = true;
+        this.triggerMetaEvent();
+        let newValue;
+        if (getValueFromEvent) {
+          newValue = getValueFromEvent(...args);
+        } else {
+          newValue = (0, import_valueUtil.defaultGetValueFromEvent)(valuePropName, ...args);
+        }
+        if (normalize) {
+          newValue = normalize(newValue, value, getFieldsValue(true));
+        }
+        dispatch({
+          type: "updateValue",
+          namePath,
+          value: newValue
+        });
+        if (originTriggerFunc) {
+          originTriggerFunc(...args);
+        }
+      };
+      const validateTriggerList = (0, import_typeUtil.toArray)(mergedValidateTrigger || []);
+      validateTriggerList.forEach((triggerName) => {
+        const originTrigger = control[triggerName];
+        control[triggerName] = (...args) => {
+          if (originTrigger) {
+            originTrigger(...args);
+          }
+          const { rules } = this.props;
+          if (rules && rules.length) {
+            dispatch({
+              type: "validateField",
+              namePath,
+              triggerName
+            });
+          }
+        };
+      });
+      return control;
+    };
+    this.onClear = () => {
+      var _a, _b, _c, _d;
+      this.touched = true;
+      const { getInternalHooks } = this.props.fieldContext;
+      const { dispatch } = getInternalHooks(import_FieldContext.HOOK_MARK);
+      dispatch({
+        type: "updateValue",
+        namePath: this.getNamePath(),
+        value: ""
+      });
+      (_d = (_c = (_b = (_a = this.props) == null ? void 0 : _a.children) == null ? void 0 : _b.props) == null ? void 0 : _c.onClear) == null ? void 0 : _d.call(_c);
+    };
+    this.getLabelWidth = () => {
+      const { pure, fieldContext, labelWidth } = this.props;
+      const { labelWidth: labelWidthContext, labelPosition } = fieldContext;
+      if (labelPosition === "top") {
+        return 0;
+      } else if ((0, import_Util.isNotEmpty)(labelWidth)) {
+        return labelWidth;
+      } else if (pure === true) {
+        return 0;
+      } else {
+        return labelWidthContext;
+      }
+    };
+    this.getValidateLable = () => {
+      const { errorStyle, warningStyle } = this.props;
+      return /* @__PURE__ */ import_react.default.createElement(import_react.default.Fragment, null, /* @__PURE__ */ import_react.default.createElement(import_Transition.Transition, { name: (0, import_classUtil.b)("slide-up"), visible: this.errors.length > 0, transitionAppear: true, unmountOnExit: true, display: "" }, /* @__PURE__ */ import_react.default.createElement("label", { className: import_classUtil.e`error`, style: errorStyle }, (0, import_head.default)(this.errors))), /* @__PURE__ */ import_react.default.createElement(import_Transition.Transition, { name: (0, import_classUtil.b)("slide-up"), visible: this.warnings.length > 0, transitionAppear: true, unmountOnExit: true, display: "" }, /* @__PURE__ */ import_react.default.createElement("label", { className: import_classUtil.e`warning`, style: warningStyle }, (0, import_head.default)(this.warnings))));
+    };
+    if (props.fieldContext) {
+      const { getInternalHooks } = props.fieldContext;
+      const { initEntityValue } = getInternalHooks(import_FieldContext.HOOK_MARK);
+      initEntityValue(this);
+    }
+  }
+  componentDidMount() {
+    const { shouldUpdate, fieldContext } = this.props;
+    this.mounted = true;
+    if (fieldContext) {
+      const { getInternalHooks } = fieldContext;
+      const { registerField } = getInternalHooks(import_FieldContext.HOOK_MARK);
+      this.cancelRegisterFunc = registerField(this);
+    }
+    if (shouldUpdate === true) {
+      this.reRender();
+    }
+  }
+  componentWillUnmount() {
+    this.cancelRegister();
+    this.triggerMetaEvent(true);
+    this.mounted = false;
+  }
+  reRender() {
+    if (!this.mounted) {
+      return;
+    }
+    this.forceUpdate();
+  }
+  render() {
+    const { resetCount } = this.state;
+    const { children, label, center, className, style, noStyle, fieldContext, labelStyle = {}, colon = false, size, help, pure } = this.props;
+    const { size: sizeContext, labelPosition, colon: colonContext } = fieldContext;
+    const labelWidth = this.getLabelWidth();
+    const { child, isFunction } = this.getOnlyChild(children);
+    const isRequired = this.props.required || this.getRules().some((item) => item.required);
+    let returnChildNode;
+    if (isFunction) {
+      returnChildNode = child;
+    } else if ((0, import_react.isValidElement)(child)) {
+      returnChildNode = (0, import_react.cloneElement)(child, this.getControlled(child.props));
+    } else {
+      returnChildNode = child;
+    }
+    return noStyle ? /* @__PURE__ */ import_react.default.createElement(import_FormItemContext.FormItemContext.Provider, { key: resetCount, value: { size } }, returnChildNode, this.getValidateLable()) : /* @__PURE__ */ import_react.default.createElement(import_FormItemContext.FormItemContext.Provider, { key: resetCount, value: { size } }, /* @__PURE__ */ import_react.default.createElement("div", { className: (0, import_classnames.default)((0, import_classUtil.b)("form-item"), { "is-required": isRequired, [(0, import_classUtil.m)(sizeContext ?? size)]: sizeContext ?? size }, className), style }, label && !pure && /* @__PURE__ */ import_react.default.createElement("label", { className: import_classUtil.e`label`, style: ["left", "right"].includes(labelPosition) ? { width: labelWidth, ...labelStyle } : labelStyle }, typeof label === "string" || typeof label === "number" ? `${label}${colonContext ?? colon ? "：" : ""}` : label, help && /* @__PURE__ */ import_react.default.createElement(import_Tooltip.default, { className: import_classUtil.e`label--help`, content: help, placement: "top", enterable: true }, /* @__PURE__ */ import_react.default.createElement(import_Icon.Icon, { name: "circle-exclamation", prefix: "fas" }))), /* @__PURE__ */ import_react.default.createElement(
+      "div",
+      {
+        className: (0, import_classnames.default)(import_classUtil.e`content`, { "is-center": center }),
+        style: !label ? { marginLeft: labelWidth } : {}
+      },
+      /* @__PURE__ */ import_react.default.createElement(import_react.default.Fragment, null, import_react.Children.map(
+        returnChildNode,
+        (item) => {
+          return item;
+        }
+      ), this.getValidateLable())
+    )));
+  }
+};
+Field.contextType = import_FieldContext.default;
+Field.defaultProps = {
+  trigger: "onChange",
+  valuePropName: "value"
+};
+function InternalFormItem({ name, rules = [], ...restProps }) {
+  var _a;
+  const fieldContext = (0, import_react.useContext)(import_FieldContext.default);
+  const namePath = name !== void 0 ? (0, import_valueUtil.getNamePath)(name) : void 0;
+  let key = "keep";
+  if (!restProps.isListField) {
+    key = `_${(namePath || []).join("_")}`;
+  }
+  if (process.env.NODE_ENV !== "production" && restProps.preserve === false && restProps.isListField && namePath.length <= 1) {
+    (0, import_Util.warning)(false, "`preserve` should not apply on Form.List fields.");
+  }
+  return /* @__PURE__ */ import_react.default.createElement(Field, { key, name: namePath, rules: [...((_a = fieldContext.rules) == null ? void 0 : _a[name]) ?? [], ...rules], ...restProps, fieldContext });
+}
+var FormItem = (0, import_react.memo)(InternalFormItem);
+FormItem.displayName = "ElFormItem";
+var FormItem_default = FormItem;

package/dist/Form/FormItemContext.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+import { TypeAttributes } from '../types/common';
+interface Props {
+    size?: TypeAttributes.Size;
+}
+export declare const FormItemContext: import("react").Context<Props>;
+export {};

package/dist/Form/FormItemContext.js

@@ -0,0 +1,32 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/Form/FormItemContext.ts
+var FormItemContext_exports = {};
+__export(FormItemContext_exports, {
+  FormItemContext: () => FormItemContext
+});
+module.exports = __toCommonJS(FormItemContext_exports);
+var import_react = require("react");
+var FormItemContext = (0, import_react.createContext)({
+  size: null
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FormItemContext
+});

package/dist/Form/List.d.ts

@@ -0,0 +1,21 @@
+import React, { FC } from 'react';
+import type { Meta, NamePath, StoreValue, ValidatorRule } from './typings';
+export interface ListField {
+    name: number;
+    key: number;
+    isListField: boolean;
+}
+export interface ListOperations {
+    add: (defaultValue?: StoreValue, index?: number) => void;
+    remove: (index: number | number[]) => void;
+    move: (from: number, to: number) => void;
+}
+export interface ListProps {
+    name: NamePath;
+    rules?: ValidatorRule[];
+    validateTrigger?: string | string[] | false;
+    initialValue?: any[];
+    children?: (fields: ListField[], operations: ListOperations, meta: Meta) => React.ReactElement;
+}
+declare const List: FC<ListProps>;
+export default List;