dishui 0.0.64 → 0.0.66

package/dist/components/pro/Flow/edges/edgePaths.js.map

@@ -1 +1 @@
-{"version":3,"file":"edgePaths.js","names":[],"sources":["../../../../../src/components/pro/Flow/edges/edgePaths.ts"],"sourcesContent":["import type { FlowEdgeTypeName, FlowBezierControl, FlowEdge, FlowNode } from '../types';\nimport { getHandlePositions, type HandleDef } from '../nodes/NodeHandles';\n\n/** Outward unit normal for a handle side */\nconst SIDE_NORMAL: Record<string, { dx: number; dy: number }> = {\n  top:    { dx:  0, dy: -1 },\n  bottom: { dx:  0, dy:  1 },\n  left:   { dx: -1, dy:  0 },\n  right:  { dx:  1, dy:  0 },\n};\n\n/** Perpendicular clearance (px) from node edge for step / smoothstep paths */\nconst EDGE_OFFSET = 20;\n/** Bezier control-arm length multiplier (fraction of inter-node distance, clamped) */\nconst BEZ_ARM_MIN = 30;\nconst BEZ_ARM_FRAC = 0.3;\n\nexport interface EdgeEndpoints {\n  sx: number; sy: number;\n  tx: number; ty: number;\n  /** Outward unit-normal at source handle */\n  snx: number; sny: number;\n  /** Outward unit-normal at target handle */\n  tnx: number; tny: number;\n}\n\nexport interface PathSegment {\n  type: 'M' | 'L' | 'C' | 'Q';\n  x: number; y: number;\n  cp1x?: number; cp1y?: number;\n  cp2x?: number; cp2y?: number;\n}\n\n/**\n * Build a path (array of segments) for the given edge type.\n * Returns segments that can be drawn with PixiJS Graphics.\n */\nexport function buildEdgePath(\n  type: FlowEdgeTypeName,\n  endpoints: EdgeEndpoints,\n  waypoints?: Array<{ x: number; y: number }>,\n  bezierControls?: Array<FlowBezierControl | null> | null,\n): PathSegment[] {\n  const src = { x: endpoints.sx, y: endpoints.sy };\n  const tgt = { x: endpoints.tx, y: endpoints.ty };\n  const wps = waypoints ?? [];\n\n  switch (type) {\n    case 'straight':\n      return buildStraightPath([src, ...wps, tgt]);\n\n    case 'step':\n    case 'smoothstep': {\n      const radius = type === 'smoothstep' ? 8 : 0;\n      return buildStepPathWithOffsets(src, tgt, wps, endpoints, radius);\n    }\n\n    case 'simplebezier':\n      return buildBezierPath([src, ...wps, tgt], bezierControls, endpoints);\n\n    default:\n      return buildStraightPath([src, ...wps, tgt]);\n  }\n}\n\nfunction buildStraightPath(points: Array<{ x: number; y: number }>): PathSegment[] {\n  const segs: PathSegment[] = [{ type: 'M', x: points[0].x, y: points[0].y }];\n  for (let i = 1; i < points.length; i++) {\n    segs.push({ type: 'L', x: points[i].x, y: points[i].y });\n  }\n  return segs;\n}\n\n/**\n * Step path with perpendicular exit / entry offsets.\n *\n * Produces clean orthogonal \"elbow\" routing:\n * 1. source → exit stub (perpendicular to the source face)\n * 2. exit → waypoints → approach (orthogonal)\n * 3. approach stub → target (perpendicular into the target face)\n *\n * The middle routing picks the split axis from the two handle orientations so\n * opposing/aligned handles produce a single clean bend instead of an S/Z jog,\n * and collinear points are collapsed at the end.\n */\nfunction buildStepPathWithOffsets(\n  src: { x: number; y: number },\n  tgt: { x: number; y: number },\n  waypoints: Array<{ x: number; y: number }>,\n  ep: EdgeEndpoints,\n  borderRadius: number,\n): PathSegment[] {\n  const dist = Math.hypot(tgt.x - src.x, tgt.y - src.y);\n  const offset = Math.min(EDGE_OFFSET, dist / 4);\n\n  const exitPt = { x: src.x + ep.snx * offset, y: src.y + ep.sny * offset };\n  const approPt = { x: tgt.x + ep.tnx * offset, y: tgt.y + ep.tny * offset };\n\n  const srcVertical = Math.abs(ep.sny) > Math.abs(ep.snx);\n  const tgtVertical = Math.abs(ep.tny) > Math.abs(ep.tnx);\n\n  // Build the raw corner list (no rounding yet), then simplify + round.\n  const corners: Array<{ x: number; y: number }> = [{ x: src.x, y: src.y }, exitPt];\n\n  const mids = [exitPt, ...waypoints, approPt];\n  for (let i = 0; i < mids.length - 1; i++) {\n    const a = mids[i];\n    const b = mids[i + 1];\n    // Orientation of this leg: first leg follows source, last leg follows target.\n    const vertical = i === 0 ? srcVertical : (i === mids.length - 2 ? tgtVertical : srcVertical);\n    if (vertical) {\n      // V-H-V: go vertically to the mid-Y, across, then down/up.\n      const midY = (a.y + b.y) / 2;\n      corners.push({ x: a.x, y: midY }, { x: b.x, y: midY });\n    } else {\n      // H-V-H: go horizontally to the mid-X, vertically, then across.\n      const midX = (a.x + b.x) / 2;\n      corners.push({ x: midX, y: a.y }, { x: midX, y: b.y });\n    }\n    corners.push({ x: b.x, y: b.y });\n  }\n  corners.push({ x: tgt.x, y: tgt.y });\n\n  const simplified = simplifyOrthogonal(corners);\n  return roundedOrthogonalPath(simplified, borderRadius);\n}\n\n/**\n * Remove collinear / duplicate points from an orthogonal polyline so we don't\n * emit degenerate zero-length jogs (a common source of \"unnatural\" bends).\n */\nfunction simplifyOrthogonal(pts: Array<{ x: number; y: number }>): Array<{ x: number; y: number }> {\n  const out: Array<{ x: number; y: number }> = [];\n  for (const p of pts) {\n    const last = out[out.length - 1];\n    if (last && Math.abs(last.x - p.x) < 0.01 && Math.abs(last.y - p.y) < 0.01) continue;\n    out.push({ x: p.x, y: p.y });\n  }\n  // Drop the middle of any 3 collinear points.\n  const res: Array<{ x: number; y: number }> = [];\n  for (let i = 0; i < out.length; i++) {\n    const prev = res[res.length - 1];\n    const cur = out[i];\n    const next = out[i + 1];\n    if (prev && next) {\n      const collinearX = Math.abs(prev.x - cur.x) < 0.01 && Math.abs(cur.x - next.x) < 0.01;\n      const collinearY = Math.abs(prev.y - cur.y) < 0.01 && Math.abs(cur.y - next.y) < 0.01;\n      if (collinearX || collinearY) continue;\n    }\n    res.push(cur);\n  }\n  return res;\n}\n\n/**\n * Convert an orthogonal polyline into path segments, rounding each corner.\n */\nfunction roundedOrthogonalPath(\n  pts: Array<{ x: number; y: number }>,\n  borderRadius: number,\n): PathSegment[] {\n  if (pts.length === 0) return [];\n  const segs: PathSegment[] = [{ type: 'M', x: pts[0].x, y: pts[0].y }];\n  if (pts.length === 1) return segs;\n  if (borderRadius <= 0.5) {\n    for (let i = 1; i < pts.length; i++) segs.push({ type: 'L', x: pts[i].x, y: pts[i].y });\n    return segs;\n  }\n  for (let i = 1; i < pts.length - 1; i++) {\n    const prev = pts[i - 1];\n    const cur = pts[i];\n    const next = pts[i + 1];\n    const inLen = Math.hypot(cur.x - prev.x, cur.y - prev.y);\n    const outLen = Math.hypot(next.x - cur.x, next.y - cur.y);\n    const r = Math.min(borderRadius, inLen / 2, outLen / 2);\n    if (r < 0.5) {\n      segs.push({ type: 'L', x: cur.x, y: cur.y });\n      continue;\n    }\n    const inDx = Math.sign(cur.x - prev.x);\n    const inDy = Math.sign(cur.y - prev.y);\n    const outDx = Math.sign(next.x - cur.x);\n    const outDy = Math.sign(next.y - cur.y);\n    segs.push({ type: 'L', x: cur.x - inDx * r, y: cur.y - inDy * r });\n    segs.push({ type: 'Q', x: cur.x + outDx * r, y: cur.y + outDy * r, cp1x: cur.x, cp1y: cur.y });\n  }\n  const end = pts[pts.length - 1];\n  segs.push({ type: 'L', x: end.x, y: end.y });\n  return segs;\n}\n\n/**\n * Cubic bezier path between consecutive points.\n * Uses handle normals on the first / last segment for perpendicular exit/entry.\n */\nfunction buildBezierPath(\n  points: Array<{ x: number; y: number }>,\n  controls?: Array<FlowBezierControl | null> | null,\n  ep?: EdgeEndpoints,\n): PathSegment[] {\n  const segs: PathSegment[] = [{ type: 'M', x: points[0].x, y: points[0].y }];\n  const lastIdx = points.length - 2;\n\n  for (let i = 0; i <= lastIdx; i++) {\n    const a = points[i];\n    const b = points[i + 1];\n    const ctrl = controls?.[i];\n\n    if (ctrl) {\n      segs.push({\n        type: 'C', x: b.x, y: b.y,\n        cp1x: ctrl.c1x, cp1y: ctrl.c1y,\n        cp2x: ctrl.c2x, cp2y: ctrl.c2y,\n      });\n    } else {\n      const dist = Math.hypot(b.x - a.x, b.y - a.y);\n      const arm = Math.max(BEZ_ARM_MIN, dist * BEZ_ARM_FRAC);\n\n      let c1x: number, c1y: number;\n      if (i === 0 && ep) {\n        c1x = a.x + ep.snx * arm;\n        c1y = a.y + ep.sny * arm;\n      } else {\n        c1x = a.x + (b.x - a.x) * 0.4;\n        c1y = a.y;\n      }\n\n      let c2x: number, c2y: number;\n      if (i === lastIdx && ep) {\n        c2x = b.x + ep.tnx * arm;\n        c2y = b.y + ep.tny * arm;\n      } else {\n        c2x = b.x - (b.x - a.x) * 0.4;\n        c2y = b.y;\n      }\n\n      segs.push({\n        type: 'C', x: b.x, y: b.y,\n        cp1x: c1x, cp1y: c1y,\n        cp2x: c2x, cp2y: c2y,\n      });\n    }\n  }\n  return segs;\n}\n\n/**\n * Compute the center point of a path (for label placement).\n */\nexport function getPathCenter(segs: PathSegment[]): { x: number; y: number } {\n  if (segs.length < 2) return { x: segs[0]?.x ?? 0, y: segs[0]?.y ?? 0 };\n  const mid = Math.floor(segs.length / 2);\n  const a = segs[mid - 1];\n  const b = segs[mid];\n  return { x: (a.x + b.x) / 2, y: (a.y + b.y) / 2 };\n}\n\n/**\n * Get a point on a path at parameter t (0-1), approximate.\n */\nexport function getPointOnPath(segs: PathSegment[], t: number): { x: number; y: number } {\n  if (segs.length < 2) return { x: segs[0]?.x ?? 0, y: segs[0]?.y ?? 0 };\n  const totalSegs = segs.length - 1;\n  const segIdx = Math.min(Math.floor(t * totalSegs), totalSegs - 1);\n  const localT = (t * totalSegs) - segIdx;\n  const a = segs[segIdx];\n  const b = segs[segIdx + 1];\n  return {\n    x: a.x + (b.x - a.x) * localT,\n    y: a.y + (b.y - a.y) * localT,\n  };\n}\n\n/**\n * Resolve source/target anchor positions for an edge.\n * Uses stored handle IDs when available; falls back to closest-handle heuristic.\n */\n/**\n * Transform a handle's local-space position into world space,\n * accounting for the node's rotation (degrees, stored in data.rotation).\n */\nfunction handleToWorld(\n  hx: number, hy: number,\n  node: FlowNode,\n): { x: number; y: number } {\n  const deg = node.data.rotation ?? 0;\n  if (deg === 0) {\n    return { x: node.position.x + hx, y: node.position.y + hy };\n  }\n  const rad = (deg * Math.PI) / 180;\n  const cx = node.width / 2, cy = node.height / 2;\n  const dx = hx - cx, dy = hy - cy;\n  const cos = Math.cos(rad), sin = Math.sin(rad);\n  return {\n    x: node.position.x + cx + dx * cos - dy * sin,\n    y: node.position.y + cy + dx * sin + dy * cos,\n  };\n}\n\n/**\n * Compute the outward unit-normal for a handle, accounting for node rotation.\n */\nfunction handleNormal(h: HandleDef | null, node: FlowNode): { nx: number; ny: number } {\n  const base = SIDE_NORMAL[h?.side ?? 'right'] ?? SIDE_NORMAL.right;\n  const deg = node.data.rotation ?? 0;\n  if (deg === 0) return { nx: base.dx, ny: base.dy };\n  const rad = (deg * Math.PI) / 180;\n  const cos = Math.cos(rad), sin = Math.sin(rad);\n  return {\n    nx: base.dx * cos - base.dy * sin,\n    ny: base.dx * sin + base.dy * cos,\n  };\n}\n\nexport function resolveEdgeEndpoints(\n  edge: FlowEdge,\n  nodeMap: Map<string, FlowNode>,\n): EdgeEndpoints | null {\n  const sn = nodeMap.get(edge.source);\n  const tn = nodeMap.get(edge.target);\n  if (!sn || !tn) return null;\n\n  const sHandles = getHandlePositions(sn.width, sn.height);\n  const tHandles = getHandlePositions(tn.width, tn.height);\n\n  let sx: number, sy: number, sH: HandleDef | null;\n  if (edge.sourceHandle) {\n    sH = sHandles.find(h => h.id === edge.sourceHandle) ?? null;\n    const pos = handleToWorld(sH ? sH.x : sn.width / 2, sH ? sH.y : sn.height / 2, sn);\n    sx = pos.x; sy = pos.y;\n  } else {\n    // Floating anchor: pick the side by direction, then slide the point along\n    // that side to align with the target so aligned nodes connect with a\n    // straight line instead of a forced mid-handle jog.\n    const anchor = floatingAnchor(sn, tn);\n    sx = anchor.x; sy = anchor.y; sH = anchor.handleLike;\n  }\n\n  let tx: number, ty: number, tH: HandleDef | null;\n  if (edge.targetHandle) {\n    tH = tHandles.find(h => h.id === edge.targetHandle) ?? null;\n    const pos = handleToWorld(tH ? tH.x : tn.width / 2, tH ? tH.y : tn.height / 2, tn);\n    tx = pos.x; ty = pos.y;\n  } else {\n    const anchor = floatingAnchor(tn, sn);\n    tx = anchor.x; ty = anchor.y; tH = anchor.handleLike;\n  }\n\n  const sN = handleNormal(sH, sn);\n  const tN = handleNormal(tH, tn);\n\n  return { sx, sy, tx, ty, snx: sN.nx, sny: sN.ny, tnx: tN.nx, tny: tN.ny };\n}\n\n/**\n * Compute a floating connection anchor on `self` facing `other`.\n * Chooses the side by dominant direction, then slides the anchor along that\n * side to line up with the other node's center (clamped to the side extent).\n * Returns the world point plus a synthetic handle carrying only the `side`\n * (used for the outward normal).\n */\nfunction floatingAnchor(\n  self: FlowNode,\n  other: FlowNode,\n): { x: number; y: number; handleLike: HandleDef } {\n  const sx = self.position.x, sy = self.position.y;\n  const sw = self.width, sh = self.height;\n  const sCx = sx + sw / 2, sCy = sy + sh / 2;\n  let oCx = other.position.x + other.width / 2;\n  let oCy = other.position.y + other.height / 2;\n\n  const deg = self.data.rotation ?? 0;\n  if (deg !== 0) {\n    // Work in the node's local (unrotated) frame: rotate the other node's\n    // center into that frame so side-picking and the slide-to-align run in the\n    // same space the anchor is computed in. The anchor is mapped back to world\n    // space below via `handleToWorld`, so it rides on the rotated border.\n    const rad = (deg * Math.PI) / 180;\n    const cos = Math.cos(-rad), sin = Math.sin(-rad);\n    const dx = oCx - sCx;\n    const dy = oCy - sCy;\n    oCx = sCx + dx * cos - dy * sin;\n    oCy = sCy + dx * sin + dy * cos;\n  }\n\n  const dx = oCx - sCx;\n  const dy = oCy - sCy;\n  // Inset so the anchor never sits exactly on a corner.\n  const inset = Math.min(12, sw / 2 - 1, sh / 2 - 1);\n\n  let side: HandleDef['side'];\n  let x: number, y: number;\n  if (Math.abs(dx) >= Math.abs(dy)) {\n    side = dx >= 0 ? 'right' : 'left';\n    x = side === 'right' ? sx + sw : sx;\n    // Slide vertically to align with the other center, clamped to the side.\n    y = Math.max(sy + inset, Math.min(sy + sh - inset, oCy));\n  } else {\n    side = dy >= 0 ? 'bottom' : 'top';\n    y = side === 'bottom' ? sy + sh : sy;\n    x = Math.max(sx + inset, Math.min(sx + sw - inset, oCx));\n  }\n\n  if (deg !== 0) {\n    // Map the (locally chosen) anchor back onto the rotated border.\n    const pos = handleToWorld(x - sx, y - sy, self);\n    return { x: pos.x, y: pos.y, handleLike: { id: `float_${side}`, x: 0, y: 0, side } };\n  }\n\n  return { x, y, handleLike: { id: `float_${side}`, x: 0, y: 0, side } };\n}\n\n/**\n * Previously this pinned auto-resolved edges to a fixed middle handle at load\n * time, which forced ugly jogs between misaligned nodes. Edges without an\n * explicit handle are now left \"floating\" and resolved dynamically in\n * `resolveEdgeEndpoints` (see `floatingAnchor`), so this is a no-op that simply\n * preserves any user-pinned handles.\n */\nexport function normalizeEdgeHandles(\n  edges: FlowEdge[],\n  _nodeMap: Map<string, FlowNode>,\n): FlowEdge[] {\n  const legacyOffsets = new Map([\n    ['0.25', String(2 / 6)],\n    ['0.5', String(3 / 6)],\n    ['0.75', String(4 / 6)],\n  ]);\n  let changed = false;\n  const migrate = (handle: string | undefined) => {\n    if (!handle) return handle;\n    const [side, offset] = handle.split('_');\n    const nextOffset = legacyOffsets.get(offset);\n    if (!nextOffset || !side) return handle;\n    changed = true;\n    return `${side}_${nextOffset}`;\n  };\n  const normalized = edges.map(edge => {\n    const sourceHandle = migrate(edge.sourceHandle);\n    const targetHandle = migrate(edge.targetHandle);\n    return sourceHandle === edge.sourceHandle && targetHandle === edge.targetHandle\n      ? edge\n      : { ...edge, sourceHandle, targetHandle };\n  });\n  return changed ? normalized : edges;\n}\n\n/**\n * Convert PathSegments into a polyline by sampling curves.\n */\nexport function linearizeSegments(\n  segs: PathSegment[],\n  samplesPerCurve = 8,\n): Array<{ x: number; y: number }> {\n  const pts: Array<{ x: number; y: number }> = [];\n  let cx = 0, cy = 0;\n  for (const seg of segs) {\n    switch (seg.type) {\n      case 'M':\n      case 'L':\n        cx = seg.x; cy = seg.y;\n        pts.push({ x: cx, y: cy });\n        break;\n      case 'Q': {\n        const cpx = seg.cp1x!, cpy = seg.cp1y!;\n        for (let i = 1; i <= samplesPerCurve; i++) {\n          const t = i / samplesPerCurve, mt = 1 - t;\n          pts.push({\n            x: mt * mt * cx + 2 * mt * t * cpx + t * t * seg.x,\n            y: mt * mt * cy + 2 * mt * t * cpy + t * t * seg.y,\n          });\n        }\n        cx = seg.x; cy = seg.y;\n        break;\n      }\n      case 'C': {\n        const c1x = seg.cp1x!, c1y = seg.cp1y!, c2x = seg.cp2x!, c2y = seg.cp2y!;\n        for (let i = 1; i <= samplesPerCurve; i++) {\n          const t = i / samplesPerCurve, mt = 1 - t;\n          pts.push({\n            x: mt ** 3 * cx + 3 * mt ** 2 * t * c1x + 3 * mt * t ** 2 * c2x + t ** 3 * seg.x,\n            y: mt ** 3 * cy + 3 * mt ** 2 * t * c1y + 3 * mt * t ** 2 * c2y + t ** 3 * seg.y,\n          });\n        }\n        cx = seg.x; cy = seg.y;\n        break;\n      }\n    }\n  }\n  return pts;\n}\n"],"mappings":"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"}
+{"version":3,"file":"edgePaths.js","names":[],"sources":["../../../../../src/components/pro/Flow/edges/edgePaths.ts"],"sourcesContent":["import type { FlowEdgeTypeName, FlowBezierControl, FlowEdge, FlowNode } from '../types';\nimport { getHandlePositions, type HandleDef } from '../nodes/NodeHandles';\n\n/** Outward unit normal for a handle side */\nconst SIDE_NORMAL: Record<string, { dx: number; dy: number }> = {\n  top:    { dx:  0, dy: -1 },\n  bottom: { dx:  0, dy:  1 },\n  left:   { dx: -1, dy:  0 },\n  right:  { dx:  1, dy:  0 },\n};\n\n/** Perpendicular clearance (px) from node edge for step / smoothstep paths */\nconst EDGE_OFFSET = 20;\n/** Bezier control-arm length multiplier (fraction of inter-node distance, clamped) */\nconst BEZ_ARM_MIN = 30;\nconst BEZ_ARM_FRAC = 0.3;\n\nexport interface EdgeEndpoints {\n  sx: number; sy: number;\n  tx: number; ty: number;\n  /** Outward unit-normal at source handle */\n  snx: number; sny: number;\n  /** Outward unit-normal at target handle */\n  tnx: number; tny: number;\n}\n\nexport interface PathSegment {\n  type: 'M' | 'L' | 'C' | 'Q';\n  x: number; y: number;\n  cp1x?: number; cp1y?: number;\n  cp2x?: number; cp2y?: number;\n}\n\n/**\n * Build a path (array of segments) for the given edge type.\n * Returns segments that can be drawn with PixiJS Graphics.\n */\nexport function buildEdgePath(\n  type: FlowEdgeTypeName,\n  endpoints: EdgeEndpoints,\n  waypoints?: Array<{ x: number; y: number }>,\n  bezierControls?: Array<FlowBezierControl | null> | null,\n): PathSegment[] {\n  const src = { x: endpoints.sx, y: endpoints.sy };\n  const tgt = { x: endpoints.tx, y: endpoints.ty };\n  const wps = waypoints ?? [];\n\n  switch (type) {\n    case 'straight':\n      return buildStraightPath([src, ...wps, tgt]);\n\n    case 'step':\n    case 'smoothstep': {\n      const radius = type === 'smoothstep' ? 8 : 0;\n      return buildStepPathWithOffsets(src, tgt, wps, endpoints, radius);\n    }\n\n    case 'simplebezier':\n      return buildBezierPath([src, ...wps, tgt], bezierControls, endpoints);\n\n    default:\n      return buildStraightPath([src, ...wps, tgt]);\n  }\n}\n\nfunction buildStraightPath(points: Array<{ x: number; y: number }>): PathSegment[] {\n  const segs: PathSegment[] = [{ type: 'M', x: points[0].x, y: points[0].y }];\n  for (let i = 1; i < points.length; i++) {\n    segs.push({ type: 'L', x: points[i].x, y: points[i].y });\n  }\n  return segs;\n}\n\n/**\n * Step path with perpendicular exit / entry offsets.\n *\n * Produces clean orthogonal \"elbow\" routing:\n * 1. source → exit stub (perpendicular to the source face)\n * 2. exit → waypoints → approach (orthogonal)\n * 3. approach stub → target (perpendicular into the target face)\n *\n * The middle routing picks the split axis from the two handle orientations so\n * opposing/aligned handles produce a single clean bend instead of an S/Z jog,\n * and collinear points are collapsed at the end.\n */\nfunction buildStepPathWithOffsets(\n  src: { x: number; y: number },\n  tgt: { x: number; y: number },\n  waypoints: Array<{ x: number; y: number }>,\n  ep: EdgeEndpoints,\n  borderRadius: number,\n): PathSegment[] {\n  const dist = Math.hypot(tgt.x - src.x, tgt.y - src.y);\n  const offset = Math.min(EDGE_OFFSET, dist / 4);\n\n  const exitPt = { x: src.x + ep.snx * offset, y: src.y + ep.sny * offset };\n  const approPt = { x: tgt.x + ep.tnx * offset, y: tgt.y + ep.tny * offset };\n\n  const srcVertical = Math.abs(ep.sny) > Math.abs(ep.snx);\n  const tgtVertical = Math.abs(ep.tny) > Math.abs(ep.tnx);\n\n  // Build the raw corner list (no rounding yet), then simplify + round.\n  const corners: Array<{ x: number; y: number }> = [{ x: src.x, y: src.y }, exitPt];\n\n  const mids = [exitPt, ...waypoints, approPt];\n  for (let i = 0; i < mids.length - 1; i++) {\n    const a = mids[i];\n    const b = mids[i + 1];\n    // Orientation of this leg: first leg follows source, last leg follows target.\n    const vertical = i === 0 ? srcVertical : (i === mids.length - 2 ? tgtVertical : srcVertical);\n    if (vertical) {\n      // V-H-V: go vertically to the mid-Y, across, then down/up.\n      const midY = (a.y + b.y) / 2;\n      corners.push({ x: a.x, y: midY }, { x: b.x, y: midY });\n    } else {\n      // H-V-H: go horizontally to the mid-X, vertically, then across.\n      const midX = (a.x + b.x) / 2;\n      corners.push({ x: midX, y: a.y }, { x: midX, y: b.y });\n    }\n    corners.push({ x: b.x, y: b.y });\n  }\n  corners.push({ x: tgt.x, y: tgt.y });\n\n  const simplified = simplifyOrthogonal(corners);\n  return roundedOrthogonalPath(simplified, borderRadius);\n}\n\n/**\n * Remove collinear / duplicate points from an orthogonal polyline so we don't\n * emit degenerate zero-length jogs (a common source of \"unnatural\" bends).\n */\nfunction simplifyOrthogonal(pts: Array<{ x: number; y: number }>): Array<{ x: number; y: number }> {\n  const out: Array<{ x: number; y: number }> = [];\n  for (const p of pts) {\n    const last = out[out.length - 1];\n    if (last && Math.abs(last.x - p.x) < 0.01 && Math.abs(last.y - p.y) < 0.01) continue;\n    out.push({ x: p.x, y: p.y });\n  }\n  // Drop the middle of any 3 collinear points.\n  const res: Array<{ x: number; y: number }> = [];\n  for (let i = 0; i < out.length; i++) {\n    const prev = res[res.length - 1];\n    const cur = out[i];\n    const next = out[i + 1];\n    if (prev && next) {\n      const collinearX = Math.abs(prev.x - cur.x) < 0.01 && Math.abs(cur.x - next.x) < 0.01;\n      const collinearY = Math.abs(prev.y - cur.y) < 0.01 && Math.abs(cur.y - next.y) < 0.01;\n      if (collinearX || collinearY) continue;\n    }\n    res.push(cur);\n  }\n  return res;\n}\n\n/**\n * Convert an orthogonal polyline into path segments, rounding each corner.\n */\nfunction roundedOrthogonalPath(\n  pts: Array<{ x: number; y: number }>,\n  borderRadius: number,\n): PathSegment[] {\n  if (pts.length === 0) return [];\n  const segs: PathSegment[] = [{ type: 'M', x: pts[0].x, y: pts[0].y }];\n  if (pts.length === 1) return segs;\n  if (borderRadius <= 0.5) {\n    for (let i = 1; i < pts.length; i++) segs.push({ type: 'L', x: pts[i].x, y: pts[i].y });\n    return segs;\n  }\n  for (let i = 1; i < pts.length - 1; i++) {\n    const prev = pts[i - 1];\n    const cur = pts[i];\n    const next = pts[i + 1];\n    const inLen = Math.hypot(cur.x - prev.x, cur.y - prev.y);\n    const outLen = Math.hypot(next.x - cur.x, next.y - cur.y);\n    const r = Math.min(borderRadius, inLen / 2, outLen / 2);\n    if (r < 0.5) {\n      segs.push({ type: 'L', x: cur.x, y: cur.y });\n      continue;\n    }\n    const inDx = Math.sign(cur.x - prev.x);\n    const inDy = Math.sign(cur.y - prev.y);\n    const outDx = Math.sign(next.x - cur.x);\n    const outDy = Math.sign(next.y - cur.y);\n    segs.push({ type: 'L', x: cur.x - inDx * r, y: cur.y - inDy * r });\n    segs.push({ type: 'Q', x: cur.x + outDx * r, y: cur.y + outDy * r, cp1x: cur.x, cp1y: cur.y });\n  }\n  const end = pts[pts.length - 1];\n  segs.push({ type: 'L', x: end.x, y: end.y });\n  return segs;\n}\n\n/**\n * Cubic bezier path between consecutive points.\n * Uses handle normals on the first / last segment for perpendicular exit/entry.\n */\nfunction buildBezierPath(\n  points: Array<{ x: number; y: number }>,\n  controls?: Array<FlowBezierControl | null> | null,\n  ep?: EdgeEndpoints,\n): PathSegment[] {\n  const segs: PathSegment[] = [{ type: 'M', x: points[0].x, y: points[0].y }];\n  const lastIdx = points.length - 2;\n\n  for (let i = 0; i <= lastIdx; i++) {\n    const a = points[i];\n    const b = points[i + 1];\n    const ctrl = controls?.[i];\n\n    if (ctrl) {\n      segs.push({\n        type: 'C', x: b.x, y: b.y,\n        cp1x: ctrl.c1x, cp1y: ctrl.c1y,\n        cp2x: ctrl.c2x, cp2y: ctrl.c2y,\n      });\n    } else {\n      const dist = Math.hypot(b.x - a.x, b.y - a.y);\n      const arm = Math.max(BEZ_ARM_MIN, dist * BEZ_ARM_FRAC);\n\n      let c1x: number, c1y: number;\n      if (i === 0 && ep) {\n        c1x = a.x + ep.snx * arm;\n        c1y = a.y + ep.sny * arm;\n      } else {\n        c1x = a.x + (b.x - a.x) * 0.4;\n        c1y = a.y;\n      }\n\n      let c2x: number, c2y: number;\n      if (i === lastIdx && ep) {\n        c2x = b.x + ep.tnx * arm;\n        c2y = b.y + ep.tny * arm;\n      } else {\n        c2x = b.x - (b.x - a.x) * 0.4;\n        c2y = b.y;\n      }\n\n      segs.push({\n        type: 'C', x: b.x, y: b.y,\n        cp1x: c1x, cp1y: c1y,\n        cp2x: c2x, cp2y: c2y,\n      });\n    }\n  }\n  return segs;\n}\n\n/**\n * Compute the center point of a path (for label placement).\n */\nexport function getPathCenter(segs: PathSegment[]): { x: number; y: number } {\n  if (segs.length < 2) return { x: segs[0]?.x ?? 0, y: segs[0]?.y ?? 0 };\n  const mid = Math.floor(segs.length / 2);\n  const a = segs[mid - 1];\n  const b = segs[mid];\n  return { x: (a.x + b.x) / 2, y: (a.y + b.y) / 2 };\n}\n\n/**\n * Get a point on a path at parameter t (0-1), approximate.\n */\nexport function getPointOnPath(segs: PathSegment[], t: number): { x: number; y: number } {\n  if (segs.length < 2) return { x: segs[0]?.x ?? 0, y: segs[0]?.y ?? 0 };\n  const totalSegs = segs.length - 1;\n  const segIdx = Math.min(Math.floor(t * totalSegs), totalSegs - 1);\n  const localT = (t * totalSegs) - segIdx;\n  const a = segs[segIdx];\n  const b = segs[segIdx + 1];\n  return {\n    x: a.x + (b.x - a.x) * localT,\n    y: a.y + (b.y - a.y) * localT,\n  };\n}\n\n/**\n * Resolve source/target anchor positions for an edge.\n * Uses stored handle IDs when available; falls back to closest-handle heuristic.\n */\n/**\n * Transform a handle's local-space position into world space,\n * accounting for the node's rotation (degrees, stored in data.rotation).\n */\nfunction handleToWorld(\n  hx: number, hy: number,\n  node: FlowNode,\n): { x: number; y: number } {\n  const deg = node.data.rotation ?? 0;\n  if (deg === 0) {\n    return { x: node.position.x + hx, y: node.position.y + hy };\n  }\n  const rad = (deg * Math.PI) / 180;\n  const cx = node.width / 2, cy = node.height / 2;\n  const dx = hx - cx, dy = hy - cy;\n  const cos = Math.cos(rad), sin = Math.sin(rad);\n  return {\n    x: node.position.x + cx + dx * cos - dy * sin,\n    y: node.position.y + cy + dx * sin + dy * cos,\n  };\n}\n\n/**\n * Compute the outward unit-normal for a handle, accounting for node rotation.\n */\nfunction handleNormal(h: HandleDef | null, node: FlowNode): { nx: number; ny: number } {\n  const base = SIDE_NORMAL[h?.side ?? 'right'] ?? SIDE_NORMAL.right;\n  const deg = node.data.rotation ?? 0;\n  if (deg === 0) return { nx: base.dx, ny: base.dy };\n  const rad = (deg * Math.PI) / 180;\n  const cos = Math.cos(rad), sin = Math.sin(rad);\n  return {\n    nx: base.dx * cos - base.dy * sin,\n    ny: base.dx * sin + base.dy * cos,\n  };\n}\n\nexport function resolveEdgeEndpoints(\n  edge: FlowEdge,\n  nodeMap: Map<string, FlowNode>,\n): EdgeEndpoints | null {\n  const sn = nodeMap.get(edge.source);\n  const tn = nodeMap.get(edge.target);\n  if (!sn || !tn) return null;\n\n  const sHandles = getHandlePositions(sn.width, sn.height);\n  const tHandles = getHandlePositions(tn.width, tn.height);\n\n  let sx: number, sy: number, sH: HandleDef | null;\n  if (edge.sourceHandle) {\n    sH = sHandles.find(h => h.id === edge.sourceHandle) ?? null;\n    const pos = handleToWorld(sH ? sH.x : sn.width / 2, sH ? sH.y : sn.height / 2, sn);\n    sx = pos.x; sy = pos.y;\n  } else {\n    // Floating anchor: pick the side by direction, then slide the point along\n    // that side to align with the target so aligned nodes connect with a\n    // straight line instead of a forced mid-handle jog.\n    const anchor = floatingAnchor(sn, tn);\n    sx = anchor.x; sy = anchor.y; sH = anchor.handleLike;\n  }\n\n  let tx: number, ty: number, tH: HandleDef | null;\n  if (edge.targetHandle) {\n    tH = tHandles.find(h => h.id === edge.targetHandle) ?? null;\n    const pos = handleToWorld(tH ? tH.x : tn.width / 2, tH ? tH.y : tn.height / 2, tn);\n    tx = pos.x; ty = pos.y;\n  } else {\n    const anchor = floatingAnchor(tn, sn);\n    tx = anchor.x; ty = anchor.y; tH = anchor.handleLike;\n  }\n\n  const sN = handleNormal(sH, sn);\n  const tN = handleNormal(tH, tn);\n\n  return { sx, sy, tx, ty, snx: sN.nx, sny: sN.ny, tnx: tN.nx, tny: tN.ny };\n}\n\n/**\n * Compute a floating connection anchor on `self` facing `other`.\n * Chooses the side by dominant direction, then slides the anchor along that\n * side to line up with the other node's center (clamped to the side extent).\n * Returns the world point plus a synthetic handle carrying only the `side`\n * (used for the outward normal).\n */\nfunction floatingAnchor(\n  self: FlowNode,\n  other: FlowNode,\n): { x: number; y: number; handleLike: HandleDef } {\n  const sx = self.position.x, sy = self.position.y;\n  const sw = self.width, sh = self.height;\n  const sCx = sx + sw / 2, sCy = sy + sh / 2;\n  let oCx = other.position.x + other.width / 2;\n  let oCy = other.position.y + other.height / 2;\n\n  const deg = self.data.rotation ?? 0;\n  if (deg !== 0) {\n    // Work in the node's local (unrotated) frame: rotate the other node's\n    // center into that frame so side-picking and the slide-to-align run in the\n    // same space the anchor is computed in. The anchor is mapped back to world\n    // space below via `handleToWorld`, so it rides on the rotated border.\n    const rad = (deg * Math.PI) / 180;\n    const cos = Math.cos(-rad), sin = Math.sin(-rad);\n    const dx = oCx - sCx;\n    const dy = oCy - sCy;\n    oCx = sCx + dx * cos - dy * sin;\n    oCy = sCy + dx * sin + dy * cos;\n  }\n\n  const dx = oCx - sCx;\n  const dy = oCy - sCy;\n  // Inset so the anchor never sits exactly on a corner.\n  const inset = Math.min(12, sw / 2 - 1, sh / 2 - 1);\n\n  let side: HandleDef['side'];\n  let x: number, y: number;\n  if (Math.abs(dx) >= Math.abs(dy)) {\n    side = dx >= 0 ? 'right' : 'left';\n    x = side === 'right' ? sx + sw : sx;\n    // Slide vertically to align with the other center, clamped to the side.\n    y = Math.max(sy + inset, Math.min(sy + sh - inset, oCy));\n  } else {\n    side = dy >= 0 ? 'bottom' : 'top';\n    y = side === 'bottom' ? sy + sh : sy;\n    x = Math.max(sx + inset, Math.min(sx + sw - inset, oCx));\n  }\n\n  if (deg !== 0) {\n    // Map the (locally chosen) anchor back onto the rotated border.\n    const pos = handleToWorld(x - sx, y - sy, self);\n    return { x: pos.x, y: pos.y, handleLike: { id: `float_${side}`, x: 0, y: 0, side } };\n  }\n\n  return { x, y, handleLike: { id: `float_${side}`, x: 0, y: 0, side } };\n}\n\n/**\n * Previously this pinned auto-resolved edges to a fixed middle handle at load\n * time, which forced ugly jogs between misaligned nodes. Edges without an\n * explicit handle are now left \"floating\" and resolved dynamically in\n * `resolveEdgeEndpoints` (see `floatingAnchor`), so this is a no-op that simply\n * preserves any user-pinned handles.\n */\nexport function normalizeEdgeHandles(\n  edges: FlowEdge[],\n  _nodeMap: Map<string, FlowNode>,\n): FlowEdge[] {\n  const legacyOffsets = new Map([\n    ['0.25', String(2 / 6)],\n    ['0.5', String(3 / 6)],\n    ['0.75', String(4 / 6)],\n  ]);\n  let changed = false;\n  const migrate = (handle: string | undefined) => {\n    if (!handle) return handle;\n    const [side, offset] = handle.split('_');\n    const nextOffset = legacyOffsets.get(offset);\n    if (!nextOffset || !side) return handle;\n    changed = true;\n    return `${side}_${nextOffset}`;\n  };\n  const normalized = edges.map(edge => {\n    const sourceHandle = migrate(edge.sourceHandle);\n    const targetHandle = migrate(edge.targetHandle);\n    return sourceHandle === edge.sourceHandle && targetHandle === edge.targetHandle\n      ? edge\n      : { ...edge, sourceHandle, targetHandle };\n  });\n  return changed ? normalized : edges;\n}\n\n/**\n * Convert PathSegments into a polyline by sampling curves.\n */\nexport function linearizeSegments(\n  segs: PathSegment[],\n  samplesPerCurve = 8,\n): Array<{ x: number; y: number }> {\n  const pts: Array<{ x: number; y: number }> = [];\n  let cx = 0, cy = 0;\n  for (const seg of segs) {\n    switch (seg.type) {\n      case 'M':\n      case 'L':\n        cx = seg.x; cy = seg.y;\n        pts.push({ x: cx, y: cy });\n        break;\n      case 'Q': {\n        const cpx = seg.cp1x!, cpy = seg.cp1y!;\n        for (let i = 1; i <= samplesPerCurve; i++) {\n          const t = i / samplesPerCurve, mt = 1 - t;\n          pts.push({\n            x: mt * mt * cx + 2 * mt * t * cpx + t * t * seg.x,\n            y: mt * mt * cy + 2 * mt * t * cpy + t * t * seg.y,\n          });\n        }\n        cx = seg.x; cy = seg.y;\n        break;\n      }\n      case 'C': {\n        const c1x = seg.cp1x!, c1y = seg.cp1y!, c2x = seg.cp2x!, c2y = seg.cp2y!;\n        for (let i = 1; i <= samplesPerCurve; i++) {\n          const t = i / samplesPerCurve, mt = 1 - t;\n          pts.push({\n            x: mt ** 3 * cx + 3 * mt ** 2 * t * c1x + 3 * mt * t ** 2 * c2x + t ** 3 * seg.x,\n            y: mt ** 3 * cy + 3 * mt ** 2 * t * c1y + 3 * mt * t ** 2 * c2y + t ** 3 * seg.y,\n          });\n        }\n        cx = seg.x; cy = seg.y;\n        break;\n      }\n    }\n  }\n  return pts;\n}\n"],"mappings":"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"}

package/dist/components/pro/Flow/hooks/useAlignmentGuides.js

@@ -1,55 +1,52 @@
-function C(y, b, i = 5) {
-  if (y.length === 0) return {
-    dx: 0,
-    dy: 0,
-    guides: []
-  };
-  const M = new Set(y.map((t) => t.id)), u = b.filter((t) => !M.has(t.id));
-  if (u.length === 0) return {
-    dx: 0,
-    dy: 0,
-    guides: []
-  };
-  let s = 1 / 0, e = -1 / 0, p = 1 / 0, a = -1 / 0;
-  for (const t of y)
-    s = Math.min(s, t.position.x), e = Math.max(e, t.position.x + t.width), p = Math.min(p, t.position.y), a = Math.max(a, t.position.y + t.height);
-  const I = (s + e) / 2, X = (p + a) / 2, r = [], h = [];
-  for (const t of u)
-    r.push(t.position.x, t.position.x + t.width / 2, t.position.x + t.width), h.push(t.position.y, t.position.y + t.height / 2, t.position.y + t.height);
-  const Y = [
-    s,
-    I,
-    e
-  ], w = [
-    p,
-    X,
-    a
-  ];
-  let m = 0, f = i + 1, x = null;
-  for (const t of Y) for (const n of r) {
-    const o = Math.abs(t - n);
-    o < f && (f = o, m = n - t, x = n);
-  }
-  let g = 0, c = i + 1, d = null;
-  for (const t of w) for (const n of h) {
-    const o = Math.abs(t - n);
-    o < c && (c = o, g = n - t, d = n);
-  }
-  const l = [], D = f <= i ? m : 0, S = c <= i ? g : 0;
-  return f <= i && x !== null && l.push({
-    type: "vertical",
-    position: x
-  }), c <= i && d !== null && l.push({
-    type: "horizontal",
-    position: d
-  }), {
-    dx: D,
-    dy: S,
-    guides: l
-  };
+//#region src/components/pro/Flow/hooks/useAlignmentGuides.ts
+function e(e, t, n = 5) {
+	if (e.length === 0) return {
+		dx: 0,
+		dy: 0,
+		guides: []
+	};
+	let r = new Set(e.map((e) => e.id)), i = t.filter((e) => !r.has(e.id));
+	if (i.length === 0) return {
+		dx: 0,
+		dy: 0,
+		guides: []
+	};
+	let a = Infinity, o = -Infinity, s = Infinity, c = -Infinity;
+	for (let t of e) a = Math.min(a, t.position.x), o = Math.max(o, t.position.x + t.width), s = Math.min(s, t.position.y), c = Math.max(c, t.position.y + t.height);
+	let l = (a + o) / 2, u = (s + c) / 2, d = [], f = [];
+	for (let e of i) d.push(e.position.x, e.position.x + e.width / 2, e.position.x + e.width), f.push(e.position.y, e.position.y + e.height / 2, e.position.y + e.height);
+	let p = [
+		a,
+		l,
+		o
+	], m = [
+		s,
+		u,
+		c
+	], h = 0, g = n + 1, _ = null;
+	for (let e of p) for (let t of d) {
+		let n = Math.abs(e - t);
+		n < g && (g = n, h = t - e, _ = t);
+	}
+	let v = 0, y = n + 1, b = null;
+	for (let e of m) for (let t of f) {
+		let n = Math.abs(e - t);
+		n < y && (y = n, v = t - e, b = t);
+	}
+	let x = [], S = g <= n ? h : 0, C = y <= n ? v : 0;
+	return g <= n && _ !== null && x.push({
+		type: "vertical",
+		position: _
+	}), y <= n && b !== null && x.push({
+		type: "horizontal",
+		position: b
+	}), {
+		dx: S,
+		dy: C,
+		guides: x
+	};
 }
-export {
-  C as computeAlignmentSnap
-};
+//#endregion
+export { e as computeAlignmentSnap };
 
 //# sourceMappingURL=useAlignmentGuides.js.map

package/dist/components/pro/Flow/hooks/useAlignmentGuides.js.map

@@ -1 +1 @@
-{"version":3,"file":"useAlignmentGuides.js","names":[],"sources":["../../../../../src/components/pro/Flow/hooks/useAlignmentGuides.ts"],"sourcesContent":["import { useMemo, useRef } from 'react';\nimport type { FlowNode } from '../types';\nimport { SNAP_THRESHOLD } from '../constants';\n\nexport interface AlignGuide {\n  type: 'vertical' | 'horizontal';\n  position: number;\n}\n\n/**\n * Computes alignment snap guides during node drag.\n * Returns snap offsets and guide lines to render.\n */\nexport function computeAlignmentSnap(\n  draggingNodes: FlowNode[],\n  allNodes: FlowNode[],\n  threshold = SNAP_THRESHOLD,\n): { dx: number; dy: number; guides: AlignGuide[] } {\n  if (draggingNodes.length === 0) return { dx: 0, dy: 0, guides: [] };\n\n  const dragIds = new Set(draggingNodes.map(n => n.id));\n  const staticNodes = allNodes.filter(n => !dragIds.has(n.id));\n\n  if (staticNodes.length === 0) return { dx: 0, dy: 0, guides: [] };\n\n  // Compute drag bounds\n  let minX = Infinity, maxX = -Infinity, minY = Infinity, maxY = -Infinity;\n  for (const n of draggingNodes) {\n    minX = Math.min(minX, n.position.x);\n    maxX = Math.max(maxX, n.position.x + n.width);\n    minY = Math.min(minY, n.position.y);\n    maxY = Math.max(maxY, n.position.y + n.height);\n  }\n  const dragCx = (minX + maxX) / 2;\n  const dragCy = (minY + maxY) / 2;\n\n  // Collect snap lines from static nodes\n  const xSnaps: number[] = [];\n  const ySnaps: number[] = [];\n  for (const n of staticNodes) {\n    xSnaps.push(n.position.x, n.position.x + n.width / 2, n.position.x + n.width);\n    ySnaps.push(n.position.y, n.position.y + n.height / 2, n.position.y + n.height);\n  }\n\n  // Dragging node snap points\n  const dragXPoints = [minX, dragCx, maxX];\n  const dragYPoints = [minY, dragCy, maxY];\n\n  let bestDx = 0;\n  let bestDistX = threshold + 1;\n  let snapXLine: number | null = null;\n\n  for (const dx of dragXPoints) {\n    for (const sx of xSnaps) {\n      const dist = Math.abs(dx - sx);\n      if (dist < bestDistX) {\n        bestDistX = dist;\n        bestDx = sx - dx;\n        snapXLine = sx;\n      }\n    }\n  }\n\n  let bestDy = 0;\n  let bestDistY = threshold + 1;\n  let snapYLine: number | null = null;\n\n  for (const dy of dragYPoints) {\n    for (const sy of ySnaps) {\n      const dist = Math.abs(dy - sy);\n      if (dist < bestDistY) {\n        bestDistY = dist;\n        bestDy = sy - dy;\n        snapYLine = sy;\n      }\n    }\n  }\n\n  const guides: AlignGuide[] = [];\n  const dx = bestDistX <= threshold ? bestDx : 0;\n  const dy = bestDistY <= threshold ? bestDy : 0;\n  if (bestDistX <= threshold && snapXLine !== null) guides.push({ type: 'vertical', position: snapXLine });\n  if (bestDistY <= threshold && snapYLine !== null) guides.push({ type: 'horizontal', position: snapYLine });\n\n  return { dx, dy, guides };\n}\n"],"mappings":"AAaA,SAAgB,EACd,GACA,GACA,IAAA,GACkD;AAClD,MAAI,EAAc,WAAW,EAAG,QAAO;AAAA,IAAE,IAAI;AAAA,IAAG,IAAI;AAAA,IAAG,QAAQ,CAAC;AAAA,EAAE;AAElE,QAAM,IAAU,IAAI,IAAI,EAAc,IAAA,CAAI,MAAK,EAAE,EAAE,CAAC,GAC9C,IAAc,EAAS,OAAA,CAAO,MAAK,CAAC,EAAQ,IAAI,EAAE,EAAE,CAAC;AAE3D,MAAI,EAAY,WAAW,EAAG,QAAO;AAAA,IAAE,IAAI;AAAA,IAAG,IAAI;AAAA,IAAG,QAAQ,CAAC;AAAA,EAAE;AAGhE,MAAI,IAAO,OAAU,IAAO,QAAW,IAAO,OAAU,IAAO;AAC/D,aAAW,KAAK;AACd,IAAA,IAAO,KAAK,IAAI,GAAM,EAAE,SAAS,CAAC,GAClC,IAAO,KAAK,IAAI,GAAM,EAAE,SAAS,IAAI,EAAE,KAAK,GAC5C,IAAO,KAAK,IAAI,GAAM,EAAE,SAAS,CAAC,GAClC,IAAO,KAAK,IAAI,GAAM,EAAE,SAAS,IAAI,EAAE,MAAM;AAE/C,QAAM,KAAU,IAAO,KAAQ,GACzB,KAAU,IAAO,KAAQ,GAGzB,IAAmB,CAAC,GACpB,IAAmB,CAAC;AAC1B,aAAW,KAAK;AACd,IAAA,EAAO,KAAK,EAAE,SAAS,GAAG,EAAE,SAAS,IAAI,EAAE,QAAQ,GAAG,EAAE,SAAS,IAAI,EAAE,KAAK,GAC5E,EAAO,KAAK,EAAE,SAAS,GAAG,EAAE,SAAS,IAAI,EAAE,SAAS,GAAG,EAAE,SAAS,IAAI,EAAE,MAAM;AAIhF,QAAM,IAAc;AAAA,IAAC;AAAA,IAAM;AAAA,IAAQ;AAAA,EAAI,GACjC,IAAc;AAAA,IAAC;AAAA,IAAM;AAAA,IAAQ;AAAA,EAAI;AAEvC,MAAI,IAAS,GACT,IAAY,IAAY,GACxB,IAA2B;AAE/B,aAAW,KAAM,EACf,YAAW,KAAM,GAAQ;AACvB,UAAM,IAAO,KAAK,IAAI,IAAK,CAAE;AAC7B,IAAI,IAAO,MACT,IAAY,GACZ,IAAS,IAAK,GACd,IAAY;AAAA,EAEhB;AAGF,MAAI,IAAS,GACT,IAAY,IAAY,GACxB,IAA2B;AAE/B,aAAW,KAAM,EACf,YAAW,KAAM,GAAQ;AACvB,UAAM,IAAO,KAAK,IAAI,IAAK,CAAE;AAC7B,IAAI,IAAO,MACT,IAAY,GACZ,IAAS,IAAK,GACd,IAAY;AAAA,EAEhB;AAGF,QAAM,IAAuB,CAAC,GACxB,IAAK,KAAa,IAAY,IAAS,GACvC,IAAK,KAAa,IAAY,IAAS;AAC7C,SAAI,KAAa,KAAa,MAAc,QAAM,EAAO,KAAK;AAAA,IAAE,MAAM;AAAA,IAAY,UAAU;AAAA,EAAU,CAAC,GACnG,KAAa,KAAa,MAAc,QAAM,EAAO,KAAK;AAAA,IAAE,MAAM;AAAA,IAAc,UAAU;AAAA,EAAU,CAAC,GAElG;AAAA,IAAE,IAAA;AAAA,IAAI,IAAA;AAAA,IAAI,QAAA;AAAA,EAAO;AAC1B"}
+{"version":3,"file":"useAlignmentGuides.js","names":[],"sources":["../../../../../src/components/pro/Flow/hooks/useAlignmentGuides.ts"],"sourcesContent":["import { useMemo, useRef } from 'react';\nimport type { FlowNode } from '../types';\nimport { SNAP_THRESHOLD } from '../constants';\n\nexport interface AlignGuide {\n  type: 'vertical' | 'horizontal';\n  position: number;\n}\n\n/**\n * Computes alignment snap guides during node drag.\n * Returns snap offsets and guide lines to render.\n */\nexport function computeAlignmentSnap(\n  draggingNodes: FlowNode[],\n  allNodes: FlowNode[],\n  threshold = SNAP_THRESHOLD,\n): { dx: number; dy: number; guides: AlignGuide[] } {\n  if (draggingNodes.length === 0) return { dx: 0, dy: 0, guides: [] };\n\n  const dragIds = new Set(draggingNodes.map(n => n.id));\n  const staticNodes = allNodes.filter(n => !dragIds.has(n.id));\n\n  if (staticNodes.length === 0) return { dx: 0, dy: 0, guides: [] };\n\n  // Compute drag bounds\n  let minX = Infinity, maxX = -Infinity, minY = Infinity, maxY = -Infinity;\n  for (const n of draggingNodes) {\n    minX = Math.min(minX, n.position.x);\n    maxX = Math.max(maxX, n.position.x + n.width);\n    minY = Math.min(minY, n.position.y);\n    maxY = Math.max(maxY, n.position.y + n.height);\n  }\n  const dragCx = (minX + maxX) / 2;\n  const dragCy = (minY + maxY) / 2;\n\n  // Collect snap lines from static nodes\n  const xSnaps: number[] = [];\n  const ySnaps: number[] = [];\n  for (const n of staticNodes) {\n    xSnaps.push(n.position.x, n.position.x + n.width / 2, n.position.x + n.width);\n    ySnaps.push(n.position.y, n.position.y + n.height / 2, n.position.y + n.height);\n  }\n\n  // Dragging node snap points\n  const dragXPoints = [minX, dragCx, maxX];\n  const dragYPoints = [minY, dragCy, maxY];\n\n  let bestDx = 0;\n  let bestDistX = threshold + 1;\n  let snapXLine: number | null = null;\n\n  for (const dx of dragXPoints) {\n    for (const sx of xSnaps) {\n      const dist = Math.abs(dx - sx);\n      if (dist < bestDistX) {\n        bestDistX = dist;\n        bestDx = sx - dx;\n        snapXLine = sx;\n      }\n    }\n  }\n\n  let bestDy = 0;\n  let bestDistY = threshold + 1;\n  let snapYLine: number | null = null;\n\n  for (const dy of dragYPoints) {\n    for (const sy of ySnaps) {\n      const dist = Math.abs(dy - sy);\n      if (dist < bestDistY) {\n        bestDistY = dist;\n        bestDy = sy - dy;\n        snapYLine = sy;\n      }\n    }\n  }\n\n  const guides: AlignGuide[] = [];\n  const dx = bestDistX <= threshold ? bestDx : 0;\n  const dy = bestDistY <= threshold ? bestDy : 0;\n  if (bestDistX <= threshold && snapXLine !== null) guides.push({ type: 'vertical', position: snapXLine });\n  if (bestDistY <= threshold && snapYLine !== null) guides.push({ type: 'horizontal', position: snapYLine });\n\n  return { dx, dy, guides };\n}\n"],"mappings":";AAaA,SAAgB,EACd,GACA,GACA,IAAA,GACkD;CAClD,IAAI,EAAc,WAAW,GAAG,OAAO;EAAE,IAAI;EAAG,IAAI;EAAG,QAAQ,CAAC;CAAE;CAElE,IAAM,IAAU,IAAI,IAAI,EAAc,KAAI,MAAK,EAAE,EAAE,CAAC,GAC9C,IAAc,EAAS,QAAO,MAAK,CAAC,EAAQ,IAAI,EAAE,EAAE,CAAC;CAE3D,IAAI,EAAY,WAAW,GAAG,OAAO;EAAE,IAAI;EAAG,IAAI;EAAG,QAAQ,CAAC;CAAE;CAGhE,IAAI,IAAO,UAAU,IAAO,WAAW,IAAO,UAAU,IAAO;CAC/D,KAAK,IAAM,KAAK,GAId,AAHA,IAAO,KAAK,IAAI,GAAM,EAAE,SAAS,CAAC,GAClC,IAAO,KAAK,IAAI,GAAM,EAAE,SAAS,IAAI,EAAE,KAAK,GAC5C,IAAO,KAAK,IAAI,GAAM,EAAE,SAAS,CAAC,GAClC,IAAO,KAAK,IAAI,GAAM,EAAE,SAAS,IAAI,EAAE,MAAM;CAE/C,IAAM,KAAU,IAAO,KAAQ,GACzB,KAAU,IAAO,KAAQ,GAGzB,IAAmB,CAAC,GACpB,IAAmB,CAAC;CAC1B,KAAK,IAAM,KAAK,GAEd,AADA,EAAO,KAAK,EAAE,SAAS,GAAG,EAAE,SAAS,IAAI,EAAE,QAAQ,GAAG,EAAE,SAAS,IAAI,EAAE,KAAK,GAC5E,EAAO,KAAK,EAAE,SAAS,GAAG,EAAE,SAAS,IAAI,EAAE,SAAS,GAAG,EAAE,SAAS,IAAI,EAAE,MAAM;CAIhF,IAAM,IAAc;EAAC;EAAM;EAAQ;CAAI,GACjC,IAAc;EAAC;EAAM;EAAQ;CAAI,GAEnC,IAAS,GACT,IAAY,IAAY,GACxB,IAA2B;CAE/B,KAAK,IAAM,KAAM,GACf,KAAK,IAAM,KAAM,GAAQ;EACvB,IAAM,IAAO,KAAK,IAAI,IAAK,CAAE;EAC7B,AAAI,IAAO,MACT,IAAY,GACZ,IAAS,IAAK,GACd,IAAY;CAEhB;CAGF,IAAI,IAAS,GACT,IAAY,IAAY,GACxB,IAA2B;CAE/B,KAAK,IAAM,KAAM,GACf,KAAK,IAAM,KAAM,GAAQ;EACvB,IAAM,IAAO,KAAK,IAAI,IAAK,CAAE;EAC7B,AAAI,IAAO,MACT,IAAY,GACZ,IAAS,IAAK,GACd,IAAY;CAEhB;CAGF,IAAM,IAAuB,CAAC,GACxB,IAAK,KAAa,IAAY,IAAS,GACvC,IAAK,KAAa,IAAY,IAAS;CAI7C,OAHI,KAAa,KAAa,MAAc,QAAM,EAAO,KAAK;EAAE,MAAM;EAAY,UAAU;CAAU,CAAC,GACnG,KAAa,KAAa,MAAc,QAAM,EAAO,KAAK;EAAE,MAAM;EAAc,UAAU;CAAU,CAAC,GAElG;EAAE;EAAI;EAAI;CAAO;AAC1B"}

package/dist/components/pro/Flow/hooks/useClipboard.js

@@ -1,157 +1,157 @@
-import { useFlowContext as N } from "../context/FlowContext.js";
-import { generateId as w } from "../nodes/nodeUtils.js";
-import { useCallback as f, useRef as R } from "react";
-function j() {
-  const { currentCanvas: l, selection: d, setDoc: I, currentCanvasId: g, setSelection: p } = N(), S = R(null), x = f(() => {
-    const o = l.nodes.filter((t) => d.nodeIds.has(t.id)), i = l.edges.filter((t) => d.edgeIds.has(t.id)), n = l.lines.filter((t) => d.lineIds.has(t.id)), r = new Set(o.map((t) => t.id)), h = l.edges.filter((t) => r.has(t.source) && r.has(t.target) && !d.edgeIds.has(t.id));
-    S.current = {
-      nodes: [...o],
-      edges: [...i, ...h],
-      lines: [...n]
-    };
-  }, [l, d]), M = f(() => {
-    x(), I((o) => {
-      const i = o.canvases[g];
-      return i ? {
-        ...o,
-        canvases: {
-          ...o.canvases,
-          [g]: {
-            ...i,
-            nodes: i.nodes.filter((n) => !d.nodeIds.has(n.id)),
-            edges: i.edges.filter((n) => !d.edgeIds.has(n.id) && !d.nodeIds.has(n.source) && !d.nodeIds.has(n.target)),
-            lines: i.lines.filter((n) => !d.lineIds.has(n.id))
-          }
-        }
-      } : o;
-    }), p({
-      nodeIds: /* @__PURE__ */ new Set(),
-      edgeIds: /* @__PURE__ */ new Set(),
-      lineIds: /* @__PURE__ */ new Set()
-    });
-  }, [
-    x,
-    I,
-    g,
-    d,
-    p
-  ]), E = f((o = 20, i = 20) => {
-    const n = S.current;
-    if (!n) return;
-    const r = /* @__PURE__ */ new Map(), h = n.nodes.map((s) => {
-      const a = w("node");
-      return r.set(s.id, a), {
-        ...s,
-        id: a,
-        position: {
-          x: s.position.x + o,
-          y: s.position.y + i
-        },
-        data: { ...s.data }
-      };
-    }), t = n.edges.filter((s) => r.has(s.source) && r.has(s.target)).map((s) => ({
-      ...s,
-      id: w("edge"),
-      source: r.get(s.source),
-      target: r.get(s.target),
-      data: { ...s.data }
-    })), m = n.lines.map((s) => ({
-      ...s,
-      id: w("line"),
-      points: s.points.map((a) => ({
-        x: a.x + o,
-        y: a.y + i
-      }))
-    }));
-    I((s) => {
-      const a = s.canvases[g];
-      return a ? {
-        ...s,
-        canvases: {
-          ...s.canvases,
-          [g]: {
-            ...a,
-            nodes: [...a.nodes, ...h],
-            edges: [...a.edges, ...t],
-            lines: [...a.lines, ...m]
-          }
-        }
-      } : s;
-    }), p({
-      nodeIds: new Set(h.map((s) => s.id)),
-      edgeIds: new Set(t.map((s) => s.id)),
-      lineIds: new Set(m.map((s) => s.id))
-    });
-  }, [
-    I,
-    g,
-    p
-  ]), L = S.current !== null;
-  return {
-    copy: x,
-    cut: M,
-    paste: E,
-    duplicate: f((o = 24, i = 24, n) => {
-      const r = n?.nodeIds ?? d.nodeIds, h = n?.edgeIds ?? d.edgeIds, t = n?.lineIds ?? d.lineIds, m = l.nodes.filter((e) => r.has(e.id)), s = l.lines.filter((e) => t.has(e.id)), a = new Set(m.map((e) => e.id)), C = l.edges.filter((e) => h.has(e.id) || a.has(e.source) && a.has(e.target));
-      if (m.length === 0 && s.length === 0 && C.length === 0) return;
-      const u = /* @__PURE__ */ new Map(), y = m.map((e) => {
-        const c = w("node");
-        return u.set(e.id, c), {
-          ...e,
-          id: c,
-          position: {
-            x: e.position.x + o,
-            y: e.position.y + i
-          },
-          data: { ...e.data }
-        };
-      });
-      for (const e of y) e.parentId && u.has(e.parentId) && (e.parentId = u.get(e.parentId));
-      const b = C.filter((e) => u.has(e.source) && u.has(e.target)).map((e) => ({
-        ...e,
-        id: w("edge"),
-        source: u.get(e.source),
-        target: u.get(e.target),
-        data: { ...e.data }
-      })), v = s.map((e) => ({
-        ...e,
-        id: w("line"),
-        points: e.points.map((c) => ({
-          x: c.x + o,
-          y: c.y + i
-        }))
-      }));
-      I((e) => {
-        const c = e.canvases[g];
-        return c ? {
-          ...e,
-          canvases: {
-            ...e.canvases,
-            [g]: {
-              ...c,
-              nodes: [...c.nodes, ...y],
-              edges: [...c.edges, ...b],
-              lines: [...c.lines, ...v]
-            }
-          }
-        } : e;
-      }), p({
-        nodeIds: new Set(y.map((e) => e.id)),
-        edgeIds: new Set(b.map((e) => e.id)),
-        lineIds: new Set(v.map((e) => e.id))
-      });
-    }, [
-      l,
-      d,
-      I,
-      g,
-      p
-    ]),
-    hasClipboard: L
-  };
+import { useFlowContext as e } from "../context/FlowContext.js";
+import { generateId as t } from "../nodes/nodeUtils.js";
+import { useCallback as n, useRef as r } from "react";
+//#region src/components/pro/Flow/hooks/useClipboard.ts
+function i() {
+	let { currentCanvas: i, selection: a, setDoc: o, currentCanvasId: s, setSelection: c } = e(), l = r(null), u = n(() => {
+		let e = i.nodes.filter((e) => a.nodeIds.has(e.id)), t = i.edges.filter((e) => a.edgeIds.has(e.id)), n = i.lines.filter((e) => a.lineIds.has(e.id)), r = new Set(e.map((e) => e.id)), o = i.edges.filter((e) => r.has(e.source) && r.has(e.target) && !a.edgeIds.has(e.id));
+		l.current = {
+			nodes: [...e],
+			edges: [...t, ...o],
+			lines: [...n]
+		};
+	}, [i, a]), d = n(() => {
+		u(), o((e) => {
+			let t = e.canvases[s];
+			return t ? {
+				...e,
+				canvases: {
+					...e.canvases,
+					[s]: {
+						...t,
+						nodes: t.nodes.filter((e) => !a.nodeIds.has(e.id)),
+						edges: t.edges.filter((e) => !a.edgeIds.has(e.id) && !a.nodeIds.has(e.source) && !a.nodeIds.has(e.target)),
+						lines: t.lines.filter((e) => !a.lineIds.has(e.id))
+					}
+				}
+			} : e;
+		}), c({
+			nodeIds: /* @__PURE__ */ new Set(),
+			edgeIds: /* @__PURE__ */ new Set(),
+			lineIds: /* @__PURE__ */ new Set()
+		});
+	}, [
+		u,
+		o,
+		s,
+		a,
+		c
+	]), f = n((e = 20, n = 20) => {
+		let r = l.current;
+		if (!r) return;
+		let i = /* @__PURE__ */ new Map(), a = r.nodes.map((r) => {
+			let a = t("node");
+			return i.set(r.id, a), {
+				...r,
+				id: a,
+				position: {
+					x: r.position.x + e,
+					y: r.position.y + n
+				},
+				data: { ...r.data }
+			};
+		}), u = r.edges.filter((e) => i.has(e.source) && i.has(e.target)).map((e) => ({
+			...e,
+			id: t("edge"),
+			source: i.get(e.source),
+			target: i.get(e.target),
+			data: { ...e.data }
+		})), d = r.lines.map((r) => ({
+			...r,
+			id: t("line"),
+			points: r.points.map((t) => ({
+				x: t.x + e,
+				y: t.y + n
+			}))
+		}));
+		o((e) => {
+			let t = e.canvases[s];
+			return t ? {
+				...e,
+				canvases: {
+					...e.canvases,
+					[s]: {
+						...t,
+						nodes: [...t.nodes, ...a],
+						edges: [...t.edges, ...u],
+						lines: [...t.lines, ...d]
+					}
+				}
+			} : e;
+		}), c({
+			nodeIds: new Set(a.map((e) => e.id)),
+			edgeIds: new Set(u.map((e) => e.id)),
+			lineIds: new Set(d.map((e) => e.id))
+		});
+	}, [
+		o,
+		s,
+		c
+	]), p = l.current !== null;
+	return {
+		copy: u,
+		cut: d,
+		paste: f,
+		duplicate: n((e = 24, n = 24, r) => {
+			let l = r?.nodeIds ?? a.nodeIds, u = r?.edgeIds ?? a.edgeIds, d = r?.lineIds ?? a.lineIds, f = i.nodes.filter((e) => l.has(e.id)), p = i.lines.filter((e) => d.has(e.id)), m = new Set(f.map((e) => e.id)), h = i.edges.filter((e) => u.has(e.id) || m.has(e.source) && m.has(e.target));
+			if (f.length === 0 && p.length === 0 && h.length === 0) return;
+			let g = /* @__PURE__ */ new Map(), _ = f.map((r) => {
+				let i = t("node");
+				return g.set(r.id, i), {
+					...r,
+					id: i,
+					position: {
+						x: r.position.x + e,
+						y: r.position.y + n
+					},
+					data: { ...r.data }
+				};
+			});
+			for (let e of _) e.parentId && g.has(e.parentId) && (e.parentId = g.get(e.parentId));
+			let v = h.filter((e) => g.has(e.source) && g.has(e.target)).map((e) => ({
+				...e,
+				id: t("edge"),
+				source: g.get(e.source),
+				target: g.get(e.target),
+				data: { ...e.data }
+			})), y = p.map((r) => ({
+				...r,
+				id: t("line"),
+				points: r.points.map((t) => ({
+					x: t.x + e,
+					y: t.y + n
+				}))
+			}));
+			o((e) => {
+				let t = e.canvases[s];
+				return t ? {
+					...e,
+					canvases: {
+						...e.canvases,
+						[s]: {
+							...t,
+							nodes: [...t.nodes, ..._],
+							edges: [...t.edges, ...v],
+							lines: [...t.lines, ...y]
+						}
+					}
+				} : e;
+			}), c({
+				nodeIds: new Set(_.map((e) => e.id)),
+				edgeIds: new Set(v.map((e) => e.id)),
+				lineIds: new Set(y.map((e) => e.id))
+			});
+		}, [
+			i,
+			a,
+			o,
+			s,
+			c
+		]),
+		hasClipboard: p
+	};
 }
-export {
-  j as useClipboard
-};
+//#endregion
+export { i as useClipboard };
 
 //# sourceMappingURL=useClipboard.js.map