@ichaingo/header 1.4.96 → 1.4.97

package/dist/node_modules/.pnpm/@rc-component_color-picker@3.0.3_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/@rc-component/color-picker/es/hooks/useColorState.js

@@ -0,0 +1,13 @@
+import { useMemo as m } from "react";
+import "../../../../../../@rc-component_util@1.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/@rc-component/util/es/hooks/useLayoutEffect.js";
+import l from "../../../../../../@rc-component_util@1.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/@rc-component/util/es/hooks/useControlledState.js";
+import "../../../../../../@rc-component_util@1.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/@rc-component/util/es/ref.js";
+import "../../../../../../@rc-component_util@1.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/@rc-component/util/es/warning.js";
+import { generateColor as s } from "../util.js";
+const d = (r, t) => {
+  const [o, e] = l(r, t);
+  return [m(() => s(o), [o]), e];
+};
+export {
+  d as default
+};

package/dist/node_modules/.pnpm/@rc-component_color-picker@3.0.3_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/@rc-component/color-picker/es/hooks/useComponent.js

@@ -0,0 +1,13 @@
+import * as t from "react";
+import o from "../components/Slider.js";
+function i(r) {
+  return t.useMemo(() => {
+    const {
+      slider: e
+    } = r || {};
+    return [e || o];
+  }, [r]);
+}
+export {
+  i as default
+};

package/dist/node_modules/.pnpm/@rc-component_color-picker@3.0.3_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/@rc-component/color-picker/es/util.js

@@ -0,0 +1,62 @@
+import { Color as l } from "./color.js";
+const y = "rc-color-picker", s = (t) => t instanceof l ? t : new l(t), O = s("#1677ff"), R = (t) => {
+  const {
+    offset: e,
+    targetRef: n,
+    containerRef: g,
+    color: C,
+    type: o
+  } = t, {
+    width: a,
+    height: b
+  } = g.current.getBoundingClientRect(), {
+    width: d,
+    height: p
+  } = n.current.getBoundingClientRect(), f = d / 2, x = p / 2, c = (e.x + f) / a, h = 1 - (e.y + x) / b, r = C.toHsb(), i = c, u = (e.x + f) / a * 360;
+  if (o)
+    switch (o) {
+      case "hue":
+        return s({
+          ...r,
+          h: u <= 0 ? 0 : u
+        });
+      case "alpha":
+        return s({
+          ...r,
+          a: i <= 0 ? 0 : i
+        });
+    }
+  return s({
+    h: r.h,
+    s: c <= 0 ? 0 : c,
+    b: h >= 1 ? 1 : h,
+    a: r.a
+  });
+}, H = (t, e) => {
+  const n = t.toHsb();
+  switch (e) {
+    case "hue":
+      return {
+        x: n.h / 360 * 100,
+        y: 50
+      };
+    case "alpha":
+      return {
+        x: t.a * 100,
+        y: 50
+      };
+    // Picker panel
+    default:
+      return {
+        x: n.s * 100,
+        y: (1 - n.b) * 100
+      };
+  }
+};
+export {
+  y as ColorPickerPrefixCls,
+  H as calcOffset,
+  R as calculateColor,
+  O as defaultColor,
+  s as generateColor
+};

package/dist/node_modules/.pnpm/@rc-component_dropdown@1.0.2_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/@rc-component/dropdown/es/Dropdown.js

@@ -0,0 +1,105 @@
+import I from "../../../../../@rc-component_trigger@3.7.1_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/@rc-component/trigger/es/index.js";
+import { composeRef as q, supportRef as z, getNodeRef as B } from "../../../../../@rc-component_util@1.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/@rc-component/util/es/ref.js";
+import { clsx as R } from "../../../../../clsx@2.1.1/node_modules/clsx/dist/clsx.js";
+import r from "react";
+import G from "./hooks/useAccessibility.js";
+import J from "./Overlay.js";
+import K from "./placements.js";
+function m() {
+  return m = Object.assign ? Object.assign.bind() : function(e) {
+    for (var i = 1; i < arguments.length; i++) {
+      var o = arguments[i];
+      for (var t in o)
+        Object.prototype.hasOwnProperty.call(o, t) && (e[t] = o[t]);
+    }
+    return e;
+  }, m.apply(this, arguments);
+}
+const ne = /* @__PURE__ */ r.forwardRef((e, i) => {
+  var O;
+  const {
+    arrow: o = !1,
+    prefixCls: t = "rc-dropdown",
+    transitionName: N,
+    animation: f,
+    align: w,
+    placement: M = "bottomLeft",
+    placements: x = K,
+    getPopupContainer: P,
+    showAction: A,
+    hideAction: E,
+    overlayClassName: T,
+    overlayStyle: $,
+    visible: V,
+    trigger: u = ["hover"],
+    autoFocus: W,
+    overlay: g,
+    children: a,
+    onVisibleChange: s,
+    ...j
+  } = e, [S, d] = r.useState(), c = "visible" in e ? V : S, _ = f ? `${t}-${f}` : N, h = r.useRef(null), v = r.useRef(null), b = r.useRef(null);
+  r.useImperativeHandle(i, () => h.current);
+  const y = (n) => {
+    d(n), s == null || s(n);
+  };
+  G({
+    visible: c,
+    triggerRef: b,
+    onVisibleChange: y,
+    autoFocus: W,
+    overlayRef: v
+  });
+  const k = (n) => {
+    const {
+      onOverlayClick: l
+    } = e;
+    d(!1), l && l(n);
+  }, C = () => /* @__PURE__ */ r.createElement(J, {
+    ref: v,
+    overlay: g,
+    prefixCls: t,
+    arrow: o
+  }), H = () => typeof g == "function" ? C : C(), L = () => {
+    const {
+      minOverlayWidthMatchTrigger: n,
+      alignPoint: l
+    } = e;
+    return "minOverlayWidthMatchTrigger" in e ? n : !l;
+  }, D = () => {
+    const {
+      openClassName: n
+    } = e;
+    return n !== void 0 ? n : `${t}-open`;
+  }, F = /* @__PURE__ */ r.cloneElement(a, {
+    className: R((O = a.props) == null ? void 0 : O.className, c && D()),
+    ref: z(a) ? q(b, B(a)) : void 0
+  });
+  let p = E;
+  return !p && u.indexOf("contextMenu") !== -1 && (p = ["click"]), /* @__PURE__ */ r.createElement(I, m({
+    builtinPlacements: x
+  }, j, {
+    prefixCls: t,
+    ref: h,
+    popupClassName: R(T, {
+      [`${t}-show-arrow`]: o
+    }),
+    popupStyle: $,
+    action: u,
+    showAction: A,
+    hideAction: p,
+    popupPlacement: M,
+    popupAlign: w,
+    popupMotion: {
+      motionName: _
+    },
+    popupVisible: c,
+    stretch: L() ? "minWidth" : "",
+    popup: H(),
+    onOpenChange: y,
+    onPopupClick: k,
+    getPopupContainer: P
+  }), F);
+});
+export {
+  ne as default
+};

package/dist/node_modules/.pnpm/@rc-component_dropdown@1.0.2_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/@rc-component/dropdown/es/Overlay.js

@@ -0,0 +1,20 @@
+import { composeRef as s, getNodeRef as c, supportRef as d } from "../../../../../@rc-component_util@1.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/@rc-component/util/es/ref.js";
+import o, { forwardRef as p, useMemo as u } from "react";
+const v = /* @__PURE__ */ p((l, n) => {
+  const {
+    overlay: e,
+    arrow: a,
+    prefixCls: f
+  } = l, r = u(() => {
+    let t;
+    return typeof e == "function" ? t = e() : t = e, t;
+  }, [e]), m = s(n, c(r));
+  return /* @__PURE__ */ o.createElement(o.Fragment, null, a && /* @__PURE__ */ o.createElement("div", {
+    className: `${f}-arrow`
+  }), /* @__PURE__ */ o.cloneElement(r, {
+    ref: d(r) ? m : void 0
+  }));
+});
+export {
+  v as default
+};

package/dist/node_modules/.pnpm/@rc-component_dropdown@1.0.2_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/@rc-component/dropdown/es/hooks/useAccessibility.js

@@ -0,0 +1,41 @@
+import l from "../../../../../../@rc-component_util@1.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/@rc-component/util/es/KeyCode.js";
+import m from "../../../../../../@rc-component_util@1.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/@rc-component/util/es/raf.js";
+import * as a from "react";
+const {
+  ESC: p,
+  TAB: i
+} = l;
+function R({
+  visible: u,
+  triggerRef: d,
+  onVisibleChange: f,
+  autoFocus: w,
+  overlayRef: c
+}) {
+  const t = a.useRef(!1), s = () => {
+    var e, r;
+    u && ((r = (e = d.current) == null ? void 0 : e.focus) == null || r.call(e), f == null || f(!1));
+  }, n = () => {
+    var e;
+    return (e = c.current) != null && e.focus ? (c.current.focus(), t.current = !0, !0) : !1;
+  }, o = (e) => {
+    switch (e.keyCode) {
+      case p:
+        s();
+        break;
+      case i: {
+        let r = !1;
+        t.current || (r = n()), r ? e.preventDefault() : s();
+        break;
+      }
+    }
+  };
+  a.useEffect(() => u ? (window.addEventListener("keydown", o), w && m(n, 3), () => {
+    window.removeEventListener("keydown", o), t.current = !1;
+  }) : () => {
+    t.current = !1;
+  }, [u]);
+}
+export {
+  R as default
+};

package/dist/node_modules/.pnpm/@rc-component_dropdown@1.0.2_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/@rc-component/dropdown/es/index.js

@@ -0,0 +1,4 @@
+import r from "./Dropdown.js";
+export {
+  r as default
+};

package/dist/node_modules/.pnpm/@rc-component_dropdown@1.0.2_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/@rc-component/dropdown/es/placements.js

@@ -0,0 +1,44 @@
+const t = {
+  adjustX: 1,
+  adjustY: 1
+}, o = [0, 0], f = {
+  topLeft: {
+    points: ["bl", "tl"],
+    overflow: t,
+    offset: [0, -4],
+    targetOffset: o
+  },
+  top: {
+    points: ["bc", "tc"],
+    overflow: t,
+    offset: [0, -4],
+    targetOffset: o
+  },
+  topRight: {
+    points: ["br", "tr"],
+    overflow: t,
+    offset: [0, -4],
+    targetOffset: o
+  },
+  bottomLeft: {
+    points: ["tl", "bl"],
+    overflow: t,
+    offset: [0, 4],
+    targetOffset: o
+  },
+  bottom: {
+    points: ["tc", "bc"],
+    overflow: t,
+    offset: [0, 4],
+    targetOffset: o
+  },
+  bottomRight: {
+    points: ["tr", "br"],
+    overflow: t,
+    offset: [0, 4],
+    targetOffset: o
+  }
+};
+export {
+  f as default
+};

package/dist/node_modules/.pnpm/@rc-component_form@1.5.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/@rc-component/form/es/BatchUpdate.js

@@ -0,0 +1,21 @@
+import * as s from "react";
+const n = /* @__PURE__ */ s.forwardRef((f, r) => {
+  const [e, o] = s.useState({});
+  return s.useLayoutEffect(() => {
+    const t = Object.keys(e);
+    t.length && (t.forEach((c) => {
+      var a;
+      (a = e[c]) == null || a.call(e);
+    }), o({}));
+  }, [e]), s.useImperativeHandle(r, () => ({
+    batch: (t, c) => {
+      o((a) => ({
+        ...a,
+        [t]: c
+      }));
+    }
+  })), null;
+});
+export {
+  n as default
+};

package/dist/node_modules/.pnpm/@rc-component_form@1.5.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/@rc-component/form/es/Field.js

@@ -0,0 +1,366 @@
+var H = Object.defineProperty;
+var W = (o, a, e) => a in o ? H(o, a, { enumerable: !0, configurable: !0, writable: !0, value: e }) : o[a] = e;
+var s = (o, a, e) => W(o, typeof a != "symbol" ? a + "" : a, e);
+import A from "../../../../../@rc-component_util@1.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/@rc-component/util/es/Children/toArray.js";
+import _ from "../../../../../@rc-component_util@1.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/@rc-component/util/es/isEqual.js";
+import { warningOnce as L } from "../../../../../@rc-component_util@1.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/@rc-component/util/es/warning.js";
+import * as v from "react";
+import U, { HOOK_MARK as M } from "./FieldContext.js";
+import G from "./ListContext.js";
+import { toArray as I } from "./utils/typeUtil.js";
+import { validateRules as $ } from "./utils/validateUtil.js";
+import { getNamePath as T, containsNamePath as N, defaultGetValueFromEvent as q } from "./utils/valueUtil.js";
+import K from "../../../../../@rc-component_util@1.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/@rc-component/util/es/utils/get.js";
+function b() {
+  return b = Object.assign ? Object.assign.bind() : function(o) {
+    for (var a = 1; a < arguments.length; a++) {
+      var e = arguments[a];
+      for (var i in e)
+        Object.prototype.hasOwnProperty.call(e, i) && (o[i] = e[i]);
+    }
+    return o;
+  }, b.apply(this, arguments);
+}
+const C = [], R = [];
+function O(o, a, e, i, t, r) {
+  return typeof o == "function" ? o(a, e, "source" in r ? {
+    source: r.source
+  } : {}) : i !== t;
+}
+class j extends v.Component {
+  // ============================== Subscriptions ==============================
+  constructor(e) {
+    super(e);
+    s(this, "state", {
+      resetCount: 0
+    });
+    s(this, "cancelRegisterFunc", null);
+    s(this, "mounted", !1);
+    /**
+     * Follow state should not management in State since it will async update by React.
+     * This makes first render of form can not get correct state value.
+     */
+    s(this, "touched", !1);
+    /**
+     * 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.
+     */
+    s(this, "dirty", !1);
+    s(this, "validatePromise");
+    s(this, "prevValidating");
+    s(this, "errors", C);
+    s(this, "warnings", R);
+    s(this, "cancelRegister", () => {
+      const {
+        preserve: e,
+        isListField: i,
+        name: t
+      } = this.props;
+      this.cancelRegisterFunc && this.cancelRegisterFunc(i, e, T(t)), this.cancelRegisterFunc = null;
+    });
+    // ================================== Utils ==================================
+    s(this, "getNamePath", () => {
+      const {
+        name: e,
+        fieldContext: i
+      } = this.props, {
+        prefixName: t = []
+      } = i;
+      return e !== void 0 ? [...t, ...e] : [];
+    });
+    s(this, "getRules", () => {
+      const {
+        rules: e = [],
+        fieldContext: i
+      } = this.props;
+      return e.map((t) => typeof t == "function" ? t(i) : t);
+    });
+    s(this, "refresh", () => {
+      this.mounted && this.setState(({
+        resetCount: e
+      }) => ({
+        resetCount: e + 1
+      }));
+    });
+    // Event should only trigger when meta changed
+    s(this, "metaCache", null);
+    s(this, "triggerMetaEvent", (e) => {
+      const {
+        onMetaChange: i
+      } = this.props;
+      if (i) {
+        const t = {
+          ...this.getMeta(),
+          destroy: e
+        };
+        _(this.metaCache, t) || i(t), this.metaCache = t;
+      } else
+        this.metaCache = null;
+    });
+    // ========================= Field Entity Interfaces =========================
+    // Trigger by store update. Check if need update the component
+    s(this, "onStoreChange", (e, i, t) => {
+      const {
+        shouldUpdate: r,
+        dependencies: l = [],
+        onReset: h
+      } = this.props, {
+        store: g
+      } = t, y = this.getNamePath(), u = this.getValue(e), c = this.getValue(g), f = i && N(i, y);
+      switch (t.type === "valueUpdate" && t.source === "external" && !_(u, c) && (this.touched = !0, this.dirty = !0, this.validatePromise = null, this.errors = C, this.warnings = R, this.triggerMetaEvent()), t.type) {
+        case "reset":
+          if (!i || f) {
+            this.touched = !1, this.dirty = !1, this.validatePromise = void 0, this.errors = C, this.warnings = R, this.triggerMetaEvent(), h == null || h(), this.refresh();
+            return;
+          }
+          break;
+        /**
+         * In case field with `preserve = false` nest deps like:
+         * - A = 1 => show B
+         * - B = 1 => show C
+         * - Reset A, need clean B, C
+         */
+        case "remove": {
+          if (r && O(r, e, g, u, c, t)) {
+            this.reRender();
+            return;
+          }
+          break;
+        }
+        case "setField": {
+          const {
+            data: n
+          } = t;
+          if (f) {
+            "touched" in n && (this.touched = n.touched), "validating" in n && !("originRCField" in n) && (this.validatePromise = n.validating ? Promise.resolve([]) : null), "errors" in n && (this.errors = n.errors || C), "warnings" in n && (this.warnings = n.warnings || R), this.dirty = !0, this.triggerMetaEvent(), this.reRender();
+            return;
+          } else if ("value" in n && N(i, y, !0)) {
+            this.reRender();
+            return;
+          }
+          if (r && !y.length && O(r, e, g, u, c, t)) {
+            this.reRender();
+            return;
+          }
+          break;
+        }
+        case "dependenciesUpdate": {
+          if (l.map(T).some((p) => N(t.relatedFields, p))) {
+            this.reRender();
+            return;
+          }
+          break;
+        }
+        default:
+          if (f || (!l.length || y.length || r) && O(r, e, g, u, c, t)) {
+            this.reRender();
+            return;
+          }
+          break;
+      }
+      r === !0 && this.reRender();
+    });
+    s(this, "validateRules", (e) => {
+      const i = this.getNamePath(), t = this.getValue(), {
+        triggerName: r,
+        validateOnly: l = !1
+      } = e || {}, h = Promise.resolve().then(async () => {
+        if (!this.mounted)
+          return [];
+        const {
+          validateFirst: g = !1,
+          messageVariables: y,
+          validateDebounce: u
+        } = this.props;
+        let c = this.getRules();
+        if (r && (c = c.filter((n) => n).filter((n) => {
+          const {
+            validateTrigger: p
+          } = n;
+          return p ? I(p).includes(r) : !0;
+        })), u && r && (await new Promise((n) => {
+          setTimeout(n, u);
+        }), this.validatePromise !== h))
+          return [];
+        const f = $(i, t, c, e, g, y);
+        return f.catch((n) => n).then((n = C) => {
+          var p;
+          if (this.validatePromise === h) {
+            this.validatePromise = null;
+            const F = [], P = [];
+            (p = n.forEach) == null || p.call(n, ({
+              rule: {
+                warningOnly: w
+              },
+              errors: V = C
+            }) => {
+              w ? P.push(...V) : F.push(...V);
+            }), this.errors = F, this.warnings = P, this.triggerMetaEvent(), this.reRender();
+          }
+        }), f;
+      });
+      return l || (this.validatePromise = h, this.dirty = !0, this.errors = C, this.warnings = R, this.triggerMetaEvent(), this.reRender()), h;
+    });
+    s(this, "isFieldValidating", () => !!this.validatePromise);
+    s(this, "isFieldTouched", () => this.touched);
+    s(this, "isFieldDirty", () => {
+      if (this.dirty || this.props.initialValue !== void 0)
+        return !0;
+      const {
+        fieldContext: e
+      } = this.props, {
+        getInitialValue: i
+      } = e.getInternalHooks(M);
+      return i(this.getNamePath()) !== void 0;
+    });
+    s(this, "getErrors", () => this.errors);
+    s(this, "getWarnings", () => this.warnings);
+    s(this, "isListField", () => this.props.isListField);
+    s(this, "isList", () => this.props.isList);
+    s(this, "isPreserve", () => this.props.preserve);
+    // ============================= Child Component =============================
+    s(this, "getMeta", () => (this.prevValidating = this.isFieldValidating(), {
+      touched: this.isFieldTouched(),
+      validating: this.prevValidating,
+      errors: this.errors,
+      warnings: this.warnings,
+      name: this.getNamePath(),
+      validated: this.validatePromise === null
+    }));
+    // Only return validate child node. If invalidate, will do nothing about field.
+    s(this, "getOnlyChild", (e) => {
+      if (typeof e == "function") {
+        const t = this.getMeta();
+        return {
+          ...this.getOnlyChild(e(this.getControlled(), t, this.props.fieldContext)),
+          isFunction: !0
+        };
+      }
+      const i = A(e);
+      return i.length !== 1 || !/* @__PURE__ */ v.isValidElement(i[0]) ? {
+        child: i,
+        isFunction: !1
+      } : {
+        child: i[0],
+        isFunction: !1
+      };
+    });
+    // ============================== Field Control ==============================
+    s(this, "getValue", (e) => {
+      const {
+        getFieldsValue: i
+      } = this.props.fieldContext, t = this.getNamePath();
+      return K(e || i(!0), t);
+    });
+    s(this, "getControlled", (e = {}) => {
+      const {
+        name: i,
+        trigger: t = "onChange",
+        validateTrigger: r,
+        getValueFromEvent: l,
+        normalize: h,
+        valuePropName: g = "value",
+        getValueProps: y,
+        fieldContext: u
+      } = this.props, c = r !== void 0 ? r : u.validateTrigger, f = this.getNamePath(), {
+        getInternalHooks: n,
+        getFieldsValue: p
+      } = u, {
+        dispatch: F
+      } = n(M), P = this.getValue(), w = y || ((d) => ({
+        [g]: d
+      })), V = e[t], E = i !== void 0 ? w(P) : {};
+      process.env.NODE_ENV !== "production" && E && Object.keys(E).forEach((d) => {
+        L(typeof E[d] != "function", `It's not recommended to generate dynamic function prop by \`getValueProps\`. Please pass it to child component directly (prop: ${d})`);
+      });
+      const x = {
+        ...e,
+        ...E
+      };
+      return x[t] = (...d) => {
+        this.touched = !0, this.dirty = !0, this.triggerMetaEvent();
+        let m;
+        l ? m = l(...d) : m = q(g, ...d), h && (m = h(m, P, p(!0))), m !== P && F({
+          type: "updateValue",
+          namePath: f,
+          value: m
+        }), V && V(...d);
+      }, I(c || []).forEach((d) => {
+        const m = x[d];
+        x[d] = (...D) => {
+          m && m(...D);
+          const {
+            rules: k
+          } = this.props;
+          k && k.length && F({
+            type: "validateField",
+            namePath: f,
+            triggerName: d
+          });
+        };
+      }), x;
+    });
+    if (e.fieldContext) {
+      const {
+        getInternalHooks: i
+      } = e.fieldContext, {
+        initEntityValue: t
+      } = i(M);
+      t(this);
+    }
+  }
+  componentDidMount() {
+    const {
+      shouldUpdate: e,
+      fieldContext: i
+    } = this.props;
+    if (this.mounted = !0, i) {
+      const {
+        getInternalHooks: t
+      } = i, {
+        registerField: r
+      } = t(M);
+      this.cancelRegisterFunc = r(this);
+    }
+    e === !0 && this.reRender();
+  }
+  componentWillUnmount() {
+    this.cancelRegister(), this.triggerMetaEvent(!0), this.mounted = !1;
+  }
+  reRender() {
+    this.mounted && this.forceUpdate();
+  }
+  render() {
+    const {
+      resetCount: e
+    } = this.state, {
+      children: i
+    } = this.props, {
+      child: t,
+      isFunction: r
+    } = this.getOnlyChild(i);
+    let l;
+    return r ? l = t : /* @__PURE__ */ v.isValidElement(t) ? l = /* @__PURE__ */ v.cloneElement(t, this.getControlled(t.props)) : (L(!t, "`children` of Field is not validate ReactElement."), l = t), /* @__PURE__ */ v.createElement(v.Fragment, {
+      key: e
+    }, l);
+  }
+}
+s(j, "contextType", U);
+function se({
+  name: o,
+  ...a
+}) {
+  const e = v.useContext(U), i = v.useContext(G), t = o !== void 0 ? T(o) : void 0, r = a.isListField ?? !!i;
+  let l = "keep";
+  return r || (l = `_${(t || []).join("_")}`), process.env.NODE_ENV !== "production" && a.preserve === !1 && r && t.length <= 1 && L(!1, "`preserve` should not apply on Form.List fields."), /* @__PURE__ */ v.createElement(j, b({
+    key: l,
+    name: t,
+    isListField: r
+  }, a, {
+    fieldContext: e
+  }));
+}
+export {
+  se as default
+};