@mx-sose-front/mx-sose-graph 1.0.0

package/src/utils/containers.ts

@@ -0,0 +1,910 @@
+// 画布容器/层级/命中等通用工具
+import type { Shape } from '../types'
+import {
+  allowAsParent,
+  ensureCompartmentAfterParentMoved,
+  getCompartmentZones,
+  isCompartment,
+} from '../utils/compartment'
+import { getBounds } from './geom'
+import { canNest } from './policy';
+import { useGraphStore } from '../store/graphStore'
+/** 统一的几何矩形类型 */
+export type Rect = { x: number; y: number; width: number; height: number }
+/** 更新回调签名（ */
+export type Updater = (id: string, updates: Partial<Shape>) => void
+
+/** 安全读取 zIndex（未设置时为 0）*/
+const getZ = (s?: Shape) =>
+  (typeof s?.style?.zIndex === 'number' ? (s!.style!.zIndex as number) : 0)
+
+/** 把 bounds-like 转为 Rect */
+const toRect = (b: any): Rect => ({
+  x: b?.x ?? 0,
+  y: b?.y ?? 0,
+  width: b?.width ?? 0,
+  height: b?.height ?? 0,
+})
+/** 取得 shape 的矩形（兼容不同 shape 的 bounds 结构） */
+const rectOf = (s: Shape): Rect => toRect(getBounds(s))
+//  布局/内容区工具
+
+/** 读取内边距（padding）。支持 style.padding 为数字；默认 20 */
+export const readPadding = (s?: Shape) => {
+  const n = typeof s?.style?.padding === 'number' ? (s!.style!.padding as number) : 20
+  // 如果是“普通容器”（非隔间），强制 top = 70，其它方向仍然用 n
+  if (s && !isCompartment(s)) {
+    return {
+      top: 75,    // 固定预留 70px 的上内边距
+      right: n,
+      bottom: n,
+      left: n,
+    }
+  }
+
+  // 如果是隔间 / 或者没有传 s 就用原来的逻辑
+  return {
+    top: n,
+    right: n,
+    bottom: n,
+    left: n,
+  }
+}
+
+/** 获取父容器的“内容区”（内边距之后的可放置区域） */
+export const getContentRect = (parent: Shape) => {
+  const pad = readPadding(parent)
+  const px = parent.bounds?.x ?? 0
+  const py = parent.bounds?.y ?? 0
+  const pw = parent.bounds?.width ?? 0
+  const ph = parent.bounds?.height ?? 0
+  return {
+    left: px + pad.left,
+    top: py + pad.top,
+    right: px + pw - pad.right,
+    bottom: py + ph - pad.bottom,
+  }
+}
+
+// 关系/后代
+
+/** 判断 childId 是否是 ancestorId 的后代 */
+export const isDescendant = (shapes: Shape[], childId: string, ancestorId: string) => {
+  let p = shapes.find(s => s.id === childId)?.parenShapeId ?? null
+  while (p) {
+    if (p === ancestorId) return true
+    p = shapes.find(s => s.id === p)?.parenShapeId ?? null
+  }
+  return false
+}
+
+/** 收集整棵子树（仅 id） */
+export const collectDescendantIds = (shapes: Shape[], parentId: string): string[] => {
+  const out: string[] = []
+  const stack = [parentId]
+  while (stack.length) {
+    const id = stack.pop()!
+    const kids = shapes.filter(s => s.parenShapeId === id)
+    kids.forEach(k => { out.push(k.id); stack.push(k.id) })
+  }
+  return out
+}
+/** 计算 child 与 region 的相交面积（region 是一个 {left,top,right,bottom}） */
+export const intersectArea = (
+  child: Rect,
+  region: { left: number; top: number; right: number; bottom: number }
+) => {
+  const ix = Math.max(child.x, region.left)
+  const iy = Math.max(child.y, region.top)
+  const ax = Math.min(child.x + child.width, region.right)
+  const ay = Math.min(child.y + child.height, region.bottom)
+  const w = Math.max(0, ax - ix)
+  const h = Math.max(0, ay - iy)
+  return w * h
+}
+
+/** 计算子矩形在父“内容区”内的覆盖率（0~1） */
+export const coverageIn = (child: Rect, parent: Shape) => {
+  const pc = getContentRect(parent)
+  const overlap = intersectArea(child, pc)
+  const childArea = Math.max(1, child.width * child.height)
+  return overlap / childArea
+}
+
+/** 把 child 夹回 parent 的内容区（不改变尺寸） */
+export const clampChildIntoParent = (
+  parent: Shape,
+  child: Rect,
+  alignLarge: 'center' | 'start' | 'end' = 'center'
+): Rect => {
+  const c = getContentRect(parent)
+  const cw = Math.max(0, c.right - c.left)
+  const ch = Math.max(0, c.bottom - c.top)
+
+  let nx: number
+  let ny: number
+
+  // 水平方向
+  if (child.width <= cw) {
+    nx = Math.min(Math.max(child.x, c.left), c.right - child.width)
+  } else {
+    if (alignLarge === 'center') nx = c.left + (cw - child.width) / 2
+    else if (alignLarge === 'start') nx = c.left
+    else nx = c.right - child.width
+  }
+
+  // 垂直方向
+  if (child.height <= ch) {
+    ny = Math.min(Math.max(child.y, c.top), c.bottom - child.height)
+  } else {
+    if (alignLarge === 'center') ny = c.top + (ch - child.height) / 2
+    else if (alignLarge === 'start') ny = c.top
+    else ny = c.bottom - child.height
+  }
+
+  return { x: nx, y: ny, width: child.width, height: child.height }
+}
+
+/**
+ * 让 parent “刚好包下所有直接子 + padding”
+ * - 仅增大，不缩小；必要时向左/上扩张（同时移动 x/y）
+ * - 采用 floor-ε 抑制抖动：避免 0.x 的毛刺每次都向上取整导致“慢慢变大”
+ */
+export const ensureParentFitsChildren = (
+  shapes: Shape[],
+  parent: Shape,
+  updateShape: Updater,
+  overrideRects?: Record<string, Rect>
+) => {
+  const kids = shapes.filter(
+    s => s.parenShapeId === parent.id && !isPinShape(s)
+  )
+  if (kids.length === 0) return
+
+  const pad = readPadding(parent)
+  const EPS = 1.25
+
+  let left = Infinity, top = Infinity
+  let right = -Infinity, bot = -Infinity
+  for (const k of kids) {
+    const r = overrideRects?.[k.id] ?? rectOf(k)
+    left = Math.min(left, r.x)
+    top = Math.min(top, r.y)
+    right = Math.max(right, r.x + r.width)
+    bot = Math.max(bot, r.y + r.height)
+  }
+
+  const px = parent.bounds.x ?? 0
+  const py = parent.bounds.y ?? 0
+  const pw = parent.bounds.width ?? 0
+  const ph = parent.bounds.height ?? 0
+
+  // 当前内容区
+  const cL = px + pad.left
+  const cT = py + pad.top
+  const cR = px + pw - pad.right
+  const cB = py + ph - pad.bottom
+
+  // 需要增长（四向，未截断）
+  const dL = Math.max(0, cL - left)
+  const dT = Math.max(0, cT - top)
+  const dR = Math.max(0, right - cR)
+  const dB = Math.max(0, bot - cB)
+
+  if (dL < EPS && dT < EPS && dR < EPS && dB < EPS) return
+
+  const down = (v: number, eps = EPS) => Math.max(0, Math.floor(v - eps))
+  let growL = down(dL)
+  let growT = down(dT)
+  const growR = down(dR)
+  const growB = down(dB)
+
+  // === 关键：左/上不允许越过 (0,0)，截断扩量 ===
+  // 位置候选（未截断）
+  let nx = px - growL
+  let ny = py - growT
+
+  // 如果会越界，就把扩量截断到恰好贴 0
+  if (nx < 0) {
+    growL = Math.min(growL, px)   // 最多把 x 拉到 0
+    nx = px - growL               // 重新计算截断后的 nx
+  }
+  if (ny < 0) {
+    growT = Math.min(growT, py)   // 最多把 y 拉到 0
+    ny = py - growT
+  }
+
+  // 宽/高按对称扩：左右/上下扩量之和
+  const needW = Math.max(pw, pw + growL + growR)
+  const needH = Math.max(ph, ph + growT + growB)
+
+  // 最终再夹一次，确保不越 0（双保险）
+  nx = Math.max(0, nx)
+  ny = Math.max(0, ny)
+
+  if (nx !== px || ny !== py || needW !== pw || needH !== ph) {
+    const snap = (v: number) => Math.round(v)
+    updateShape(parent.id, {
+      bounds: { x: snap(nx), y: snap(ny), width: snap(needW), height: snap(needH) }
+    })
+  }
+}
+/** 从当前父开始，逐层向上做 ensureParentFitsChildren */
+export const bubbleAutoFitUp = (
+  shapes: Shape[],
+  startParentId: string | null | undefined,
+  updateShape: Updater
+) => {
+  let pid = startParentId ?? null
+  while (pid) {
+    const p = shapes.find(s => s.id === pid)
+    if (!p) break
+    ensureParentFitsChildren(shapes, p, updateShape)
+    pid = p.parenShapeId ?? null
+  }
+}
+/**
+ * 挂接：把 child 挂到 parent 下，同时把“整棵子树的 zIndex”平移为 parent.z + 1（相对层级不变）
+ * - 注意：这里只负责数据层，不做归一化（normalizeZOrder 建议在调用方统一执行）
+ */
+export const attachToParent = (
+  shapes: Shape[],
+  childId: string,
+  parentId: string,
+  updateShape: Updater
+) => {
+  const child = shapes.find(s => s.id === childId)
+  const parent = shapes.find(s => s.id === parentId)
+  if (!child || !parent) return
+  if (isDescendant(shapes, parentId, childId)) return // 防环
+
+  // 目标：child 的 z = parent.z + 1，并平移整棵子树
+  const parentZ = getZ(parent)
+  const childZ = getZ(child)
+  const wantChildZ = parentZ + 1
+  const delta = wantChildZ - childZ
+
+  const subtreeIds = [childId, ...collectDescendantIds(shapes, childId)]
+  if (delta !== 0) {
+    for (const id of subtreeIds) {
+      const n = shapes.find(s => s.id === id)!
+      const nz = getZ(n) + delta
+      updateShape(id, { style: { ...(n.style ?? {}), zIndex: nz } as any })
+    }
+  }
+
+  // 最后落盘父子关系（避免中途触发 watch 干扰）
+  updateShape(childId, { parenShapeId: parentId, diagramId: parent.diagramId })
+}
+
+/** 脱离父子关系（仅清 parenShapeId） */
+export const detachFromParent = (
+  shapes: Shape[],
+  childId: string,
+  updateShape: Updater
+) => {
+  const child = shapes.find(s => s.id === childId)
+  if (!child || !child.parenShapeId) return
+  updateShape(childId, { parenShapeId: undefined })
+}
+
+/**
+ * （旧）自某节点起，强制“子 = 父+1”
+ */
+export const cascadeZIndexFrom = (
+  shapes: Shape[],
+  startId: string,
+  updateShape: Updater
+) => {
+  const start = shapes.find(s => s.id === startId); if (!start) return
+  const queue: Shape[] = [start]
+
+  while (queue.length) {
+    const parent = queue.shift()!
+    const pz = getZ(parent)
+    const kids = shapes.filter(s => s.parenShapeId === parent.id)
+
+    kids.forEach(k => {
+      const target = pz + 1
+      if (getZ(k) !== target) {
+        updateShape(k.id, { style: { ...(k.style ?? {}), zIndex: target } as any })
+      }
+      queue.push(k)
+    })
+  }
+}
+
+/** 计算“直接子元素”的联合包围盒 */
+export const childrenUnionBounds = (
+  shapes: Shape[],
+  parentId: string,
+  overrideRects?: Record<string, Rect>
+) => {
+ const kids = shapes.filter(
+    s => s.parenShapeId === parentId && !isPinShape(s)
+  )
+  if (!kids.length) return null
+  let L = Infinity, T = Infinity, R = -Infinity, B = -Infinity
+  for (const k of kids) {
+    const r = overrideRects?.[k.id] ?? getBounds(k)
+    L = Math.min(L, r.x)
+    T = Math.min(T, r.y)
+    R = Math.max(R, r.x + r.width)
+    B = Math.max(B, r.y + r.height)
+  }
+  return { L, T, R, B }
+}
+
+/**
+ * 在“缩放父元素”手势中，约束 next：content(next) 覆盖 childrenUnion ± gap
+ * - dir 决定修正哪条边：左/上需要改 x/y 和宽高；右/下只改宽高
+ */
+export const clampParentRectToChildrenGap = (
+  shapes: Shape[],
+  parent: Shape,
+  next: Rect,
+  dir: 'nw' | 'ne' | 'sw' | 'se',
+  gap = 0,
+  minW = 1,
+  minH = 1,
+  overrideRects?: Record<string, Rect>
+): Rect => {
+  const union = childrenUnionBounds(shapes, parent.id, overrideRects)
+  if (!union) return next
+
+  const pad = readPadding(parent)
+  // 目标内容区
+  const reqL = union.L - gap
+  const reqT = union.T - gap
+  const reqR = union.R + gap
+  const reqB = union.B + gap
+
+  // 现状内容区
+  let cL = next.x + pad.left
+  let cT = next.y + pad.top
+  let cR = next.x + next.width - pad.right
+  let cB = next.y + next.height - pad.bottom
+
+  // 左侧
+  if ((dir === 'nw' || dir === 'sw') && cL > reqL) {
+    const newX = reqL - pad.left
+    next = { ...next, x: newX, width: Math.max((next.x + next.width) - newX, minW) }
+  }
+  // 上侧
+  if ((dir === 'nw' || dir === 'ne') && cT > reqT) {
+    const newY = reqT - pad.top
+    next = { ...next, y: newY, height: Math.max((next.y + next.height) - newY, minH) }
+  }
+  // 右侧
+  cR = next.x + next.width - pad.right
+  if ((dir === 'ne' || dir === 'se') && cR < reqR) {
+    const newW = (reqR + pad.right) - next.x
+    next = { ...next, width: Math.max(newW, minW) }
+  }
+  // 下侧
+  cB = next.y + next.height - pad.bottom
+  if ((dir === 'sw' || dir === 'se') && cB < reqB) {
+    const newH = (reqB + pad.bottom) - next.y
+    next = { ...next, height: Math.max(newH, minH) }
+  }
+  return next
+}
+
+/**
+ * 直接把 parent 扩到“刚好 ≥ 子并集 + gap”（对称扩容）
+ * - 注意：这是“立即扩父”的版本，通常用于非交互状态下的矫正或强制收口
+ */
+export const ensureParentCoversChildrenWithGap = (
+  shapes: Shape[],
+  parent: Shape,
+  updateShape: Updater,
+  gap = 0,
+  overrideRects?: Record<string, Rect>
+) => {
+  const union = childrenUnionBounds(shapes, parent.id, overrideRects)
+  if (!union) return
+
+  const pad = readPadding(parent)
+  const px = parent.bounds.x ?? 0
+  const py = parent.bounds.y ?? 0
+  const pw = parent.bounds.width ?? 0
+  const ph = parent.bounds.height ?? 0
+
+  const reqL = union.L - gap
+  const reqT = union.T - gap
+  const reqR = union.R + gap
+  const reqB = union.B + gap
+
+  const cL = px + pad.left
+  const cT = py + pad.top
+  const cR = px + pw - pad.right
+  const cB = py + ph - pad.bottom
+
+  const needL = Math.max(0, reqL - cL)
+  const needT = Math.max(0, reqT - cT)
+  const needR = Math.max(0, reqR - cR)
+  const needB = Math.max(0, reqB - cB)
+  if (needL <= 0 && needT <= 0 && needR <= 0 && needB <= 0) return
+
+  const nx = px - Math.ceil(needL)
+  const ny = py - Math.ceil(needT)
+  const nw = Math.max(pw, pw + Math.ceil(needL) + Math.ceil(needR))
+  const nh = Math.max(ph, ph + Math.ceil(needT) + Math.ceil(needB))
+  const snap = (v: number) => Math.round(v)
+  updateShape(parent.id, { bounds: { x: snap(nx), y: snap(ny), width: snap(nw), height: snap(nh) } })
+}
+
+/** 从当前父起，逐层把所有祖先都扩到“刚好 ≥ 子并集 + gap” */
+export const bubbleCoverWithGapUp = (
+  shapes: Shape[],
+  startParentId: string | null | undefined,
+  updateShape: Updater,
+  gap = 0
+) => {
+  let pid = startParentId ?? null
+  while (pid) {
+    const p = shapes.find(s => s.id === pid)
+    if (!p) break
+    ensureParentCoversChildrenWithGap(shapes, p, updateShape, gap)
+    pid = p.parenShapeId ?? null
+  }
+}
+
+/** 轻微越界容忍（px） */
+export const CONTENT_EPS = 3
+
+/** 计算“最终矩形”（ghost 优先，兜底实体 bounds） */
+export const finalRectOf = (ghost: Record<string, Rect>, s: Shape): Rect => {
+  const g = ghost[s.id]
+  return g ? g : {
+    x: s.bounds?.x ?? 0,
+    y: s.bounds?.y ?? 0,
+    width: s.bounds?.width ?? 0,
+    height: s.bounds?.height ?? 0,
+  }
+}
+/** 计算 childRect 相对 parent 内容区的“最大越界量”（>0 表示越界） */
+export const overflowIn = (parent: Shape, childRect: Rect) => {
+  const c = getContentRect(parent)
+  const overL = c.left - childRect.x
+  const overT = c.top - childRect.y
+  const overR = (childRect.x + childRect.width) - c.right
+  const overB = (childRect.y + childRect.height) - c.bottom
+  return Math.max(0, overL, overT, overR, overB)
+}
+
+/** 轻微越界 → 夹回；显著越界 → 扩父（并向上冒泡） */
+export const clampOrGrowIntoParent = (
+  parent: Shape,
+  childRect: Rect,
+  shapes: Shape[],
+  updateShape: Updater,
+  childId: string,
+  eps = CONTENT_EPS
+) => {
+  const overflow = overflowIn(parent, childRect)
+  if (overflow <= eps) {
+    const clamped = clampChildIntoParent(parent, childRect)
+    updateShape(childId, { bounds: clamped })
+  } else {
+    ensureParentFitsChildren(shapes, parent, updateShape, { [childId]: childRect })
+    bubbleAutoFitUp(shapes, parent.parenShapeId, updateShape)
+  }
+}
+
+/** 组拖辅助：该节点是否有“正在拖动”的祖先（有则禁止 reparent） */
+export const hasDraggedAncestor = (
+  shapes: Shape[],
+  sid: string,
+  draggingSet: Set<string>
+) => {
+  let pid = shapes.find(s => s.id === sid)?.parenShapeId ?? null
+  while (pid) {
+    if (draggingSet.has(pid)) return true
+    pid = shapes.find(s => s.id === pid)?.parenShapeId ?? null
+  }
+  return false
+}
+/**
+ * “拖拽结束后的归属策略”：封装了保留原父/候选父/夹回/扩父的完整流程
+ * - keptParent 优先：只要仍在原父内部，就不找候选父
+ * - 不在原父：找候选父（exclude = 正在拖的 id）
+ * - 组拖后代：禁止 reparent；只夹回/必要才扩父
+ * - 返回：是否发生 reparent（可用于统计/调试）
+ */
+const DETACH_THRESHOLD = 0.4   // 覆盖率低于该阈值就脱离，不再扩父
+/** 哪些图元一旦挂上父，就不允许脱离父（拖动时只能让父扩容） */
+export const isStickyChild = (s: Shape): boolean => {
+  if (!Object.prototype.hasOwnProperty.call(s, 'isMovableComparents')) {
+    return false
+  }
+  // 只有为 true 时才视为不能脱离
+  return (s as any).isMovableComparents == true
+}
+export const resolveParentAfterDrag = (
+  shapes: Shape[],
+  s: Shape,
+  finalRect: Rect,
+  draggingIds: string[],
+  diagramId: string | null | undefined,
+  updateShape: (id: string, updates: Partial<Shape>) => void,
+  _minCoverage = 0.5,
+  hoverCandidateId?: string | null,
+  options?: {
+    /** 当发生“换父（嵌套）”时，是否只更新父子关系与位置，不立刻扩父，留给外部在接口成功后再扩父 */
+    deferExpandOnReparent?: boolean
+  }
+): boolean => {
+  const byId = (id?: string | null) => (id ? shapes.find(x => x.id === id) || null : null)
+  const draggingSet = new Set(draggingIds)
+  // 本次拖动的子图元是否是“黏在父上的类型”
+  const stickyToParent = isStickyChild(s)
+  // 配置：是否在“换父”时只改父子关系 / 坐标，不立刻扩父
+  const deferExpandOnReparent = !!options?.deferExpandOnReparent
+  // ===== 组拖保护：若该节点存在“正在拖动的祖先”，禁止换父 =====
+  if (hasDraggedAncestor(shapes, s.id, draggingSet)) {
+    const curParent = byId(s.parenShapeId)
+    if (!curParent) { updateShape(s.id, { bounds: finalRect }); return false }
+    //  子就地落位（不回弹/不clamp，避免跳动）
+    updateShape(s.id, { bounds: finalRect })
+    if (isCompartment(curParent)) {
+      // 如果父是隔间，拖动时父移动了，需要刷新隔间内部布局
+      ensureCompartmentAfterParentMoved(shapes, curParent, updateShape) // 新增调用
+    } else {
+      // 非隔间：维持原有逻辑——只在“放不下”时扩父 + 冒泡 + clamp
+      if (overflowIn(curParent, finalRect) > CONTENT_EPS) {
+        ensureParentFitsChildren(shapes, curParent, updateShape, { [s.id]: finalRect })
+        bubbleAutoFitUp(shapes, curParent.parenShapeId, updateShape)
+        // 扩父完还轻微越界，再轻夹一次（尽量少动）
+        const pNow = byId(curParent.id)!
+        if (overflowIn(pNow, finalRect) > CONTENT_EPS) {
+          const clamped = clampChildIntoParent(pNow, finalRect)
+          if (clamped.x !== finalRect.x || clamped.y !== finalRect.y) {
+            updateShape(s.id, { bounds: clamped })
+          }
+        }
+      }
+    }
+    return false
+  }
+  // 当前“原父”
+  const origParent = byId(s.parenShapeId)
+  // ===== hover 判定：只要合法就用 hover，完全“指哪选哪” =====
+  const isValidParent = (p: Shape | null): p is Shape => {
+    if (!p) return false
+    if (p.diagramId !== (diagramId || s.diagramId)) return false
+    if (p.id === s.id) return false
+    if (draggingSet.has(p.id)) return false
+    if (isDescendant(shapes, p.id, s.id)) return false // 防把后代当父
+
+    // sticky 类型一旦有了 origParent，只允许这个父作为候选父
+    if (stickyToParent && origParent && p.id !== origParent.id) {
+      return false
+    }
+
+    // 在隔间里的元素禁止当父（直到脱离隔间）
+    if (allowAsParent) {
+      if (!allowAsParent(shapes, p)) return false
+    } else {
+      // 或者直接内联一版最小实现：
+      let q = shapes.find(x => x.id === p.parenShapeId) || null
+      while (q) {
+        if (isCompartment(q)) return false
+        const parentId = q.parenShapeId
+        q = parentId ? shapes.find(x => x.id === parentId) || null : null
+      }
+    }
+    // if (!canNest(s, p, shapes)) return false
+    return true
+  }
+  // 选择目标父（优先 hover，其次原父，最后可能脱离）
+  const hover = byId(hoverCandidateId)
+  // const origParent = byId(s.parenShapeId)
+
+  // ===== Pin 硬性保护：永不置空父（不走后续脱离/覆盖率判断） =====
+  const __isPin = s.shapeType === 'pin' || String((s as any).shapeKey || '').toLowerCase().includes('pin')
+  if (__isPin) {
+    const pinTarget = isValidParent(hover) ? hover : origParent
+    if (pinTarget) {
+      updateShape(s.id, { parenShapeId: pinTarget.id, diagramId: pinTarget.diagramId, bounds: finalRect })
+    } else {
+      // 没有候选父且也没有原父：仅落位，不触碰 parenShapeId
+      updateShape(s.id, { bounds: finalRect })
+    }
+    return false
+  }
+
+  // ===== 目标父选择 =====
+  let target: Shape | null = null// 最终目标父
+  let reparent = false    // 是否发生“换父”（包括挂到 null 上）
+
+  if (isValidParent(hover)) {
+    target = hover
+    reparent = hover.id !== s.parenShapeId
+  } else {
+    // 没有 hover 容器时，不再盲目回退原父；
+    //    若覆盖率低于阈值，直接脱离
+    if (origParent) {
+      const cover = coverageIn(finalRect, origParent)
+      if (!stickyToParent && cover < DETACH_THRESHOLD) {
+        // —— 脱离：不扩父
+        updateShape(s.id, { parenShapeId: undefined, bounds: finalRect })
+        return true
+      }
+      // 覆盖仍可接受 → 继续把原父作为 target（未换父）
+      target = origParent
+      reparent = false
+    } else {
+      target = null
+    }
+  }
+
+  // ===== 无目标父：保持无父，仅落位（Pin 兜底：保留原父） =====
+  if (!target) {
+    const isPin = s.shapeType === 'pin' || String((s as any).shapeKey || '').toLowerCase().includes('pin')
+    if (isPin && origParent) {
+      // Pin 没有 hover 候选时，强制保留原父，避免 parenShapeId 被清空
+      updateShape(s.id, { parenShapeId: origParent.id, bounds: finalRect })
+      return false
+    }
+    if (s.parenShapeId) {
+      updateShape(s.id, { parenShapeId: undefined })
+    }
+    updateShape(s.id, { bounds: finalRect })
+    return false
+  }
+  let placeRect = finalRect
+  // ===== 有目标父：先落位 finalRect；仅当放不下时才扩父（四向对称），避免位移 =====
+  if (reparent) {
+    // 只更新父子关系 + 位置
+    updateShape(s.id, {
+      parenShapeId: target.id,
+      diagramId: target.diagramId,
+      bounds: placeRect,
+    })
+    // updateShape(s.id, { parenShapeId: target.id, diagramId: target.diagramId, bounds: placeRect })
+    // （ zIndex 平移保持不变）
+    const parentZ = (typeof target.style?.zIndex === 'number') ? (target.style!.zIndex as number) : 0
+    const childZ = (typeof s.style?.zIndex === 'number') ? (s.style!.zIndex as number) : 0
+    const delta = (parentZ + 1) - childZ
+    if (delta !== 0) {
+      const subtree = [s.id, ...collectDescendantIds(shapes, s.id)]
+      for (const id of subtree) {
+        const node = shapes.find(x => x.id === id)!
+        const nz = ((typeof node.style?.zIndex === 'number') ? node.style!.zIndex as number : 0) + delta
+        updateShape(id, { style: { ...(node.style ?? {}), zIndex: nz } as any })
+      }
+    }
+    // 若不需要延迟扩父，仍可在这里同步扩父（兼容老行为）
+    if (!deferExpandOnReparent) {
+      expandParentToFitChildBounds(shapes, target, s.id, placeRect, updateShape)
+    }
+    return true
+  }
+  // 先更新位置
+  updateShape(s.id, { bounds: placeRect })
+  // ===== 未换父：只是父内部移动 —— 这类通常不走“嵌套接口”，可以继续即时扩父 =====
+  expandParentToFitChildBounds(shapes, target, s.id, placeRect, updateShape)
+
+  return false
+}
+const pointInRect = (pt: { x: number; y: number }, r: Rect, margin = 0) =>
+  pt.x >= r.x + margin &&
+  pt.x <= r.x + r.width - margin &&
+  pt.y >= r.y + margin &&
+  pt.y <= r.y + r.height - margin
+
+const depthOf = (shapes: Shape[], id: string): number => {
+  let d = 0
+  let p = shapes.find(s => s.id === id)?.parenShapeId ?? null
+  while (p) { d++; p = shapes.find(s => s.id === p)?.parenShapeId ?? null }
+  return d
+}
+
+/**
+ * 只返回“视觉上最上面”的命中容器：
+ * - 命中条件：指针在 shape.bounds 内（不强制内容区）
+ * - 先找候选里 zIndex 的最大值，只在这个 z 层里挑一个
+ * - 同 z 打平：更深（层级大）> 内容区更小 > id 稳定
+ */
+export const pickContainerByPointerTopmost = (
+  shapes: Shape[],
+  pointer: { x: number; y: number },
+  draggingId: string,
+  diagramId: string,
+  excludeIds: string[] = [],
+  boundsMargin = 0// 负值略放宽，边缘更容易点中
+): Shape | null => {
+  const ex = new Set(excludeIds)
+
+  // 1) 收集候选（在同一图里、不是自己/自己的后代/排除集，且指针在其 bounds 内）
+  const candidates = shapes.filter(s => {
+    if (s.diagramId !== diagramId) return false
+    if (s.shapeType !== 'shape') return false
+    if (s.id === draggingId) return false
+    if (ex.has(s.id)) return false
+    if (isDescendant(shapes, s.id, draggingId)) return false
+    const b = getBounds(s) as Rect
+    return pointInRect(pointer, b, boundsMargin)
+  })
+  if (!candidates.length) return null
+
+  // 2) 只看“最上层”那一批（z 最大）
+  const getZ = (s: Shape) => (typeof s.style?.zIndex === 'number' ? s.style!.zIndex as number : 0)
+  let maxZ = -Infinity
+  for (const s of candidates) maxZ = Math.max(maxZ, getZ(s))
+  const topLayer = candidates.filter(s => getZ(s) === maxZ)
+
+  if (topLayer.length === 1) return topLayer[0]
+
+  // 3) 同 z 打平：更深层级 > 内容区更小 > id 稳定
+  let best = topLayer[0]
+  let bestDepth = depthOf(shapes, best.id)
+  let bestArea = (() => {
+    const c = getContentRect(best); return Math.max(1, (c.right - c.left) * (c.bottom - c.top))
+  })()
+  for (let i = 1; i < topLayer.length; i++) {
+    const s = topLayer[i]
+    const d = depthOf(shapes, s.id)
+    const c = getContentRect(s)
+    const area = Math.max(1, (c.right - c.left) * (c.bottom - c.top))
+    if (d > bestDepth || (d === bestDepth && area < bestArea) || (d === bestDepth && area === bestArea && s.id < best.id)) {
+      best = s; bestDepth = d; bestArea = area
+    }
+  }
+  return best
+}
+//是否命中元素
+export function hitContainerAtPoint(
+  shapes: Shape[],
+  pointer: { x: number; y: number },
+  diagramId: string,
+  excludeIds: string[] = []
+) {
+  // 拖“新建图元”时没有真实 id，用占位即可
+  return pickContainerByPointerTopmost(
+    shapes,
+    pointer,
+    '__NEW__',          // 非自身/非后代的过滤占位
+    diagramId,
+    excludeIds,
+    0
+  )
+}
+/**
+ * 根据某个子元素的最终矩形，自动扩容父元素，并在必要时把子元素夹回父元素内部。
+ * 注意：
+ *  - 这个方法可以在拖拽逻辑之外单独调用（比如：后端嵌套接口成功后，再调用它来扩父）
+ *  - 仅依赖当前 shapes + parent + childRect，不改变父子关系
+ */
+export const expandParentToFitChildBounds = (
+  shapes: Shape[],
+  parent: Shape,
+  childId: string,
+  childRect: Rect,
+  updateShape: (id: string, updates: Partial<Shape>) => void,
+): { expanded: boolean; affectedIds: string[] } => {
+  // child 是 pin 时，永远不扩父，直接返回
+  const childShape = shapes.find(s => s.id === childId) || null
+  if (isPinShape(childShape)) {
+    return { expanded: false, affectedIds: [] }
+  }
+
+  let expanded = false
+  const affected = new Set<string>()
+
+  // 子自己一定是受影响对象之一
+  affected.add(childId)
+  affected.add(parent.id)
+  // 当前使用的子矩形（后面 clamp 时会更新它）
+  let placeRect = childRect
+
+  // ================== 1. 若父是隔间（compartment），先处理顶部 header / 说明区 ==================
+  if (isCompartment(parent)) {
+    const INSET = 6          // 子内容与“childrenTop”之间预留的安全内边距
+    const DIVIDER = 1        // 标题与内容区之间的分隔线高度
+    const PAD_TOP = 6        // 内容区顶部 padding
+    const MARGIN = 2         // 额外的冗余间距，避免贴得太死
+    const EPS = 0.5
+    const CANVAS_TOP = 0     // 画布上边界（如果有全局 padding，可以在这里留出来）
+
+    const pb = parent.bounds!
+    const pX = Number(pb.x ?? 0)
+    const pY = Number(pb.y ?? 0)
+    const pW = Number(pb.width ?? 0)
+    const pH = Number(pb.height ?? 0)
+
+    // 若外面有 getCompartmentZones，则优先用测量得到的 childrenArea
+    const zones =
+      typeof getCompartmentZones === 'function'
+        ? getCompartmentZones(parent.id)
+        : null
+
+    let zonalTop: number | null = null
+    if (zones?.childrenArea) {
+      const ca = zones.childrenArea
+      const parentYAtMeasure = zones.parentBounds?.y ?? 0
+      const rel = ca.y - parentYAtMeasure
+      // 换算到“当前父的绝对坐标系”
+      zonalTop = pY + rel
+    }
+
+    // 兜底：用 meta 中记录的 header / content 高度估算 childrenTop
+    const headerH =
+      Number(parent.meta?.headerH) ||
+      Number((parent.meta as any)?.upperHeight) || 30
+    const contentH =
+      Number(parent.meta?.contentH) ||
+      Number((parent as any).keywordsBounds?.height) ||
+      Math.ceil((Number((parent as any).keywordsStyle?.fontSize) || 14) * 1.3)
+
+    const metaTop = pY + headerH + DIVIDER + contentH + PAD_TOP
+
+    // 取更“严格”的 childrenTop
+    const childrenTopAbs = Math.max((zonalTop ?? -Infinity), metaTop)
+
+    const childTop = placeRect.y
+    const minAllowedTop = childrenTopAbs + INSET + MARGIN
+
+    // 只有在“确实侵入禁区”时才扩父，尽量少动
+    if (childTop < minAllowedTop - EPS) {
+      // 扩容目标：扩完后 newChildrenTop <= childTop - INSET - MARGIN
+      const targetTop = childTop - INSET - MARGIN
+      let needGrowUp = Math.max(0, childrenTopAbs - targetTop)
+
+      // 限制向上扩的量，不能超过画布顶部
+      const availUp = Math.max(0, pY - CANVAS_TOP)
+      let growUp = Math.min(needGrowUp, availUp)
+      if (growUp < EPS) growUp = 0
+
+      if (growUp > 0) {
+        const ny = pY - growUp
+        const nh = pH + growUp
+        if (ny !== pY || nh !== pH) {
+          updateShape(parent.id, {
+            bounds: { x: pX, y: ny, width: pW, height: nh },
+          })
+          expanded = true
+        }
+      }
+    }
+    // 左 / 右 / 下的越界问题交给下面的 overflowIn → ensureParentFitsChildren 统一处理
+  }
+
+  // ================== 2. 通用“放不下就扩父 + 向上冒泡 + 轻量 clamp 子元素” ==================
+  if (overflowIn(parent, placeRect) > CONTENT_EPS) {
+    // 这里只关心这个 childId 对父的影响，其他子元素的影响在 ensureParentFitsChildren 内部综合计算
+    ensureParentFitsChildren(shapes, parent, updateShape, {
+      [childId]: placeRect,
+    })
+
+    // 把“扩父影响”向上冒泡到更高层父节点
+    bubbleAutoFitUp(shapes, parent.parenShapeId, updateShape)
+
+    // 再看一眼，若父仍然轻微越界，则把子轻夹回去
+    const pNow = shapes.find(s => s.id === parent.id)
+    if (pNow && overflowIn(pNow, placeRect) > CONTENT_EPS) {
+      const clamped = clampChildIntoParent(pNow, placeRect)
+      if (clamped.x !== placeRect.x || clamped.y !== placeRect.y) {
+        updateShape(childId, { bounds: clamped })
+      }
+    }
+    expanded = true
+  }
+  return {
+    expanded,
+    affectedIds: expanded ? Array.from(affected) : [],
+  }
+}
+/**
+ * 统一判定：这个 shape 是否“禁止扩父”（pin / port）
+ */
+const isPinShape = (shape?: Shape | null): boolean => {
+  if (!shape) return false
+  const key = (shape as any).shapeKey ?? ''
+  const store = useGraphStore()
+  const pins = store?.pinsTypes ?? []
+  const ports = store?.portsTypes ?? []
+  // 在 pinsTypes 或 portsTypes 里就视为“不参与扩父”
+  return pins.includes(key) || ports.includes(key)
+}