@dazhicheng/ui 1.5.199 → 1.5.201

package/dist/components/tt-form/src/group-form/groupFormApi.js

@@ -0,0 +1,700 @@
+var M = Object.defineProperty;
+var A = (u, c, e) => c in u ? M(u, c, { enumerable: !0, configurable: !0, writable: !0, value: e }) : u[c] = e;
+var n = (u, c, e) => A(u, typeof c != "symbol" ? c + "" : c, e);
+import { isFunction as S, isString as b, isBoolean as G } from "@dazhicheng/utils";
+import { isPlainObject as p, get as v, cloneDeep as V } from "lodash-es";
+import { ref as N, reactive as f, nextTick as C } from "vue";
+import { FormApi as P } from "../formApi.js";
+import { resolveValueByFieldName as E } from "../form-render/dependencies.js";
+import { resolveSchemaFieldInitialValue as k } from "../useFormContext.js";
+import { normalizeArrayFieldPath as y, childArrayPath as H } from "../utils/array-path.js";
+import { extractFlatSchemas as m, collectDefaultCollapseStates as w, getGroupValues as K, cloneSchemaTree as _, insertFieldsByPosition as O, removeFieldsFromGroup as j, removeGroupsFromGroup as T, isGroupSchema as R, isRowSchema as x } from "./utils.js";
+class L extends P {
+  /**
+   * @param {TtFormProps} formProps - 底层表单配置（已展平的 schema、layout 等）
+   * @param {GroupFormApiOptions} groupOptions - 分组场景专属配置
+   */
+  constructor(e, t) {
+    super(e);
+    /** 是否启用虚拟化（IntersectionObserver 懒渲染） */
+    n(this, "virtual");
+    /** 构造时的导航锚点默认配置，作为 store 未设置时的 fallback */
+    n(this, "_defaultNavAnchorProps");
+    /** 校验失败时是否自动滚动到第一个有错误的分组，默认 true */
+    n(this, "_scrollToFirstError");
+    /** 滚动容器高度 */
+    n(this, "_containerHeight");
+    /** IntersectionObserver rootMargin */
+    n(this, "_rootMargin");
+    /** 预估每个表单项高度（px） */
+    n(this, "_estimateFieldHeight");
+    /** 滚动到分组时的顶部偏移量（px），补偿固定元素遮挡 */
+    n(this, "_scrollOffset");
+    /** 各分组折叠状态（key → 是否折叠） */
+    n(this, "collapseStates");
+    /** 当前被 ifShow 隐藏的分组 key 集合 */
+    n(this, "hiddenGroupKeys");
+    /** 当前被 ifShow 隐藏的字段名集合 */
+    n(this, "hiddenFieldNames");
+    /** 导航各分组的错误数量，validate 后自动更新 */
+    n(this, "navErrorCounts");
+    /** 共享错误缓存，validate 写入 → LazyFormField 挂载时读取恢复 */
+    n(this, "errorCacheMap", /* @__PURE__ */ new Map());
+    /** 重置信号，递增时通知所有 LazyFormField 清空 cachedError */
+    n(this, "resetSignal", N(0));
+    /** 初始传入的分组 schema（用于 fallback） */
+    n(this, "_initialGroupSchema");
+    /** 初始展平后的 flatSchema（用于 fallback） */
+    n(this, "_initialFlatSchema");
+    /** 各分组 key → 其直属字段名（不含子分组的字段） */
+    n(this, "_groupFieldMap", {});
+    /** 各分组 key → 其直属子分组 key 列表 */
+    n(this, "_groupChildrenMap", {});
+    /** 字段名 → 所属分组 key 的反向映射，用于快速判断字段是否属于隐藏分组 */
+    n(this, "_fieldToGroupKey", {});
+    /** 子分组 key → 父分组 key 的映射，用于递归向上查找祖先分组是否被隐藏 */
+    n(this, "_groupParentMap", {});
+    /** 字段名 → 字段 schema 的映射，用于隐藏清空时读取默认值 */
+    n(this, "_fieldSchemaMap", {});
+    /** 分组 key 构建时的去重集合，用于检测重复 key */
+    n(this, "_groupKeySet", /* @__PURE__ */ new Set());
+    /** 是否已执行过 validate，用于控制导航栏错误同步是否需要重新校验未挂载字段 */
+    n(this, "_hasValidated", !1);
+    /** VirtualGroupForm 组件实例引用，由 useGroupForm 的 h() 渲染时赋值 */
+    n(this, "groupFormRef", N(null));
+    /**
+     * @description 响应式读取 store 状态，由 useGroupForm 在运行时注入实现
+     * @param {Function} [selector] - 可选的状态选择器
+     * @returns {Readonly<Ref<T>>} 响应式状态引用
+     */
+    n(this, "useStore");
+    const {
+      groupSchema: r,
+      virtual: s = !0,
+      navAnchorProps: o,
+      scrollToFirstError: i = !0,
+      containerHeight: a = "100%",
+      rootMargin: l = "400px 0px",
+      estimateFieldHeight: h = 52,
+      scrollOffset: d = 0
+    } = t;
+    this.virtual = s, this._defaultNavAnchorProps = { show: !0, ...o }, this._scrollToFirstError = i, this._containerHeight = a, this._rootMargin = l, this._estimateFieldHeight = h, this._scrollOffset = d, this._initialGroupSchema = r, this._initialFlatSchema = m(r), this.collapseStates = f({}), w(r, this.collapseStates), this.hiddenGroupKeys = f(/* @__PURE__ */ new Set()), this.hiddenFieldNames = f(/* @__PURE__ */ new Set()), this.navErrorCounts = f({}), this._buildGroupFieldMap(r), this.setState({
+      groupSchema: r,
+      navAnchorProps: this._defaultNavAnchorProps,
+      virtual: s,
+      containerHeight: a,
+      rootMargin: l,
+      estimateFieldHeight: h,
+      scrollOffset: d
+    });
+  }
+  /**
+   * @description 从 store 响应式读取 navAnchorProps，支持通过 setState({ navAnchorProps }) 动态修改
+   * @returns {Required<Pick<UseGroupFormNavAnchorProps, "show">> & UseGroupFormNavAnchorProps} 导航锚点配置
+   */
+  get navAnchorProps() {
+    return this.store.state.navAnchorProps ?? this._defaultNavAnchorProps;
+  }
+  /**
+   * @description 覆盖基类 setState，扩展支持 GroupFormExtraState 中的字段（navAnchorProps、groupSchema 等）。
+   * @param {Partial<GroupFormState> | ((prev: GroupFormState) => Partial<GroupFormState>)} stateOrFn - 新状态或更新函数
+   */
+  setState(e) {
+    const t = this.store.state, r = S(e) ? e(t) : e;
+    if (super.setState(e), r.groupSchema === void 0)
+      return;
+    const s = this.store.state.groupSchema;
+    !s || s === t.groupSchema || (this._buildGroupFieldMap(s), super.setState({ schema: m(s) }));
+  }
+  /**
+   * @description 分组表单以 `groupSchema` 展平结果为字段全集。仅依赖 store 中的 `schema` 时，若与 `groupSchema` 不同步（例如外部只 `setState` 了 `groupSchema`、或合并顺序导致 `schema` 滞后），`setValues` 默认过滤会误删合法字段；此处优先按 `groupSchema` 展平生成白名单。
+   * @returns {string[]} 允许 `setValues` 写入的 fieldName 列表
+   */
+  getFieldNamesForSetValuesFilter() {
+    const e = this.store.state.groupSchema;
+    return e != null && e.length ? m(e).map((t) => t.fieldName).filter((t) => typeof t == "string" && t.length > 0) : super.getFieldNamesForSetValuesFilter();
+  }
+  /**
+   * @description schema 中移除字段后清空 vee 值/错误，并同步清理虚拟列表 errorCacheMap
+   * @param {string[]} removedFieldNames 已移除的 fieldName 列表
+   */
+  onRemovedSchemaFields(e) {
+    if (e.length) {
+      super.onRemovedSchemaFields(e);
+      for (const t of e)
+        this.errorCacheMap.delete(t), this.unregisterArrayField(t);
+    }
+  }
+  /**
+   * @description 校验表单（含未挂载的虚拟字段），支持通过第二个参数控制是否滚动到第一个错误分组
+   * @param {Partial<ValidationOptions>} [opts] - 原始 validate 选项
+   * @param {boolean} [scrollToError] - 是否滚动到第一个错误分组，不传时使用全局配置 scrollToFirstError
+   * @returns {Promise<{valid: boolean; errors: Record<string, string>; results?: any}>} 校验结果
+   * @example
+   * await formApi.validate();
+   * @example
+   * await formApi.validate(undefined, true);
+   * @example
+   * await formApi.validate(undefined, false);
+   */
+  async validate(e, t) {
+    let r = await super.validate(e);
+    return this.hiddenFieldNames.size > 0 && (r = this._stripHiddenFieldErrors(r)), this.virtual && (this.errorCacheMap.clear(), this._hasValidated = !0, r = await this._validateUnmountedFields(r)), this.navAnchorProps.show && await this.syncNavErrorCountsFromForm(), (t ?? this._scrollToFirstError) && !r.valid && this._scrollToFirstErrorGroup(r.errors), r;
+  }
+  /**
+   * @description 校验并提交表单
+   * @returns {Promise<any>} 提交结果，校验失败时返回 undefined
+   */
+  async validateAndSubmitForm() {
+    if ((await this.validate()).valid)
+      return await this.submitForm();
+  }
+  /**
+   * @description 重置表单（含清空虚拟字段错误缓存和导航错误计数）
+   * @param {Partial<FormState<GenericObject>>} [state] - 重置后的表单状态
+   * @param {Partial<ResetFormOpts>} [opts] - 重置选项
+   */
+  async resetForm(e, t) {
+    return this.virtual && (this._clearAllCachedErrors(), this._hasValidated = !1), this.navAnchorProps.show && this._clearNavErrorCounts(), await super.resetForm(e, t);
+  }
+  /**
+   * @description 重置校验状态（含清空虚拟字段错误缓存和导航错误计数）
+   */
+  async resetValidate() {
+    return this.virtual && (this._clearAllCachedErrors(), this._hasValidated = !1), this.navAnchorProps.show && this._clearNavErrorCounts(), await super.resetValidate();
+  }
+  /**
+   * @description 获取表单值
+   * @param {boolean} [isGroup] - 为 true 时返回按分组 key 嵌套的对象，默认 false 返回扁平值
+   * @returns {Promise<T>} 表单值
+   */
+  async getValues(e = !1) {
+    const t = await super.getValues();
+    if (e) {
+      const r = this.store.state.groupSchema ?? this._initialGroupSchema;
+      return K(r, t);
+    }
+    return t;
+  }
+  /**
+   * @description 滚动到指定分组（外部可通过 formApi.scrollToGroup 调用）
+   * @param {string} key - 分组 key
+   */
+  scrollToGroup(e) {
+    var r;
+    const t = this.groupFormRef.value;
+    (r = t == null ? void 0 : t.scrollToGroup) == null || r.call(t, e);
+  }
+  /**
+   * @description 切换分组折叠状态
+   * @param {string} key - 分组 key
+   */
+  toggleCollapse(e) {
+    this.collapseStates[e] = !this.collapseStates[e];
+  }
+  /**
+   * @description 设置分组折叠状态
+   * @param {string} key - 分组 key
+   * @param {boolean} collapsed - 是否折叠
+   */
+  setGroupCollapsed(e, t) {
+    this.collapseStates[e] = t;
+  }
+  /**
+   * @description 设置容器的可见性状态，由 GroupSection 组件在 ifShow 求值后调用。
+   *   group 隐藏时额外维护 {@link hiddenGroupKeys} 供导航和渲染判断；
+   *   group / row 隐藏时都会清空其下字段校验，并把字段加入 {@link hiddenFieldNames}，使隐藏字段不参与校验。
+   *   可见性变化后在下一帧调用 {@link syncNavErrorCountsFromForm}，使「先 validate 再隐藏再显示」时
+   *   导航徽标、{@link errorCacheMap} 与表单项错误展示保持一致。
+   * @param {string} key - 分组 key
+   * @param {boolean} visible - 是否可见
+   * @param {string[]} [fieldNames] - 兼容旧内部调用的字段名列表，传入时按字段集合显隐处理
+   */
+  setGroupVisible(e, t, r) {
+    if (r) {
+      this.setFieldsVisible(r, t);
+      return;
+    }
+    const s = this.getGroupFieldNames(e);
+    t ? (this.hiddenGroupKeys.delete(e), this._setFieldsHidden(s, !1)) : (this._setFieldsHidden(s, !0), this._clearHiddenFieldValues(s), this.hiddenGroupKeys.add(e)), C(() => {
+      this.syncNavErrorCountsFromForm();
+    });
+  }
+  /**
+   * @description 设置字段集合的可见性状态，用于 row 容器隐藏时同步字段值、校验和错误缓存。
+   * @param {string[]} fieldNames - 字段名列表
+   * @param {boolean} visible - 是否可见
+   */
+  setFieldsVisible(e, t) {
+    t ? this._setFieldsHidden(e, !1) : (this._setFieldsHidden(e, !0), this._clearHiddenFieldValues(e)), C(() => {
+      this.syncNavErrorCountsFromForm();
+    });
+  }
+  /**
+   * @description 判断字段是否属于被隐藏的字段集合
+   * @param {string} fieldName - 字段名
+   * @returns {boolean} 是否属于隐藏字段
+   */
+  _isFieldHidden(e) {
+    if (this.hiddenFieldNames.size === 0) return !1;
+    for (const t of this.hiddenFieldNames)
+      if (this._matchFieldOrNested(e, t)) return !0;
+    return !1;
+  }
+  /**
+   * @description 判断错误键是否命中字段（支持数组/对象嵌套键）
+   * @param {string} errorKey - 错误键（如 a[0].b）
+   * @param {string} field - schema 字段（如 a）
+   * @returns {boolean}
+   */
+  _matchFieldOrNested(e, t) {
+    const r = y(e), s = y(t);
+    return r === s || r.startsWith(`${s}.`) || r.startsWith(`${s}[`);
+  }
+  /**
+   * @description 按当前 store 中的 groupSchema（若无则用初始 schema）重置折叠状态：
+   *   先清空已有 key，再按 `defaultCollapsed` 写入默认值。
+   *   用于同一 `formApi` 实例下分组表单卸载后再次挂载（如弹框 `destroy-on-close`）时，避免沿用上次折叠状态。
+   */
+  resetCollapseStatesToDefault() {
+    const e = this.store.state.groupSchema ?? this._initialGroupSchema;
+    for (const t of Object.keys(this.collapseStates))
+      delete this.collapseStates[t];
+    w(e, this.collapseStates);
+  }
+  /**
+   * @description 全量应用分组 schema 树到 store（扁平 schema、groupSchema、分组字段映射、折叠默认值）。
+   */
+  _applyGroupSchema(e) {
+    this.setState({ groupSchema: e });
+  }
+  /**
+   * @description 增量插入字段到分组 schema 树中，无需全量重建 schema。
+   *   通过 position 的 before/after 在整棵树中递归查找锚点并就地插入；
+   *   不传 position 时追加到顶层 schema 末尾。
+   * @param {GroupFormSchema[]} fields - 要插入的字段或子结构（字段、slot、row 等均可）
+   * @param {InsertPosition} [position] - 插入位置，省略则追加到顶层末尾
+   * @example
+   * formApi.appendFields([newField], { before: 'phone' });
+   * @example
+   * formApi.appendFields([newField], { after: 'email' });
+   * @example
+   * formApi.appendFields([newGroup]);
+   */
+  appendFields(e, t) {
+    const r = this.store.state.groupSchema ?? [], s = _(r);
+    t && (t.before || t.after) ? O(s, e, t) || s.push(...e) : s.push(...e), this._applyGroupSchema(s), this.seedDefaultsForAppendedFields(m(e));
+  }
+  /**
+   * @description 按标识从 groupSchema 树中移除节点，无需全量重建 schema。
+   *   支持匹配 fieldName（普通字段 / row 内字段）和 slot 的字符串 content
+   * @param {string[]} fieldNames - 要移除的标识列表（fieldName 或 slot content 字符串）
+   * @example
+   * formApi.removeFields(['v_phone', 'v_email']);
+   */
+  removeFields(e) {
+    if (!e.length) return;
+    const t = this.store.state.groupSchema ?? [], r = j(_(t), new Set(e));
+    this._applyGroupSchema(r);
+  }
+  /**
+   * @description 清理已移除分组的运行时状态（隐藏集、折叠、导航徽标等）
+   * @param keysToRemove - 待移除的分组 key（含子分组）
+   */
+  _purgeRemovedGroupState(e) {
+    for (const r of e)
+      this._setFieldsHidden(this.getGroupFieldNames(r), !1), this.hiddenGroupKeys.delete(r), Reflect.deleteProperty(this.navErrorCounts, r), Reflect.deleteProperty(this.collapseStates, r);
+    const t = this.navAnchorProps.extraBadgeCounts;
+    if (t)
+      for (const r of e)
+        Reflect.deleteProperty(t, r);
+    for (const r of Object.keys(this.navErrorCounts))
+      r in this._groupFieldMap || Reflect.deleteProperty(this.navErrorCounts, r);
+  }
+  /**
+   * @description 按分组 key 移除分组及其子分组（从 groupSchema 树删除），并清空其下字段值与相关状态
+   * @param groupKey - 分组 key（单个或数组）
+   * @example
+   * formApi.removeGroups(['group1', 'group2']);
+   * formApi.removeGroups('group1');
+   */
+  removeGroups(e) {
+    const t = Array.isArray(e) ? e : [e], r = this._collectGroupKeysWithDescendants(t);
+    if (!r.length)
+      return;
+    const s = [...new Set(r.flatMap((a) => this.getGroupFieldNames(a, !0)))], o = this.store.state.groupSchema ?? [], i = T(_(o), new Set(r));
+    this._applyGroupSchema(i), s.length && this.onRemovedSchemaFields(s), this._purgeRemovedGroupState(r), this.navAnchorProps.show && this.syncNavErrorCountsFromForm();
+  }
+  /**
+   * @description 合并 vee-validate 实时 errors 与虚拟列表未挂载字段的 errorCacheMap，用于导航徽标与输入联动
+   * @returns {Record<string, string>} 合并后的错误映射
+   */
+  _mergeErrorsForNav() {
+    var r, s;
+    const e = (s = (r = this.form) == null ? void 0 : r.errors) == null ? void 0 : s.value, t = {};
+    if (e && typeof e == "object")
+      for (const o of Object.keys(e)) {
+        if (this._isFieldHidden(o)) continue;
+        const i = e[o];
+        i && (t[o] = i);
+      }
+    return this.virtual && this.errorCacheMap.forEach((o, i) => {
+      this._isFieldHidden(i) || o && t[i] === void 0 && (t[i] = o);
+    }), t;
+  }
+  /**
+   * @description 同步导航错误计数。
+   *   当开启虚拟列表且已执行过 validate 时，会重新对未挂载字段做可见性检查和校验，
+   *   确保 dependencies 条件变化后错误计数实时更新。
+   */
+  async syncNavErrorCountsFromForm() {
+    var a, l;
+    if (!this.virtual || !this._hasValidated) {
+      this._updateNavErrorCounts(this._mergeErrorsForNav());
+      return;
+    }
+    const e = this.form;
+    if (!(e != null && e.values)) {
+      this._updateNavErrorCounts(this._mergeErrorsForNav());
+      return;
+    }
+    const t = e.values, r = (l = (a = this.form) == null ? void 0 : a.errors) == null ? void 0 : l.value, s = /* @__PURE__ */ new Set();
+    if (r)
+      for (const h of Object.keys(r))
+        s.add(h);
+    const o = {};
+    if (r && typeof r == "object")
+      for (const h of Object.keys(r)) {
+        if (this._isFieldHidden(h)) continue;
+        const d = r[h];
+        d && (o[h] = d);
+      }
+    const i = this.store.state.schema ?? this._initialFlatSchema;
+    for (const h of i) {
+      const d = h.fieldName;
+      if (!d || s.has(d)) continue;
+      if (!await this._isFieldVisible(h, t)) {
+        this.errorCacheMap.delete(d);
+        continue;
+      }
+      const F = E(t, d), g = await this._validateFieldValue(F, h.rules, d);
+      g ? (this.errorCacheMap.set(d, g), o[d] = g) : this.errorCacheMap.delete(d);
+    }
+    this._updateNavErrorCounts(o);
+  }
+  /**
+   * @description 清空导航各分组的错误计数
+   */
+  _clearNavErrorCounts() {
+    for (const e of Object.keys(this.navErrorCounts))
+      this.navErrorCounts[e] = 0;
+  }
+  /**
+   * @description 校验失败后展开包含错误的分组，并滚动到该分组标题
+   * @param {Record<string, string>} errors - 合并后的所有错误
+   */
+  _scrollToFirstErrorGroup(e) {
+    const t = this._findFirstErrorGroupKey(e);
+    t && (this.collapseStates[t] && this.toggleCollapse(t), this.scrollToGroup(t));
+  }
+  /**
+   * @description 从校验结果中剔除属于隐藏字段集合的错误，并重新判定 valid 状态
+   * @param {object} result - 校验结果
+   * @returns {object} 过滤后的校验结果
+   */
+  _stripHiddenFieldErrors(e) {
+    const t = {};
+    let r = !1;
+    for (const [s, o] of Object.entries(e.errors))
+      this._isFieldHidden(s) || (t[s] = o, o && (r = !0));
+    return { ...e, errors: t, valid: !r };
+  }
+  /**
+   * @description 对单个字段值执行 rules 校验（纯数据，不挂载组件）。
+   *   支持字符串规则（"required" / "selectRequired"）和 Zod schema。
+   * @param {unknown} value - 字段值
+   * @param {FormSchemaRuleType | undefined} rules - 校验规则
+   * @param {string} fieldName - 字段名
+   * @returns {Promise<string | undefined>} 错误信息，无错误返回 undefined
+   */
+  async _validateFieldValue(e, t, r) {
+    var s;
+    if (t) {
+      if (b(t)) {
+        if (t === "required") {
+          if (e == null || e === "")
+            return "请输入";
+        } else if (t === "selectRequired" && (e == null || Array.isArray(e) && e.length === 0 || e === ""))
+          return "请选择";
+        return;
+      }
+      try {
+        const i = t.safeParse(e);
+        if (!i.success)
+          return ((s = i.error.issues[0]) == null ? void 0 : s.message) || `${r} 校验失败`;
+      } catch {
+      }
+    }
+  }
+  /**
+   * @description 检查字段的 dependencies 条件，判断字段在当前值下是否应该被校验。
+   *   与 FormField.vue 保持一致：visible = !hide && isIf && isShow
+   * @param {FormSchema} schema - 字段 schema
+   * @param {Record<string, any>} values - 当前表单值
+   * @returns {Promise<boolean>} 字段是否可见
+   */
+  async _isFieldVisible(e, t) {
+    if (e.fieldName && this._isFieldHidden(e.fieldName) || e.hide) return !1;
+    const r = e.dependencies;
+    if (!r) return !0;
+    const s = r.if;
+    if (s != null && (G(s) && !s || S(s) && !await s(t, this.form)))
+      return !1;
+    const o = r.show;
+    return !(o != null && (G(o) && !o || S(o) && !await o(t, this.form)));
+  }
+  /**
+   * @description 对所有未挂载的字段做纯值校验，补充到 validate 结果中，
+   *   并将错误写入 errorCacheMap 以便 LazyFormField 挂载时恢复。
+   *   会跳过因 dependencies.if 条件不满足而不应渲染的字段，与原始表单校验行为一致。
+   * @param {object} validateResult - 父类 validate 返回的校验结果
+   * @returns {Promise<object>} 补充未挂载字段错误后的校验结果
+   */
+  async _validateUnmountedFields(e) {
+    const t = this.form;
+    if (!(t != null && t.values)) return e;
+    const r = t.values, s = new Set(Object.keys(e.results || {})), o = {}, i = this.store.state.schema ?? this._initialFlatSchema;
+    for (const a of i) {
+      const l = a.fieldName;
+      if (!l || s.has(l) || !await this._isFieldVisible(a, r)) continue;
+      const h = E(r, l), d = await this._validateFieldValue(h, a.rules, l);
+      d && (o[l] = d, this.errorCacheMap.set(l, d));
+    }
+    return Object.keys(o).length > 0 ? {
+      valid: !1,
+      errors: { ...e.errors, ...o },
+      results: e.results
+    } : e;
+  }
+  /**
+   * @description 清空所有缓存的错误并递增重置信号
+   */
+  _clearAllCachedErrors() {
+    this.errorCacheMap.clear(), this.resetSignal.value++;
+  }
+  /**
+   * @description 收集分组 key 及其所有子分组 key（去重）
+   * @param keys - 起始分组 key 列表
+   */
+  _collectGroupKeysWithDescendants(e) {
+    const t = /* @__PURE__ */ new Set(), r = (s) => {
+      if (!(!s || t.has(s))) {
+        t.add(s);
+        for (const o of this._groupChildrenMap[s] ?? [])
+          r(o);
+      }
+    };
+    for (const s of e)
+      r(s);
+    return [...t];
+  }
+  /**
+   * @description 递归构建各分组 key → 其直属字段名的映射
+   * @param {GroupFormSchema[]} schemas - 分组 schema 数组
+   * @param {string} [parentKey] - 父分组 key
+   */
+  _buildGroupFieldMap(e, t) {
+    var r;
+    t || (this._groupFieldMap = {}, this._groupChildrenMap = {}, this._fieldToGroupKey = {}, this._groupParentMap = {}, this._fieldSchemaMap = {}, this._groupKeySet.clear());
+    for (const s of e)
+      if (R(s)) {
+        if (this._groupKeySet.has(s.key))
+          throw new Error(
+            `[GroupFormApi] duplicate group key detected: "${s.key}". Group key must be unique in groupSchema tree.`
+          );
+        this._groupKeySet.add(s.key), this._groupFieldMap[s.key] = [], this._groupChildrenMap[s.key] = [], t && (this._groupParentMap[s.key] = t, (r = this._groupChildrenMap)[t] ?? (r[t] = []), this._groupChildrenMap[t].push(s.key)), this._buildGroupFieldMap(s.children, s.key);
+      } else x(s) ? this._buildGroupFieldMap(s.children, t) : t && "fieldName" in s && s.fieldName ? (this._groupFieldMap[t].push(s.fieldName), this._fieldToGroupKey[s.fieldName] = t, this._fieldSchemaMap[s.fieldName] = s) : "fieldName" in s && s.fieldName && (this._fieldSchemaMap[s.fieldName] = s);
+  }
+  /**
+   * @description 根据错误映射更新导航各分组的错误计数
+   * @param {Record<string, string>} errors - 字段错误映射
+   */
+  _updateNavErrorCounts(e) {
+    const t = Object.keys(e).filter((r) => !!e[r]);
+    for (const r of Object.keys(this._groupFieldMap)) {
+      const o = this.getGroupFieldNames(r).filter(
+        (i) => t.some((a) => this._matchFieldOrNested(a, i))
+      ).length;
+      this.navErrorCounts[r] = o;
+    }
+  }
+  /**
+   * @description 根据错误字段找到第一个包含错误的分组 key（按 schema 定义顺序）
+   * @param {Record<string, string>} errors - 错误字段映射
+   * @returns {string | undefined} 第一个有错误的分组 key
+   */
+  _findFirstErrorGroupKey(e) {
+    const t = Object.keys(e).filter((r) => e[r]);
+    if (t.length !== 0)
+      for (const r of Object.keys(this._groupFieldMap)) {
+        const s = this.getGroupFieldNames(r);
+        if (s != null && s.some((o) => t.some((i) => this._matchFieldOrNested(i, o)))) return r;
+      }
+  }
+  /**
+   * @description 获取指定分组下的字段名列表，默认会获取该分组下的所有字段
+   * @param {string} key - 分组 key
+   * @param {boolean} 是否包含子分组字段
+   * @returns {string[]} 字段名列表
+   */
+  getGroupFieldNames(e, t = !0) {
+    return this._getGroupFieldNamesWithVisited(e, t, /* @__PURE__ */ new Set());
+  }
+  /**
+   * @description 获取指定分组字段名（带防环保护），避免异常 schema 导致递归栈溢出
+   */
+  _getGroupFieldNamesWithVisited(e, t, r) {
+    if (r.has(e))
+      return [];
+    r.add(e);
+    const s = this._groupFieldMap[e] ?? [];
+    if (!t)
+      return [...s];
+    const o = [...s], i = this._groupChildrenMap[e] ?? [];
+    for (const a of i)
+      o.push(...this._getGroupFieldNamesWithVisited(a, !0, r));
+    return r.delete(e), Array.from(new Set(o));
+  }
+  /**
+   * @description 获取字段所属分组 key，支持数组/对象嵌套路径回溯到 schema 字段。
+   * @param {string} fieldName 字段名
+   * @returns {string | undefined} 所属分组 key
+   */
+  _getFieldGroupKey(e) {
+    const t = this._fieldToGroupKey[e];
+    if (t) return t;
+    for (const r of Object.keys(this._fieldToGroupKey))
+      if (this._matchFieldOrNested(e, r))
+        return this._fieldToGroupKey[r];
+  }
+  /**
+   * @description 判断字段所属分组或祖先分组是否仍处于隐藏状态，用于避免字段显示时绕过仍隐藏的父级分组。
+   * @param {string} fieldName 字段名
+   * @returns {boolean} 是否存在隐藏的所属分组或祖先分组
+   */
+  _hasHiddenGroup(e) {
+    let t = this._getFieldGroupKey(e);
+    for (; t; ) {
+      if (this.hiddenGroupKeys.has(t)) return !0;
+      t = this._groupParentMap[t];
+    }
+    return !1;
+  }
+  /**
+   * @description 设置字段隐藏状态
+   * @param {string[]} fieldNames 字段名列表
+   * @param {boolean} hidden 是否隐藏
+   */
+  _setFieldsHidden(e, t) {
+    for (const r of e)
+      t ? this.hiddenFieldNames.add(r) : this._hasHiddenGroup(r) || this.hiddenFieldNames.delete(r);
+  }
+  /**
+   * @description 生成清空后的值：数组和对象保留结构，叶子值按默认值回填，否则置为 undefined
+   * @param {unknown} value 原始值
+   * @param {unknown} defaultValue 默认值
+   * @returns {unknown} 清空后的值
+   */
+  _clearValueKeepStructure(e, t) {
+    if (Array.isArray(e)) {
+      const r = Array.isArray(t) ? t : [];
+      return e.map((s, o) => this._clearValueKeepStructure(s, r[o] ?? r[0]));
+    }
+    if (p(e)) {
+      const r = p(t) ? t : {};
+      return Object.fromEntries(
+        Object.keys(e).map((s) => [
+          s,
+          this._clearValueKeepStructure(v(e, s), v(r, s))
+        ])
+      );
+    }
+    if (e === void 0 && (Array.isArray(t) || p(t)))
+      return this._clearValueKeepStructure(t, t);
+    if (t !== void 0 && !Array.isArray(t) && !p(t))
+      return V(t);
+  }
+  /**
+   * @description 清空隐藏字段的值、校验状态和虚拟错误缓存，数组和对象保留结构
+   * @param {string[]} fieldNames 字段名列表
+   */
+  _clearHiddenFieldValues(e) {
+    var t, r, s, o, i, a, l;
+    if (e.length)
+      for (const h of e) {
+        const d = v((t = this.form) == null ? void 0 : t.values, h), F = this._fieldSchemaMap[h] ? k(this._fieldSchemaMap[h]) : void 0;
+        (s = (r = this.form) == null ? void 0 : r.setFieldValue) == null || s.call(r, h, this._clearValueKeepStructure(d, F), !1), (i = (o = this.form) == null ? void 0 : o.setFieldError) == null || i.call(o, h, void 0), (l = (a = this.form) == null ? void 0 : a.setFieldTouched) == null || l.call(a, h, !1), this.errorCacheMap.delete(h);
+      }
+  }
+  /**
+   * @description 卸载分组表单时恢复初始schema
+   */
+  get arrayAction() {
+    var o;
+    const e = super.arrayAction;
+    let t = ((o = this.resetSignal) == null ? void 0 : o.value) ?? 0;
+    const r = () => {
+      var a;
+      if (!this.navAnchorProps.show) return;
+      const i = ((a = this.resetSignal) == null ? void 0 : a.value) ?? 0;
+      if (i !== t) {
+        t = i, this.syncNavErrorCountsFromForm();
+        return;
+      }
+      this._hasValidated && this.syncNavErrorCountsFromForm();
+    }, s = (i) => y(i);
+    return {
+      get: (i) => e.get(s(i)),
+      push: (i, a) => {
+        e.push(s(i), a), r();
+      },
+      remove: (i, a) => {
+        e.remove(s(i), a), r();
+      },
+      replace: (i, a) => {
+        e.replace(s(i), a), r();
+      },
+      update: (i, a, l) => {
+        e.update(s(i), a, l), r();
+      },
+      insert: (i, a, l) => {
+        e.insert(s(i), a, l), r();
+      },
+      prepend: (i, a) => {
+        e.prepend(s(i), a), r();
+      },
+      move: (i, a, l) => {
+        e.move(s(i), a, l), r();
+      },
+      swap: (i, a, l) => {
+        e.swap(s(i), a, l), r();
+      },
+      /**
+       * @description 获取嵌套数组路径下的操作器
+       * @param parentPath 父数组路径，或完整路径（仅传 path）
+       * @param index 父数组索引
+       * @param childField 子数组字段名
+       */
+      at: (i, a, l) => {
+        const h = e.at(H(s(i), a, l));
+        return this._wrapNestedArrayHandle(h, r);
+      }
+    };
+  }
+  unmount() {
+    this._applyGroupSchema(_(this._initialGroupSchema)), this.hiddenGroupKeys.clear(), this.hiddenFieldNames.clear(), this.virtual && (this._clearAllCachedErrors(), this._hasValidated = !1), this._clearNavErrorCounts(), super.unmount();
+  }
+}
+export {
+  L as GroupFormApi
+};