@ichaingo/header 1.4.96 → 1.4.97

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/useForm.js

@@ -0,0 +1,625 @@
+var C = Object.defineProperty;
+var D = (m, e, t) => e in m ? C(m, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : m[e] = t;
+var r = (m, e, t) => D(m, typeof e != "symbol" ? e + "" : e, t);
+import F, { merge as k, mergeWith as H } 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/set.js";
+import * 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 "../../../../../@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 w 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";
+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 { HOOK_MARK as R } from "./FieldContext.js";
+import { allPromiseFinish as _ } from "./utils/asyncUtil.js";
+import { defaultValidateMessages as j } from "./utils/messages.js";
+import b from "./utils/NameMap.js";
+import { getNamePath as g, cloneByNamePathList as A, containsNamePath as S, matchNamePath as O } from "./utils/valueUtil.js";
+class x {
+  constructor(e) {
+    r(this, "formHooked", !1);
+    r(this, "forceRootUpdate");
+    r(this, "subscribable", !0);
+    r(this, "store", {});
+    r(this, "fieldEntities", []);
+    r(this, "initialValues", {});
+    r(this, "callbacks", {});
+    r(this, "validateMessages", null);
+    r(this, "preserve", null);
+    r(this, "lastValidatePromise", null);
+    r(this, "getForm", () => ({
+      getFieldValue: this.getFieldValue,
+      getFieldsValue: this.getFieldsValue,
+      getFieldError: this.getFieldError,
+      getFieldWarning: this.getFieldWarning,
+      getFieldsError: this.getFieldsError,
+      isFieldsTouched: this.isFieldsTouched,
+      isFieldTouched: this.isFieldTouched,
+      isFieldValidating: this.isFieldValidating,
+      isFieldsValidating: this.isFieldsValidating,
+      resetFields: this.resetFields,
+      setFields: this.setFields,
+      setFieldValue: this.setFieldValue,
+      setFieldsValue: this.setFieldsValue,
+      validateFields: this.validateFields,
+      submit: this.submit,
+      _init: !0,
+      getInternalHooks: this.getInternalHooks
+    }));
+    // ======================== Internal Hooks ========================
+    r(this, "getInternalHooks", (e) => e === R ? (this.formHooked = !0, {
+      dispatch: this.dispatch,
+      initEntityValue: this.initEntityValue,
+      registerField: this.registerField,
+      useSubscribe: this.useSubscribe,
+      setInitialValues: this.setInitialValues,
+      destroyForm: this.destroyForm,
+      setCallbacks: this.setCallbacks,
+      setValidateMessages: this.setValidateMessages,
+      getFields: this.getFields,
+      setPreserve: this.setPreserve,
+      getInitialValue: this.getInitialValue,
+      registerWatch: this.registerWatch,
+      setBatchUpdate: this.setBatchUpdate
+    }) : (L(!1, "`getInternalHooks` is internal usage. Should not call directly."), null));
+    r(this, "useSubscribe", (e) => {
+      this.subscribable = e;
+    });
+    /**
+     * Record prev Form unmount fieldEntities which config preserve false.
+     * This need to be refill with initialValues instead of store value.
+     */
+    r(this, "prevWithoutPreserves", null);
+    /**
+     * First time `setInitialValues` should update store with initial value
+     */
+    r(this, "setInitialValues", (e, t) => {
+      var i;
+      if (this.initialValues = e || {}, t) {
+        let s = k(e, this.store);
+        (i = this.prevWithoutPreserves) == null || i.map(({
+          key: o
+        }) => {
+          s = F(s, o, w(e, o));
+        }), this.prevWithoutPreserves = null, this.updateStore(s);
+      }
+    });
+    r(this, "destroyForm", (e) => {
+      if (e)
+        this.updateStore({});
+      else {
+        const t = new b();
+        this.getFieldEntities(!0).forEach((i) => {
+          this.isMergedPreserve(i.isPreserve()) || t.set(i.getNamePath(), !0);
+        }), this.prevWithoutPreserves = t;
+      }
+    });
+    r(this, "getInitialValue", (e) => {
+      const t = w(this.initialValues, e);
+      return e.length ? k(t) : t;
+    });
+    r(this, "setCallbacks", (e) => {
+      this.callbacks = e;
+    });
+    r(this, "setValidateMessages", (e) => {
+      this.validateMessages = e;
+    });
+    r(this, "setPreserve", (e) => {
+      this.preserve = e;
+    });
+    // ============================= Watch ============================
+    r(this, "watchList", []);
+    r(this, "registerWatch", (e) => (this.watchList.push(e), () => {
+      this.watchList = this.watchList.filter((t) => t !== e);
+    }));
+    r(this, "notifyWatch", (e = []) => {
+      if (this.watchList.length) {
+        const t = this.getFieldsValue(), i = this.getFieldsValue(!0);
+        this.watchList.forEach((s) => {
+          s(t, i, e);
+        });
+      }
+    });
+    r(this, "notifyWatchNamePathList", []);
+    r(this, "batchNotifyWatch", (e) => {
+      this.notifyWatchNamePathList.push(e), this.batch("notifyWatch", () => {
+        this.notifyWatch(this.notifyWatchNamePathList), this.notifyWatchNamePathList = [];
+      });
+    });
+    // ============================= Batch ============================
+    r(this, "batchUpdate");
+    r(this, "setBatchUpdate", (e) => {
+      this.batchUpdate = e;
+    });
+    // Batch call the task, only last will be called
+    r(this, "batch", (e, t) => {
+      this.batchUpdate(e, t);
+    });
+    // ========================== Dev Warning =========================
+    r(this, "timeoutId", null);
+    r(this, "warningUnhooked", () => {
+      process.env.NODE_ENV !== "production" && !this.timeoutId && typeof window < "u" && (this.timeoutId = setTimeout(() => {
+        this.timeoutId = null, this.formHooked || L(!1, "Instance created by `useForm` is not connected to any Form element. Forget to pass `form` prop?");
+      }));
+    });
+    // ============================ Store =============================
+    r(this, "updateStore", (e) => {
+      this.store = e;
+    });
+    // ============================ Fields ============================
+    /**
+     * Get registered field entities.
+     * @param pure Only return field which has a `name`. Default: false
+     */
+    r(this, "getFieldEntities", (e = !1) => e ? this.fieldEntities.filter((t) => t.getNamePath().length) : this.fieldEntities);
+    r(this, "getFieldsMap", (e = !1) => {
+      const t = new b();
+      return this.getFieldEntities(e).forEach((i) => {
+        const s = i.getNamePath();
+        t.set(s, i);
+      }), t;
+    });
+    r(this, "getFieldEntitiesForNamePathList", (e) => {
+      if (!e)
+        return this.getFieldEntities(!0);
+      const t = this.getFieldsMap(!0);
+      return e.map((i) => {
+        const s = g(i);
+        return t.get(s) || {
+          INVALIDATE_NAME_PATH: g(i)
+        };
+      });
+    });
+    r(this, "getFieldsValue", (e, t) => {
+      this.warningUnhooked();
+      let i, s;
+      if (e === !0 || Array.isArray(e) ? (i = e, s = t) : e && typeof e == "object" && (s = e.filter), i === !0 && !s)
+        return this.store;
+      const o = this.getFieldEntitiesForNamePathList(Array.isArray(i) ? i : null), a = [], n = [];
+      o.forEach((h) => {
+        var d;
+        const u = h.INVALIDATE_NAME_PATH || h.getNamePath();
+        if ((d = h.isList) != null && d.call(h)) {
+          n.push(u);
+          return;
+        }
+        if (!s)
+          a.push(u);
+        else {
+          const P = "getMeta" in h ? h.getMeta() : null;
+          s(P) && a.push(u);
+        }
+      });
+      let l = A(this.store, a.map(g));
+      return n.forEach((h) => {
+        w(l, h) || (l = F(l, h, []));
+      }), l;
+    });
+    r(this, "getFieldValue", (e) => {
+      this.warningUnhooked();
+      const t = g(e);
+      return w(this.store, t);
+    });
+    r(this, "getFieldsError", (e) => (this.warningUnhooked(), this.getFieldEntitiesForNamePathList(e).map((i, s) => i && !i.INVALIDATE_NAME_PATH ? {
+      name: i.getNamePath(),
+      errors: i.getErrors(),
+      warnings: i.getWarnings()
+    } : {
+      name: g(e[s]),
+      errors: [],
+      warnings: []
+    })));
+    r(this, "getFieldError", (e) => {
+      this.warningUnhooked();
+      const t = g(e);
+      return this.getFieldsError([t])[0].errors;
+    });
+    r(this, "getFieldWarning", (e) => {
+      this.warningUnhooked();
+      const t = g(e);
+      return this.getFieldsError([t])[0].warnings;
+    });
+    r(this, "isFieldsTouched", (...e) => {
+      this.warningUnhooked();
+      const [t, i] = e;
+      let s, o = !1;
+      e.length === 0 ? s = null : e.length === 1 ? Array.isArray(t) ? (s = t.map(g), o = !1) : (s = null, o = t) : (s = t.map(g), o = i);
+      const a = this.getFieldEntities(!0), n = (d) => d.isFieldTouched();
+      if (!s)
+        return o ? a.every((d) => n(d) || d.isList()) : a.some(n);
+      const l = new b();
+      s.forEach((d) => {
+        l.set(d, []);
+      }), a.forEach((d) => {
+        const P = d.getNamePath();
+        s.forEach((p) => {
+          p.every((E, W) => P[W] === E) && l.update(p, (E) => [...E, d]);
+        });
+      });
+      const h = (d) => d.some(n), u = l.map(({
+        value: d
+      }) => d);
+      return o ? u.every(h) : u.some(h);
+    });
+    r(this, "isFieldTouched", (e) => (this.warningUnhooked(), this.isFieldsTouched([e])));
+    r(this, "isFieldsValidating", (e) => {
+      this.warningUnhooked();
+      const t = this.getFieldEntities();
+      if (!e)
+        return t.some((s) => s.isFieldValidating());
+      const i = e.map(g);
+      return t.some((s) => {
+        const o = s.getNamePath();
+        return S(i, o) && s.isFieldValidating();
+      });
+    });
+    r(this, "isFieldValidating", (e) => (this.warningUnhooked(), this.isFieldsValidating([e])));
+    /**
+     * Reset Field with field `initialValue` prop.
+     * Can pass `entities` or `namePathList` or just nothing.
+     */
+    r(this, "resetWithFieldInitialValue", (e = {}) => {
+      const t = new b(), i = this.getFieldEntities(!0);
+      i.forEach((a) => {
+        const {
+          initialValue: n
+        } = a.props, l = a.getNamePath();
+        if (n !== void 0) {
+          const h = t.get(l) || /* @__PURE__ */ new Set();
+          h.add({
+            entity: a,
+            value: n
+          }), t.set(l, h);
+        }
+      });
+      const s = (a) => {
+        a.forEach((n) => {
+          const {
+            initialValue: l
+          } = n.props;
+          if (l !== void 0) {
+            const h = n.getNamePath();
+            if (this.getInitialValue(h) !== void 0)
+              L(!1, `Form already set 'initialValues' with path '${h.join(".")}'. Field can not overwrite it.`);
+            else {
+              const d = t.get(h);
+              if (d && d.size > 1)
+                L(!1, `Multiple Field with path '${h.join(".")}' set 'initialValue'. Can not decide which one to pick.`);
+              else if (d) {
+                const P = this.getFieldValue(h);
+                !n.isListField() && (!e.skipExist || P === void 0) && this.updateStore(F(this.store, h, [...d][0].value));
+              }
+            }
+          }
+        });
+      };
+      let o;
+      e.entities ? o = e.entities : e.namePathList ? (o = [], e.namePathList.forEach((a) => {
+        const n = t.get(a);
+        n && o.push(...[...n].map((l) => l.entity));
+      })) : o = i, s(o);
+    });
+    r(this, "resetFields", (e) => {
+      this.warningUnhooked();
+      const t = this.store;
+      if (!e) {
+        this.updateStore(k(this.initialValues)), this.resetWithFieldInitialValue(), this.notifyObservers(t, null, {
+          type: "reset"
+        }), this.notifyWatch();
+        return;
+      }
+      const i = e.map(g);
+      i.forEach((s) => {
+        const o = this.getInitialValue(s);
+        this.updateStore(F(this.store, s, o));
+      }), this.resetWithFieldInitialValue({
+        namePathList: i
+      }), this.notifyObservers(t, i, {
+        type: "reset"
+      }), this.notifyWatch(i);
+    });
+    r(this, "setFields", (e) => {
+      this.warningUnhooked();
+      const t = this.store, i = [];
+      e.forEach((s) => {
+        const {
+          name: o,
+          ...a
+        } = s, n = g(o);
+        i.push(n), "value" in a && this.updateStore(F(this.store, n, a.value)), this.notifyObservers(t, [n], {
+          type: "setField",
+          data: s
+        });
+      }), this.notifyWatch(i);
+    });
+    r(this, "getFields", () => this.getFieldEntities(!0).map((i) => {
+      const s = i.getNamePath(), a = {
+        ...i.getMeta(),
+        name: s,
+        value: this.getFieldValue(s)
+      };
+      return Object.defineProperty(a, "originRCField", {
+        value: !0
+      }), a;
+    }));
+    // =========================== Observer ===========================
+    /**
+     * This only trigger when a field is on constructor to avoid we get initialValue too late
+     */
+    r(this, "initEntityValue", (e) => {
+      const {
+        initialValue: t
+      } = e.props;
+      if (t !== void 0) {
+        const i = e.getNamePath();
+        w(this.store, i) === void 0 && this.updateStore(F(this.store, i, t));
+      }
+    });
+    r(this, "isMergedPreserve", (e) => (e !== void 0 ? e : this.preserve) ?? !0);
+    r(this, "registerField", (e) => {
+      this.fieldEntities.push(e);
+      const t = e.getNamePath();
+      if (this.batchNotifyWatch(t), e.props.initialValue !== void 0) {
+        const i = this.store;
+        this.resetWithFieldInitialValue({
+          entities: [e],
+          skipExist: !0
+        }), this.notifyObservers(i, [e.getNamePath()], {
+          type: "valueUpdate",
+          source: "internal"
+        });
+      }
+      return (i, s, o = []) => {
+        if (this.fieldEntities = this.fieldEntities.filter((a) => a !== e), !this.isMergedPreserve(s) && (!i || o.length > 1)) {
+          const a = i ? void 0 : this.getInitialValue(t);
+          if (t.length && this.getFieldValue(t) !== a && this.fieldEntities.every((n) => (
+            // Only reset when no namePath exist
+            !O(n.getNamePath(), t)
+          ))) {
+            const n = this.store;
+            this.updateStore(F(n, t, a, !0)), this.notifyObservers(n, [t], {
+              type: "remove"
+            }), this.triggerDependenciesUpdate(n, t);
+          }
+        }
+        this.batchNotifyWatch(t);
+      };
+    });
+    r(this, "dispatch", (e) => {
+      switch (e.type) {
+        case "updateValue": {
+          const {
+            namePath: t,
+            value: i
+          } = e;
+          this.updateValue(t, i);
+          break;
+        }
+        case "validateField": {
+          const {
+            namePath: t,
+            triggerName: i
+          } = e;
+          this.validateFields([t], {
+            triggerName: i
+          });
+          break;
+        }
+      }
+    });
+    r(this, "notifyObservers", (e, t, i) => {
+      if (this.subscribable) {
+        const s = {
+          ...i,
+          store: this.getFieldsValue(!0)
+        };
+        this.getFieldEntities().forEach(({
+          onStoreChange: o
+        }) => {
+          o(e, t, s);
+        });
+      } else
+        this.forceRootUpdate();
+    });
+    /**
+     * Notify dependencies children with parent update
+     * We need delay to trigger validate in case Field is under render props
+     */
+    r(this, "triggerDependenciesUpdate", (e, t) => {
+      const i = this.getDependencyChildrenFields(t);
+      return i.length && this.validateFields(i), this.notifyObservers(e, i, {
+        type: "dependenciesUpdate",
+        relatedFields: [t, ...i]
+      }), i;
+    });
+    r(this, "updateValue", (e, t) => {
+      const i = g(e), s = this.store;
+      this.updateStore(F(this.store, i, t)), this.notifyObservers(s, [i], {
+        type: "valueUpdate",
+        source: "internal"
+      }), this.notifyWatch([i]);
+      const o = this.triggerDependenciesUpdate(s, i), {
+        onValuesChange: a
+      } = this.callbacks;
+      if (a) {
+        const n = this.getFieldsMap(!0).get(i), l = A(this.store, [i]), h = this.getFieldsValue(), u = H([h, l], {
+          // When value is array, it means trigger by Form.List which should replace directly
+          prepareArray: (d) => n != null && n.isList() ? [] : [...d || []]
+        });
+        a(l, u);
+      }
+      this.triggerOnFieldsChange([i, ...o]);
+    });
+    // Let all child Field get update.
+    r(this, "setFieldsValue", (e) => {
+      this.warningUnhooked();
+      const t = this.store;
+      if (e) {
+        const i = k(this.store, e);
+        this.updateStore(i);
+      }
+      this.notifyObservers(t, null, {
+        type: "valueUpdate",
+        source: "external"
+      }), this.notifyWatch();
+    });
+    r(this, "setFieldValue", (e, t) => {
+      this.setFields([{
+        name: e,
+        value: t,
+        errors: [],
+        warnings: [],
+        touched: !0
+      }]);
+    });
+    r(this, "getDependencyChildrenFields", (e) => {
+      const t = /* @__PURE__ */ new Set(), i = [], s = new b();
+      this.getFieldEntities().forEach((a) => {
+        const {
+          dependencies: n
+        } = a.props;
+        (n || []).forEach((l) => {
+          const h = g(l);
+          s.update(h, (u = /* @__PURE__ */ new Set()) => (u.add(a), u));
+        });
+      });
+      const o = (a) => {
+        (s.get(a) || /* @__PURE__ */ new Set()).forEach((l) => {
+          if (!t.has(l)) {
+            t.add(l);
+            const h = l.getNamePath();
+            l.isFieldDirty() && h.length && (i.push(h), o(h));
+          }
+        });
+      };
+      return o(e), i;
+    });
+    r(this, "triggerOnFieldsChange", (e, t) => {
+      const {
+        onFieldsChange: i
+      } = this.callbacks;
+      if (i) {
+        const s = this.getFields();
+        if (t) {
+          const a = new b();
+          t.forEach(({
+            name: n,
+            errors: l
+          }) => {
+            a.set(n, l);
+          }), s.forEach((n) => {
+            n.errors = a.get(n.name) || n.errors;
+          });
+        }
+        const o = s.filter(({
+          name: a
+        }) => S(e, a));
+        o.length && i(o, s);
+      }
+    });
+    // =========================== Validate ===========================
+    r(this, "validateFields", (e, t) => {
+      this.warningUnhooked();
+      let i, s;
+      Array.isArray(e) || typeof e == "string" || typeof t == "string" ? (i = e, s = t) : s = e;
+      const o = !!i, a = o ? i.map(g) : [], n = [...a], l = [], h = String(Date.now()), u = /* @__PURE__ */ new Set(), {
+        recursive: d,
+        dirty: P
+      } = s || {};
+      this.getFieldEntities(!0).forEach((c) => {
+        const f = c.getNamePath();
+        if (o || // If is field, pass directly
+        ((!c.isList() || // If is list, do not add if already exist sub field in the namePathList
+        !a.some((V) => O(V, f, !0))) && n.push(f), a.push(f)), !(!c.props.rules || !c.props.rules.length) && !(P && !c.isFieldDirty()) && (u.add(f.join(h)), !o || S(a, f, d))) {
+          const V = c.validateRules({
+            validateMessages: {
+              ...j,
+              ...this.validateMessages
+            },
+            ...s
+          });
+          l.push(V.then(() => ({
+            name: f,
+            errors: [],
+            warnings: []
+          })).catch((y) => {
+            var I;
+            const v = [], N = [];
+            return (I = y.forEach) == null || I.call(y, ({
+              rule: {
+                warningOnly: T
+              },
+              errors: U
+            }) => {
+              T ? N.push(...U) : v.push(...U);
+            }), v.length ? Promise.reject({
+              name: f,
+              errors: v,
+              warnings: N
+            }) : {
+              name: f,
+              errors: v,
+              warnings: N
+            };
+          }));
+        }
+      });
+      const p = _(l);
+      this.lastValidatePromise = p, p.catch((c) => c).then((c) => {
+        const f = c.map(({
+          name: V
+        }) => V);
+        this.notifyObservers(this.store, f, {
+          type: "validateFinish"
+        }), this.triggerOnFieldsChange(f, c);
+      });
+      const E = p.then(() => this.lastValidatePromise === p ? Promise.resolve(this.getFieldsValue(n)) : Promise.reject([])).catch((c) => {
+        var y, v;
+        const f = c.filter((N) => N && N.errors.length), V = (v = (y = f[0]) == null ? void 0 : y.errors) == null ? void 0 : v[0];
+        return Promise.reject({
+          message: V,
+          values: this.getFieldsValue(a),
+          errorFields: f,
+          outOfDate: this.lastValidatePromise !== p
+        });
+      });
+      E.catch((c) => c);
+      const W = a.filter((c) => u.has(c.join(h)));
+      return this.triggerOnFieldsChange(W), E;
+    });
+    // ============================ Submit ============================
+    r(this, "submit", () => {
+      this.warningUnhooked(), this.validateFields().then((e) => {
+        const {
+          onFinish: t
+        } = this.callbacks;
+        if (t)
+          try {
+            t(e);
+          } catch (i) {
+            console.error(i);
+          }
+      }).catch((e) => {
+        const {
+          onFinishFailed: t
+        } = this.callbacks;
+        t && t(e);
+      });
+    });
+    this.forceRootUpdate = e;
+  }
+}
+function ee(m) {
+  const e = M.useRef(null), [, t] = M.useState({});
+  if (!e.current)
+    if (m)
+      e.current = m;
+    else {
+      const i = () => {
+        t({});
+      }, s = new x(i);
+      e.current = s.getForm();
+    }
+  return [e.current];
+}
+export {
+  x as FormStore,
+  ee 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/useWatch.js

@@ -0,0 +1,42 @@
+import { warningOnce as R } 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 { useState as S, useMemo as E, useRef as _, useContext as C, useEffect as h } from "react";
+import F, { HOOK_MARK as I } from "./FieldContext.js";
+import { isFormInstance as M } from "./utils/typeUtil.js";
+import { getNamePath as W } from "./utils/valueUtil.js";
+import w 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/useEvent.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/hooks/useLayoutEffect.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 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/utils/get.js";
+function f(n) {
+  try {
+    return JSON.stringify(n);
+  } catch {
+    return Math.random();
+  }
+}
+function j(...n) {
+  const [t, s = {}] = n, u = M(s) ? {
+    form: s
+  } : s, a = u.form, [o, y] = S(() => typeof t == "function" ? t({}) : void 0), m = E(() => f(o), [o]), v = _(m);
+  v.current = m;
+  const x = C(F), c = a || x, e = c && c._init;
+  process.env.NODE_ENV !== "production" && R(n.length === 2 ? a ? e : !0 : e, "useWatch requires a form instance since it can not auto detect from context.");
+  const {
+    getFieldsValue: p,
+    getInternalHooks: O
+  } = c, {
+    registerWatch: V
+  } = O(I), l = w((g, i) => {
+    const r = u.preserve ? i ?? p(!0) : g ?? p(), d = typeof t == "function" ? t(r) : D(r, W(t));
+    f(o) !== f(d) && y(d);
+  }), N = typeof t == "function" ? t : JSON.stringify(t);
+  return h(() => {
+    e && l();
+  }, [e, N]), h(() => e ? V((i, r) => {
+    l(i, r);
+  }) : void 0, [e]), o;
+}
+export {
+  j as default,
+  f as stringify
+};