jvs-ppt-ui 0.0.8 → 0.0.9

package/src/utils/line.ts

@@ -150,143 +150,246 @@ export function getLinePointByOffset(
   ] as [number, number]
 }
 
+function getElementBox(el: any, fallbackPt: [number, number], logWidth = 1000, logHeight = 562.5) {
+  if (!el) {
+    return { left: fallbackPt[0] - 10, right: fallbackPt[0] + 10, top: fallbackPt[1] - 10, bottom: fallbackPt[1] + 10 }
+  }
+  const style = el.style || {}
+  const left = getPxVal(style.left || el.left, logWidth)
+  const top = getPxVal(style.top || el.top, logHeight)
+  const width = getPxVal(style.width || el.width, logWidth) || 20
+  const height = getPxVal(style.height || el.height, logHeight) || 20
+  return { left, top, right: left + width, bottom: top + height }
+}
+
+function getAnchorNormal(idx: number | undefined, isEllipse = false): [number, number] | null {
+  if (idx === undefined) return null
+  if (isEllipse) {
+    if (idx === 0) return [0, -1]
+    if (idx === 1) return [-1, -1]
+    if (idx === 2) return [-1, 0]
+    if (idx === 3) return [-1, 1]
+    if (idx === 4) return [0, 1]
+    if (idx === 5) return [1, 1]
+    if (idx === 6) return [1, 0]
+    if (idx === 7) return [1, -1]
+  } else {
+    const k = idx % 4
+    if (k === 0) return [0, -1]
+    if (k === 1) return [-1, 0]
+    if (k === 2) return [0, 1]
+    if (k === 3) return [1, 0]
+  }
+  return null
+}
+
 function getDefaultOrthogonalTurnPoints(
   x1: number, y1: number,
   x2: number, y2: number,
   element: any,
   startEl?: any,
-  endEl?: any
+  endEl?: any,
+  obstacles?: any[]
 ): [number, number][] {
-  let absTurnPoints: [number, number][] = []
+  const pad = 20
+  const isStartEllipse = isEllipseShape(startEl)
+  const isEndEllipse = isEllipseShape(endEl)
 
-  if (element.broken !== undefined) {
-    if (element.startConnection && element.endConnection) {
-      const idx1 = element.startConnection.idx
-      const idx2 = element.endConnection.idx
-      
-      const isStartEllipse = isEllipseShape(startEl)
-      const isEndEllipse = isEllipseShape(endEl)
-      
-      let isStartHoriz = (idx1 === 1 || idx1 === 3)
-      if (isStartEllipse) {
-        isStartHoriz = (idx1 === 2 || idx1 === 6)
-      }
-      
-      let isEndHoriz = (idx2 === 1 || idx2 === 3)
-      if (isEndEllipse) {
-        isEndHoriz = (idx2 === 2 || idx2 === 6)
-      }
+  const sBox = getElementBox(startEl, [x1, y1])
+  const eBox = getElementBox(endEl, [x2, y2])
+
+  const idx1 = element.startConnection?.idx
+  const idx2 = element.endConnection?.idx
+
+  let sNorm = getAnchorNormal(idx1, isStartEllipse)
+  let eNorm = getAnchorNormal(idx2, isEndEllipse)
+
+  let eEntryNorm: [number, number] | null = eNorm ? [-eNorm[0], -eNorm[1]] : null
+
+  if (!sNorm && !eEntryNorm) {
+    if (Math.abs(x2 - x1) >= Math.abs(y2 - y1)) {
+      return [[x2, y1]]
+    } else {
+      return [[x1, y2]]
+    }
+  }
+
+  if (!sNorm && eEntryNorm) {
+    sNorm = eEntryNorm[0] !== 0 ? [0, y2 >= y1 ? 1 : -1] : [x2 >= x1 ? 1 : -1, 0]
+  } else if (sNorm && !eEntryNorm) {
+    eEntryNorm = sNorm[0] !== 0 ? [0, y2 >= y1 ? 1 : -1] : [x2 >= x1 ? 1 : -1, 0]
+  }
+
+  if (!sNorm || !eEntryNorm) return [[(x1 + x2) / 2, y1], [(x1 + x2) / 2, y2]]
+
+  const sDx = sNorm[0]
+  const sDy = sNorm[1]
+  const eDx = eEntryNorm[0]
+  const eDy = eEntryNorm[1]
+
+  // 1. Can we do a clean 1-turn (L-shape)?
+  if (sDx !== 0 && sDy === 0 && eDx === 0 && eDy !== 0) {
+    if ((x2 - x1) * sDx > 0 && (y2 - y1) * eDy > 0) {
+      return [[x2, y1]]
+    }
+  }
+  if (sDy !== 0 && sDx === 0 && eDy === 0 && eDx !== 0) {
+    if ((y2 - y1) * sDy > 0 && (x2 - x1) * eDx > 0) {
+      return [[x1, y2]]
+    }
+  }
+
+  // 2. Parallel cases
+  if (sDx !== 0 && sDy === 0 && eDx !== 0 && eDy === 0) {
+    if (sDx === eDx) {
+      const mx = sDx > 0 ? Math.max(x1, x2, sBox.right, eBox.right) + pad : Math.min(x1, x2, sBox.left, eBox.left) - pad
+      return [[mx, y1], [mx, y2]]
+    } else if ((x2 - x1) * sDx > 0) {
+      const mx = (x1 + x2) / 2
+      return [[mx, y1], [mx, y2]]
+    }
+  }
 
-      if (isStartHoriz && !isEndHoriz) {
-        absTurnPoints = [[x2, y1]]
-      } else if (!isStartHoriz && isEndHoriz) {
-        absTurnPoints = [[x1, y2]]
-      } else if (isStartHoriz && isEndHoriz) {
-        let mx = (x1 + x2) / 2
-        if (idx1 === idx2) {
-          const isRight = (idx1 === 3 && !isStartEllipse) || (idx1 === 6 && isStartEllipse)
-          const isLeft = (idx1 === 1 && !isStartEllipse) || (idx1 === 2 && isStartEllipse)
-          if (isRight) mx = Math.max(x1, x2) + 30
-          else if (isLeft) mx = Math.min(x1, x2) - 30
+  if (sDy !== 0 && sDx === 0 && eDy !== 0 && eDx === 0) {
+    if (sDy === eDy) {
+      const my = sDy > 0 ? Math.max(y1, y2, sBox.bottom, eBox.bottom) + pad : Math.min(y1, y2, sBox.top, eBox.top) - pad
+      return [[x1, my], [x2, my]]
+    } else if ((y2 - y1) * sDy > 0) {
+      const my = (y1 + y2) / 2
+      return [[x1, my], [x2, my]]
+    }
+  }
+
+  // 3. Perpendicular wrap-around (Start H, End V)
+  if (sDx !== 0 && eDy !== 0) {
+    const xExit = sDx > 0 ? Math.max(x1 + pad, sBox.right + pad) : Math.min(x1 - pad, sBox.left - pad)
+    let yMid: number
+    if (eDy > 0) {
+      if (y2 > sBox.bottom + pad) {
+        yMid = (sBox.bottom + y2) / 2
+        if (obstacles && obstacles.length > 0 && isSegmentObstructed(xExit, yMid, x2, yMid, obstacles)) {
+          const inBetween = obstacles.filter(obs => obs.bottom > sBox.bottom && obs.top < y2)
+          for (const obs of inBetween) {
+            const candidateAbove = (sBox.bottom + obs.top) / 2
+            if (!isSegmentObstructed(xExit, candidateAbove, x2, candidateAbove, obstacles)) {
+              yMid = candidateAbove
+              break
+            }
+            const candidateBelow = (obs.bottom + y2) / 2
+            if (!isSegmentObstructed(xExit, candidateBelow, x2, candidateBelow, obstacles)) {
+              yMid = candidateBelow
+              break
+            }
+          }
         }
-        absTurnPoints = [[mx, y1], [mx, y2]]
       } else {
-        let my = (y1 + y2) / 2
-        if (idx1 === idx2) {
-          const isBottom = (idx1 === 2 && !isStartEllipse) || (idx1 === 4 && isStartEllipse)
-          const isTop = (idx1 === 0 && !isStartEllipse) || (idx1 === 0 && isStartEllipse)
-          if (isBottom) my = Math.max(y1, y2) + 30
-          else if (isTop) my = Math.min(y1, y2) - 30
-        }
-        absTurnPoints = [[x1, my], [x2, my]]
+        yMid = Math.min(sBox.top - pad, eBox.top - pad)
       }
     } else {
-      if (Math.abs(x2 - x1) >= Math.abs(y2 - y1)) {
-        absTurnPoints = [[x2, y1]]
+      if (y2 < sBox.top - pad) {
+        yMid = (sBox.top + y2) / 2
+        if (obstacles && obstacles.length > 0 && isSegmentObstructed(xExit, yMid, x2, yMid, obstacles)) {
+          const inBetween = obstacles.filter(obs => obs.top < sBox.top && obs.bottom > y2)
+          for (const obs of inBetween) {
+            const candidateBelow = (sBox.top + obs.bottom) / 2
+            if (!isSegmentObstructed(xExit, candidateBelow, x2, candidateBelow, obstacles)) {
+              yMid = candidateBelow
+              break
+            }
+            const candidateAbove = (obs.top + y2) / 2
+            if (!isSegmentObstructed(xExit, candidateAbove, x2, candidateAbove, obstacles)) {
+              yMid = candidateAbove
+              break
+            }
+          }
+        }
       } else {
-        absTurnPoints = [[x1, y2]]
+        yMid = Math.max(sBox.bottom + pad, eBox.bottom + pad)
       }
     }
-  } else if (element.broken2 !== undefined) {
-    if (element.startConnection && !element.endConnection) {
-      const isStartEllipse = isEllipseShape(startEl)
-      const idx1 = element.startConnection.idx
-      let isStartHoriz = (idx1 === 1 || idx1 === 3)
-      if (isStartEllipse) {
-        isStartHoriz = (idx1 === 2 || idx1 === 6)
-      }
-      if (isStartHoriz) {
-        const mx = (x1 + x2) / 2
-        absTurnPoints = [[mx, y1], [mx, y2]]
-      } else {
-        const my = (y1 + y2) / 2
-        absTurnPoints = [[x1, my], [x2, my]]
-      }
-    } else if (!element.startConnection && element.endConnection) {
-      const isEndEllipse = isEllipseShape(endEl)
-      const idx2 = element.endConnection.idx
-      let isEndHoriz = (idx2 === 1 || idx2 === 3)
-      if (isEndEllipse) {
-        isEndHoriz = (idx2 === 2 || idx2 === 6)
-      }
-      if (isEndHoriz) {
-        const mx = (x1 + x2) / 2
-        absTurnPoints = [[mx, y1], [mx, y2]]
-      } else {
-        const my = (y1 + y2) / 2
-        absTurnPoints = [[x1, my], [x2, my]]
-      }
-    } else if (element.startConnection && element.endConnection) {
-      const isStartEllipse = isEllipseShape(startEl)
-      const isEndEllipse = isEllipseShape(endEl)
-      const idx1 = element.startConnection.idx
-      const idx2 = element.endConnection.idx
-
-      let isStartHoriz = (idx1 === 1 || idx1 === 3)
-      if (isStartEllipse) {
-        isStartHoriz = (idx1 === 2 || idx1 === 6)
-      }
-
-      let isEndHoriz = (idx2 === 1 || idx2 === 3)
-      if (isEndEllipse) {
-        isEndHoriz = (idx2 === 2 || idx2 === 6)
-      }
+    return [
+      [xExit, y1],
+      [xExit, yMid],
+      [x2, yMid]
+    ]
+  }
 
-      if (isStartHoriz && isEndHoriz) {
-        let mx = (x1 + x2) / 2
-        if (idx1 === idx2) {
-          const isRight = (idx1 === 3 && !isStartEllipse) || (idx1 === 6 && isStartEllipse)
-          const isLeft = (idx1 === 1 && !isStartEllipse) || (idx1 === 2 && isStartEllipse)
-          if (isRight) mx = Math.max(x1, x2) + 30
-          else if (isLeft) mx = Math.min(x1, x2) - 30
-        }
-        absTurnPoints = [[mx, y1], [mx, y2]]
-      } else if (!isStartHoriz && !isEndHoriz) {
-        let my = (y1 + y2) / 2
-        if (idx1 === idx2) {
-          const isBottom = (idx1 === 2 && !isStartEllipse) || (idx1 === 4 && isStartEllipse)
-          const isTop = (idx1 === 0 && !isStartEllipse) || (idx1 === 0 && isStartEllipse)
-          if (isBottom) my = Math.max(y1, y2) + 30
-          else if (isTop) my = Math.min(y1, y2) - 30
+  // 4. Perpendicular wrap-around (Start V, End H)
+  if (sDy !== 0 && eDx !== 0) {
+    const yExit = sDy > 0 ? Math.max(y1 + pad, sBox.bottom + pad) : Math.min(y1 - pad, sBox.top - pad)
+    let xMid: number
+    if (eDx > 0) {
+      if (x2 > sBox.right + pad) {
+        xMid = (sBox.right + x2) / 2
+        if (obstacles && obstacles.length > 0 && isSegmentObstructed(xMid, yExit, xMid, y2, obstacles)) {
+          const inBetween = obstacles.filter(obs => obs.right > sBox.right && obs.left < x2)
+          for (const obs of inBetween) {
+            const candidateLeft = (sBox.right + obs.left) / 2
+            if (!isSegmentObstructed(candidateLeft, yExit, candidateLeft, y2, obstacles)) {
+              xMid = candidateLeft
+              break
+            }
+            const candidateRight = (obs.right + x2) / 2
+            if (!isSegmentObstructed(candidateRight, yExit, candidateRight, y2, obstacles)) {
+              xMid = candidateRight
+              break
+            }
+          }
         }
-        absTurnPoints = [[x1, my], [x2, my]]
-      } else if (isStartHoriz && !isEndHoriz) {
-        absTurnPoints = [[x2, y1]]
       } else {
-        absTurnPoints = [[x1, y2]]
+        xMid = Math.min(sBox.left - pad, eBox.left - pad)
       }
     } else {
-      const dir = getBroken2Direction(element)
-      if (dir === 'horizontal') {
-        const mx = (x1 + x2) / 2
-        absTurnPoints = [[mx, y1], [mx, y2]]
+      if (x2 < sBox.left - pad) {
+        xMid = (sBox.left + x2) / 2
+        if (obstacles && obstacles.length > 0 && isSegmentObstructed(xMid, yExit, xMid, y2, obstacles)) {
+          const inBetween = obstacles.filter(obs => obs.left < sBox.left && obs.right > x2)
+          for (const obs of inBetween) {
+            const candidateRight = (sBox.left + obs.right) / 2
+            if (!isSegmentObstructed(candidateRight, yExit, candidateRight, y2, obstacles)) {
+              xMid = candidateRight
+              break
+            }
+            const candidateLeft = (obs.left + x2) / 2
+            if (!isSegmentObstructed(candidateLeft, yExit, candidateLeft, y2, obstacles)) {
+              xMid = candidateLeft
+              break
+            }
+          }
+        }
       } else {
-        const my = (y1 + y2) / 2
-        absTurnPoints = [[x1, my], [x2, my]]
+        xMid = Math.max(sBox.right + pad, eBox.right + pad)
       }
     }
+    return [
+      [x1, yExit],
+      [xMid, yExit],
+      [xMid, y2]
+    ]
+  }
+
+  // 5. Parallel facing opposite directions and e is behind s
+  if (sDx !== 0) {
+    const xExit = sDx > 0 ? Math.max(x1 + pad, sBox.right + pad) : Math.min(x1 - pad, sBox.left - pad)
+    const yAround = y1 < y2 ? Math.min(sBox.top - pad, eBox.top - pad) : Math.max(sBox.bottom + pad, eBox.bottom + pad)
+    const xEntry = eDx > 0 ? Math.min(x2 - pad, eBox.left - pad) : Math.max(x2 + pad, eBox.right + pad)
+    return [
+      [xExit, y1],
+      [xExit, yAround],
+      [xEntry, yAround],
+      [xEntry, y2]
+    ]
+  } else {
+    const yExit = sDy > 0 ? Math.max(y1 + pad, sBox.bottom + pad) : Math.min(y1 - pad, sBox.top - pad)
+    const xAround = x1 < x2 ? Math.min(sBox.left - pad, eBox.left - pad) : Math.max(sBox.right + pad, eBox.right + pad)
+    const yEntry = eDy > 0 ? Math.min(y2 - pad, eBox.top - pad) : Math.max(y2 + pad, eBox.bottom + pad)
+    return [
+      [x1, yExit],
+      [xAround, yExit],
+      [xAround, yEntry],
+      [x2, yEntry]
+    ]
   }
-  return absTurnPoints
 }
 
 export function getLinePathTurningPoints(
@@ -297,25 +400,34 @@ export function getLinePathTurningPoints(
 ): [number, number][] {
   const isCustom = element.customControlPoints
 
-  const leftPx = getPxVal(element.style.left, 1000)
-  const topPx = getPxVal(element.style.top, 562.5)
+  const leftPx = getPxVal(element.style?.left || element.left, 1000)
+  const topPx = getPxVal(element.style?.top || element.top, 562.5)
   const rawStart = Array.isArray(element.start) ? element.start : [0, 0]
   const rawEnd = Array.isArray(element.end) ? element.end : [getPxVal(element.style?.width || element.width, 1000) || 0, getPxVal(element.style?.height || element.height, 562.5) || 0]
   const s: [number, number] = absStart || [leftPx + rawStart[0], topPx + rawStart[1]]
   const e: [number, number] = absEnd || [leftPx + rawEnd[0], topPx + rawEnd[1]]
 
-  const startEl = (element.startConnection && elements) ? elements.find(item => item.id === element.startConnection.id) : null
-  const endEl = (element.endConnection && elements) ? elements.find(item => item.id === element.endConnection.id) : null
-  const isStartEllipse = isEllipseShape(startEl)
-  const isEndEllipse = isEllipseShape(endEl)
+  const findElementRecursive = (list: any[], id: string): any => {
+    for (const it of list) {
+      if (!it) continue
+      if (String(it.id) === String(id)) return it
+      if (it.type === 'group' && Array.isArray(it.elements)) {
+        const found = findElementRecursive(it.elements, id)
+        if (found) return found
+      }
+    }
+    return null
+  }
+  const startEl = (element.startConnection && elements) ? findElementRecursive(elements, element.startConnection.id) : null
+  const endEl = (element.endConnection && elements) ? findElementRecursive(elements, element.endConnection.id) : null
 
-  if (!isCustom && elements && elements.length > 0 && (element.broken !== undefined || element.broken2 !== undefined)) {
-    const obstacles = getSlideObstacles(element, elements)
-    if (obstacles.length > 0) {
-      // 1. Calculate the default orthogonal path turning points first
-      const defaultTurnPoints = getDefaultOrthogonalTurnPoints(s[0], s[1], e[0], e[1], element, startEl, endEl)
+  let absTurnPoints: [number, number][] = []
 
-      // 2. Check if the default path is obstructed
+  if (!isCustom && (element.broken !== undefined || element.broken2 !== undefined)) {
+    const obstacles = (elements && elements.length > 0) ? getSlideObstacles(element, elements) : []
+    const defaultTurnPoints = getDefaultOrthogonalTurnPoints(s[0], s[1], e[0], e[1], element, startEl, endEl, obstacles)
+
+    if (obstacles.length > 0) {
       const defaultPathPoints = [s, ...defaultTurnPoints, e]
       let defaultObstructed = false
       for (let i = 0; i < defaultPathPoints.length - 1; i++) {
@@ -325,176 +437,36 @@ export function getLinePathTurningPoints(
         }
       }
 
-      // 3. If default path is NOT obstructed, use it! It's perfectly stable and uses midpoint.
       if (!defaultObstructed) {
-        if (absStart && absEnd) {
-          return defaultTurnPoints
-        } else {
-          return defaultTurnPoints.map(pt => [pt[0] - leftPx, pt[1] - topPx])
-        }
-      }
-
-      // 4. Otherwise, run A* to avoid the obstacle
-      const idx1 = element.startConnection?.idx
-      const idx2 = element.endConnection?.idx
-      const astarPath = routeAvoidObstacles(s[0], s[1], e[0], e[1], idx1, idx2, obstacles, startEl, endEl)
-      if (astarPath && astarPath.length >= 2) {
-        const absTurnPoints = astarPath.slice(1, -1)
-        if (absStart && absEnd) {
-          return absTurnPoints
-        } else {
-          return absTurnPoints.map(pt => [pt[0] - leftPx, pt[1] - topPx])
-        }
-      }
-    }
-  }
-
-  const x1 = s[0]
-  const y1 = s[1]
-  const x2 = e[0]
-  const y2 = e[1]
-
-  let absTurnPoints: [number, number][] = []
-
-  if (element.broken !== undefined) {
-    if (isCustom && element.broken) {
-      const absB: [number, number] = [leftPx + element.broken[0], topPx + element.broken[1]]
-      absTurnPoints = [absB]
-    } else {
-      if (element.startConnection && element.endConnection) {
-        const idx1 = element.startConnection.idx
-        const idx2 = element.endConnection.idx
-        
-        let isStartHoriz = (idx1 === 1 || idx1 === 3)
-        if (isStartEllipse) {
-          isStartHoriz = (idx1 === 2 || idx1 === 6)
-        }
-        
-        let isEndHoriz = (idx2 === 1 || idx2 === 3)
-        if (isEndEllipse) {
-          isEndHoriz = (idx2 === 2 || idx2 === 6)
-        }
-
-        if (isStartHoriz && !isEndHoriz) {
-          absTurnPoints = [[x2, y1]]
-        } else if (!isStartHoriz && isEndHoriz) {
-          absTurnPoints = [[x1, y2]]
-        } else if (isStartHoriz && isEndHoriz) {
-          let mx = (x1 + x2) / 2
-          if (idx1 === idx2) {
-            const isRight = (idx1 === 3 && !isStartEllipse) || (idx1 === 6 && isStartEllipse)
-            const isLeft = (idx1 === 1 && !isStartEllipse) || (idx1 === 2 && isStartEllipse)
-            if (isRight) mx = Math.max(x1, x2) + 30
-            else if (isLeft) mx = Math.min(x1, x2) - 30
-          }
-          absTurnPoints = [[mx, y1], [mx, y2]]
-        } else {
-          let my = (y1 + y2) / 2
-          if (idx1 === idx2) {
-            const isBottom = (idx1 === 2 && !isStartEllipse) || (idx1 === 4 && isStartEllipse)
-            const isTop = (idx1 === 0 && !isStartEllipse) || (idx1 === 0 && isStartEllipse)
-            if (isBottom) my = Math.max(y1, y2) + 30
-            else if (isTop) my = Math.min(y1, y2) - 30
-          }
-          absTurnPoints = [[x1, my], [x2, my]]
-        }
+        absTurnPoints = defaultTurnPoints
       } else {
-        if (Math.abs(x2 - x1) >= Math.abs(y2 - y1)) {
-          absTurnPoints = [[x2, y1]]
+        const idx1 = element.startConnection?.idx
+        const idx2 = element.endConnection?.idx
+        const astarPath = routeAvoidObstacles(s[0], s[1], e[0], e[1], idx1, idx2, obstacles, startEl, endEl)
+        if (astarPath && astarPath.length >= 2) {
+          absTurnPoints = astarPath.slice(1, -1)
         } else {
-          absTurnPoints = [[x1, y2]]
+          absTurnPoints = defaultTurnPoints
         }
       }
+    } else {
+      absTurnPoints = defaultTurnPoints
     }
-  } else if (element.broken2 !== undefined) {
-    if (isCustom && element.broken2) {
-      const dir = getBroken2Direction(element)
-      const absB2: [number, number] = [leftPx + element.broken2[0], topPx + element.broken2[1]]
-      if (dir === 'horizontal') {
-        absTurnPoints = [
-          [absB2[0], y1],
-          [absB2[0], y2]
-        ]
-      } else {
-        absTurnPoints = [
-          [x1, absB2[1]],
-          [x2, absB2[1]]
-        ]
-      }
+  } else if (isCustom && element.broken !== undefined && element.broken) {
+    absTurnPoints = [[leftPx + element.broken[0], topPx + element.broken[1]]]
+  } else if (isCustom && element.broken2 !== undefined && element.broken2) {
+    const dir = getBroken2Direction(element)
+    const absB2: [number, number] = [leftPx + element.broken2[0], topPx + element.broken2[1]]
+    if (dir === 'horizontal') {
+      absTurnPoints = [
+        [absB2[0], s[1]],
+        [absB2[0], e[1]]
+      ]
     } else {
-      if (element.startConnection && !element.endConnection) {
-        const idx1 = element.startConnection.idx
-        let isStartHoriz = (idx1 === 1 || idx1 === 3)
-        if (isStartEllipse) {
-          isStartHoriz = (idx1 === 2 || idx1 === 6)
-        }
-        if (isStartHoriz) {
-          const mx = (x1 + x2) / 2
-          absTurnPoints = [[mx, y1], [mx, y2]]
-        } else {
-          const my = (y1 + y2) / 2
-          absTurnPoints = [[x1, my], [x2, my]]
-        }
-      } else if (!element.startConnection && element.endConnection) {
-        const idx2 = element.endConnection.idx
-        let isEndHoriz = (idx2 === 1 || idx2 === 3)
-        if (isEndEllipse) {
-          isEndHoriz = (idx2 === 2 || idx2 === 6)
-        }
-        if (isEndHoriz) {
-          const mx = (x1 + x2) / 2
-          absTurnPoints = [[mx, y1], [mx, y2]]
-        } else {
-          const my = (y1 + y2) / 2
-          absTurnPoints = [[x1, my], [x2, my]]
-        }
-      } else if (element.startConnection && element.endConnection) {
-        const idx1 = element.startConnection.idx
-        const idx2 = element.endConnection.idx
-
-        let isStartHoriz = (idx1 === 1 || idx1 === 3)
-        if (isStartEllipse) {
-          isStartHoriz = (idx1 === 2 || idx1 === 6)
-        }
-
-        let isEndHoriz = (idx2 === 1 || idx2 === 3)
-        if (isEndEllipse) {
-          isEndHoriz = (idx2 === 2 || idx2 === 6)
-        }
-
-        if (isStartHoriz && isEndHoriz) {
-          let mx = (x1 + x2) / 2
-          if (idx1 === idx2) {
-            const isRight = (idx1 === 3 && !isStartEllipse) || (idx1 === 6 && isStartEllipse)
-            const isLeft = (idx1 === 1 && !isStartEllipse) || (idx1 === 2 && isStartEllipse)
-            if (isRight) mx = Math.max(x1, x2) + 30
-            else if (isLeft) mx = Math.min(x1, x2) - 30
-          }
-          absTurnPoints = [[mx, y1], [mx, y2]]
-        } else if (!isStartHoriz && !isEndHoriz) {
-          let my = (y1 + y2) / 2
-          if (idx1 === idx2) {
-            const isBottom = (idx1 === 2 && !isStartEllipse) || (idx1 === 4 && isStartEllipse)
-            const isTop = (idx1 === 0 && !isStartEllipse) || (idx1 === 0 && isStartEllipse)
-            if (isBottom) my = Math.max(y1, y2) + 30
-            else if (isTop) my = Math.min(y1, y2) - 30
-          }
-          absTurnPoints = [[x1, my], [x2, my]]
-        } else if (isStartHoriz && !isEndHoriz) {
-          absTurnPoints = [[x2, y1]]
-        } else {
-          absTurnPoints = [[x1, y2]]
-        }
-      } else {
-        const dir = getBroken2Direction(element)
-        if (dir === 'horizontal') {
-          const mx = (x1 + x2) / 2
-          absTurnPoints = [[mx, y1], [mx, y2]]
-        } else {
-          const my = (y1 + y2) / 2
-          absTurnPoints = [[x1, my], [x2, my]]
-        }
-      }
+      absTurnPoints = [
+        [s[0], absB2[1]],
+        [e[0], absB2[1]]
+      ]
     }
   } else if (element.curve) {
     absTurnPoints = [[leftPx + element.curve[0], topPx + element.curve[1]]]
@@ -643,6 +615,8 @@ export function getSvgWidth(el: any) {
       }
     }
   }
+  const styleW = getPxVal(el.style?.width || el.width, 1000)
+  if (styleW && styleW > 0) return Math.max(24, styleW)
   const width = Math.abs((el.start ? el.start[0] : 0) - (el.end ? el.end[0] : 0))
   return width < 24 ? 24 : width
 }
@@ -664,6 +638,8 @@ export function getSvgHeight(el: any) {
       }
     }
   }
+  const styleH = getPxVal(el.style?.height || el.height, 562.5)
+  if (styleH && styleH > 0) return Math.max(24, styleH)
   const height = Math.abs((el.start ? el.start[1] : 0) - (el.end ? el.end[1] : 0))
   return height < 24 ? 24 : height
 }
@@ -702,9 +678,6 @@ export function isStandardShapeType(target: any): boolean {
   if (target.type && target.type !== 'shape' && target.type !== 'text') return false
 
   const shapType = String(target.shapType || target.pathFormula || '').toLowerCase()
-  if (!shapType) {
-    return !!target.pathFormula || target.viewBox?.[0] === 200
-  }
 
   // 明确排除非标准自定义/自由多边形
   if (shapType === 'custom' || shapType.startsWith('custom:') || /freeform/i.test(shapType) || shapType === 'unknown') {
@@ -848,15 +821,12 @@ function getSlideObstacles(element: any, elements: any[]) {
   const logWidth = 1000
   const logHeight = 562.5
 
-  const startId = element.startConnection?.id
-  const endId = element.endConnection?.id
+  const lineId = String(element.id)
 
   for (const el of elements) {
-    if (el.id === element.id) continue
-    if (el.id !== startId && el.id !== endId) continue
+    if (!el || String(el.id) === lineId) continue
     if (el.type !== 'shape' && el.type !== 'text' && el.type !== 'image') continue
 
-    if (!el) continue
     const style = el.style || {}
     const left = getPxVal(style.left || el.left, logWidth)
     const top = getPxVal(style.top || el.top, logHeight)
@@ -866,8 +836,8 @@ function getSlideObstacles(element: any, elements: any[]) {
     if (typeof document !== 'undefined' && (!width || !height || el.type === 'text')) {
       const domEl = document.getElementById(`canvas-el-${el.id}`) || document.getElementById(`screen-element-${el.id}`)
       if (domEl) {
-        if (domEl.offsetWidth) width = domEl.offsetWidth
-        if (domEl.offsetHeight) height = domEl.offsetHeight
+        if (domEl.offsetWidth && !width) width = domEl.offsetWidth
+        if (domEl.offsetHeight && !height) height = domEl.offsetHeight
       }
     }
 
@@ -889,7 +859,7 @@ function isSegmentObstructed(x3: number, y3: number, x4: number, y4: number, obs
   const minY = Math.min(y3, y4)
   const maxY = Math.max(y3, y4)
 
-  const eps = 1.0
+  const eps = 0.5
 
   for (const obs of obstacles) {
     const obsLeft = obs.left + eps
@@ -899,13 +869,13 @@ function isSegmentObstructed(x3: number, y3: number, x4: number, y4: number, obs
 
     if (obsRight <= obsLeft || obsBottom <= obsTop) continue
 
-    if (x3 === x4) {
+    if (Math.abs(x3 - x4) < 0.5) {
       if (x3 > obsLeft && x3 < obsRight) {
         if (minY < obsBottom && maxY > obsTop) {
           return true
         }
       }
-    } else if (y3 === y4) {
+    } else if (Math.abs(y3 - y4) < 0.5) {
       if (y3 > obsTop && y3 < obsBottom) {
         if (minX < obsRight && maxX > obsLeft) {
           return true
@@ -1249,7 +1219,7 @@ export function updateLineGeometry(
     absControls.broken = [(absStart[0] + absEnd[0]) / 2, (absStart[1] + absEnd[1]) / 2]
   }
 
-  if (el.path !== undefined && !isBent) {
+  if (el.path !== undefined) {
     delete el.path
   }
 
@@ -1424,17 +1394,13 @@ export function syncSlideConnections(slide: any, logWidth: number, logHeight: nu
         }
         const pt = getConnectionPoint(target, idx, logWidth, logHeight, targetDim)
         const isLineSelected = Boolean(selectedElementIds && selectedElementIds.includes(el.id))
-        const isTargetSelected = Boolean(selectedElementIds && selectedElementIds.includes(target.id))
-        const shouldSnapStart = (!selectedElementIds || selectedElementIds.length === 0) || (isTargetSelected && !isLineSelected)
+        const shouldSnapStart = !isLineSelected
         if (shouldSnapStart) {
           if (Math.abs(pt[0] - currentStartAbs[0]) > 0.5 || Math.abs(pt[1] - currentStartAbs[1]) > 0.5) {
             newStartAbs = pt
             updated = true
           }
         }
-      } else {
-        // 目标形状不是系统已知标准形状（如自由曲线/自定义形状等），不给绑定锚点，原样呈现 PPT 原生排版位置
-        delete el.startConnection
       }
     }
 
@@ -1474,17 +1440,13 @@ export function syncSlideConnections(slide: any, logWidth: number, logHeight: nu
         }
         const pt = getConnectionPoint(target, idx, logWidth, logHeight, targetDim)
         const isLineSelected = Boolean(selectedElementIds && selectedElementIds.includes(el.id))
-        const isTargetSelected = Boolean(selectedElementIds && selectedElementIds.includes(target.id))
-        const shouldSnapEnd = (!selectedElementIds || selectedElementIds.length === 0) || (isTargetSelected && !isLineSelected)
+        const shouldSnapEnd = !isLineSelected
         if (shouldSnapEnd) {
           if (Math.abs(pt[0] - currentEndAbs[0]) > 0.5 || Math.abs(pt[1] - currentEndAbs[1]) > 0.5) {
             newEndAbs = pt
             updated = true
           }
         }
-      } else {
-        // 目标形状不是系统已知标准形状，不给绑定锚点，原样呈现 PPT 原生排版位置
-        delete el.endConnection
       }
     }