microboard-temp 0.5.80 → 0.5.82

package/dist/cjs/browser.js

@@ -36934,79 +36934,85 @@ function reconstructPath(node2) {
   }
   return path2.reverse();
 }
-function createHookWaypoints(startPoint, endPoint, start, end, startDir, endDir) {
-  if (!startDir || !endDir || start.pointType === "Board" || end.pointType === "Board") {
-    return [];
-  }
-  const startMbr = start.item.getMbr();
-  const endMbr = end.item.getMbr();
-  if (startDir === "right" && endDir === "left" && startPoint.x > endPoint.x) {
-    const midY = (startPoint.y + endPoint.y) / 2;
-    return [new Point(startPoint.x, midY), new Point(endPoint.x, midY)];
-  }
-  if (startDir === "left" && endDir === "right" && startPoint.x < endPoint.x) {
-    const midY = (startPoint.y + endPoint.y) / 2;
-    return [new Point(startPoint.x, midY), new Point(endPoint.x, midY)];
-  }
-  if (startDir === "bottom" && endDir === "top" && startPoint.y > endPoint.y) {
-    const midX = (startPoint.x + endPoint.x) / 2;
-    return [new Point(midX, startPoint.y), new Point(midX, endPoint.y)];
-  }
-  if (startDir === "top" && endDir === "bottom" && startPoint.y < endPoint.y) {
-    const midX = (startPoint.x + endPoint.x) / 2;
-    return [new Point(midX, startPoint.y), new Point(midX, endPoint.y)];
-  }
-  if ((startDir === "right" || startDir === "left") && (endDir === "top" || endDir === "bottom")) {
-    let needsHook = false;
-    if (startDir === "right" && startPoint.x > endMbr.right) {
-      if (endDir === "top" && endPoint.y < startMbr.top)
-        needsHook = true;
-      if (endDir === "bottom" && endPoint.y > startMbr.bottom)
-        needsHook = true;
-    }
-    if (startDir === "left" && startPoint.x < endMbr.left) {
-      if (endDir === "top" && endPoint.y < startMbr.top)
-        needsHook = true;
-      if (endDir === "bottom" && endPoint.y > startMbr.bottom)
-        needsHook = true;
-    }
-    if (needsHook) {
-      return [new Point(endPoint.x, startPoint.y)];
-    }
+function preCalculatePathPoints(start, end) {
+  const startDir = getPointerDirection(start);
+  const endDir = getPointerDirection(end);
+  const offset = conf.CONNECTOR_ITEM_OFFSET;
+  let startPoint = start;
+  let endPoint = end;
+  const stemWaypoints = [];
+  const allWaypoints = [];
+  const processPoint = (point5, dir2) => {
+    if (point5.pointType === "Board") {
+      return point5;
+    }
+    const offsetMap = {
+      top: { x: 0, y: -offset },
+      bottom: { x: 0, y: offset },
+      right: { x: offset, y: 0 },
+      left: { x: -offset, y: 0 }
+    };
+    const itemMbr = point5.item.getMbr();
+    const revertMapDir = { top: 0, bottom: 1, right: 2, left: 3 };
+    const pointOnMbr = itemMbr.getLines()[revertMapDir[dir2]].getNearestPointOnLineSegment(point5);
+    const newPoint = Object.create(Object.getPrototypeOf(point5), Object.getOwnPropertyDescriptors(point5));
+    newPoint.x = pointOnMbr.x + offsetMap[dir2].x;
+    newPoint.y = pointOnMbr.y + offsetMap[dir2].y;
+    return newPoint;
+  };
+  if (start.pointType !== "Board" && startDir) {
+    startPoint = processPoint(start, startDir);
   }
-  if ((startDir === "top" || startDir === "bottom") && (endDir === "right" || endDir === "left")) {
-    let needsHook = false;
-    if (startDir === "top" && startPoint.y < endMbr.top) {
-      if (endDir === "right" && endPoint.x > startMbr.right)
-        needsHook = true;
-      if (endDir === "left" && endPoint.x < startMbr.left)
-        needsHook = true;
-    }
-    if (startDir === "bottom" && startPoint.y > endMbr.bottom) {
-      if (endDir === "right" && endPoint.x > startMbr.right)
-        needsHook = true;
-      if (endDir === "left" && endPoint.x < startMbr.left)
-        needsHook = true;
-    }
-    if (needsHook) {
-      return [new Point(startPoint.x, endPoint.y)];
-    }
+  if (end.pointType !== "Board" && endDir) {
+    endPoint = processPoint(end, endDir);
+  }
+  if (startDir) {
+    let stem;
+    if (startDir === "right")
+      stem = new Point(startPoint.x + offset, startPoint.y);
+    else if (startDir === "left")
+      stem = new Point(startPoint.x - offset, startPoint.y);
+    else if (startDir === "bottom")
+      stem = new Point(startPoint.x, startPoint.y + offset);
+    else
+      stem = new Point(startPoint.x, startPoint.y - offset);
+    stemWaypoints.push(stem);
+    allWaypoints.push(stem);
+  }
+  if (endDir) {
+    let stem;
+    if (endDir === "right")
+      stem = new Point(endPoint.x + offset, endPoint.y);
+    else if (endDir === "left")
+      stem = new Point(endPoint.x - offset, endPoint.y);
+    else if (endDir === "bottom")
+      stem = new Point(endPoint.x, endPoint.y + offset);
+    else
+      stem = new Point(endPoint.x, endPoint.y - offset);
+    stemWaypoints.push(stem);
+    allWaypoints.push(stem);
   }
-  return [];
+  return { startPoint, endPoint, stemWaypoints, allWaypoints };
 }
 function findOrthogonalPath(start, end, obstacles, toVisitPoints = []) {
-  const { grid, newStart, newEnd } = createGrid(start, end, toVisitPoints);
-  const startPoint = newStart || start;
-  const endPoint = newEnd || end;
-  const startDir = getPointerDirection(start);
-  const endDir = getPointerDirection(end);
-  const hookWaypoints = createHookWaypoints(startPoint, endPoint, start, end, startDir, endDir);
-  const points = [startPoint, ...hookWaypoints, ...toVisitPoints, endPoint];
-  const pathPoints = findPathPoints(points, grid, obstacles, newStart, newEnd);
+  const { startPoint, endPoint, stemWaypoints, allWaypoints } = preCalculatePathPoints(start, end);
+  const gridPoints = [...allWaypoints, ...toVisitPoints];
+  const { grid, newStart, newEnd } = createGrid(start, end, gridPoints);
+  let finalWaypoints = [startPoint];
+  if (stemWaypoints.length > 0) {
+    finalWaypoints.push(stemWaypoints[0]);
+  }
+  finalWaypoints.push(...toVisitPoints);
+  if (stemWaypoints.length > 1) {
+    finalWaypoints.push(stemWaypoints[1]);
+  }
+  finalWaypoints.push(endPoint);
+  const uniqueWaypoints = finalWaypoints.filter((point5, index2, self2) => index2 === 0 || !point5.barelyEqual(self2[index2 - 1]));
+  const pathPoints = findPathPoints(uniqueWaypoints, grid, obstacles, newStart, newEnd);
   return {
     lines: getLines(pathPoints),
-    newStart,
-    newEnd
+    newStart: startPoint,
+    newEnd: endPoint
   };
 }
 

package/dist/cjs/index.js

@@ -36934,79 +36934,85 @@ function reconstructPath(node2) {
   }
   return path2.reverse();
 }
-function createHookWaypoints(startPoint, endPoint, start, end, startDir, endDir) {
-  if (!startDir || !endDir || start.pointType === "Board" || end.pointType === "Board") {
-    return [];
-  }
-  const startMbr = start.item.getMbr();
-  const endMbr = end.item.getMbr();
-  if (startDir === "right" && endDir === "left" && startPoint.x > endPoint.x) {
-    const midY = (startPoint.y + endPoint.y) / 2;
-    return [new Point(startPoint.x, midY), new Point(endPoint.x, midY)];
-  }
-  if (startDir === "left" && endDir === "right" && startPoint.x < endPoint.x) {
-    const midY = (startPoint.y + endPoint.y) / 2;
-    return [new Point(startPoint.x, midY), new Point(endPoint.x, midY)];
-  }
-  if (startDir === "bottom" && endDir === "top" && startPoint.y > endPoint.y) {
-    const midX = (startPoint.x + endPoint.x) / 2;
-    return [new Point(midX, startPoint.y), new Point(midX, endPoint.y)];
-  }
-  if (startDir === "top" && endDir === "bottom" && startPoint.y < endPoint.y) {
-    const midX = (startPoint.x + endPoint.x) / 2;
-    return [new Point(midX, startPoint.y), new Point(midX, endPoint.y)];
-  }
-  if ((startDir === "right" || startDir === "left") && (endDir === "top" || endDir === "bottom")) {
-    let needsHook = false;
-    if (startDir === "right" && startPoint.x > endMbr.right) {
-      if (endDir === "top" && endPoint.y < startMbr.top)
-        needsHook = true;
-      if (endDir === "bottom" && endPoint.y > startMbr.bottom)
-        needsHook = true;
-    }
-    if (startDir === "left" && startPoint.x < endMbr.left) {
-      if (endDir === "top" && endPoint.y < startMbr.top)
-        needsHook = true;
-      if (endDir === "bottom" && endPoint.y > startMbr.bottom)
-        needsHook = true;
-    }
-    if (needsHook) {
-      return [new Point(endPoint.x, startPoint.y)];
-    }
+function preCalculatePathPoints(start, end) {
+  const startDir = getPointerDirection(start);
+  const endDir = getPointerDirection(end);
+  const offset = conf.CONNECTOR_ITEM_OFFSET;
+  let startPoint = start;
+  let endPoint = end;
+  const stemWaypoints = [];
+  const allWaypoints = [];
+  const processPoint = (point5, dir2) => {
+    if (point5.pointType === "Board") {
+      return point5;
+    }
+    const offsetMap = {
+      top: { x: 0, y: -offset },
+      bottom: { x: 0, y: offset },
+      right: { x: offset, y: 0 },
+      left: { x: -offset, y: 0 }
+    };
+    const itemMbr = point5.item.getMbr();
+    const revertMapDir = { top: 0, bottom: 1, right: 2, left: 3 };
+    const pointOnMbr = itemMbr.getLines()[revertMapDir[dir2]].getNearestPointOnLineSegment(point5);
+    const newPoint = Object.create(Object.getPrototypeOf(point5), Object.getOwnPropertyDescriptors(point5));
+    newPoint.x = pointOnMbr.x + offsetMap[dir2].x;
+    newPoint.y = pointOnMbr.y + offsetMap[dir2].y;
+    return newPoint;
+  };
+  if (start.pointType !== "Board" && startDir) {
+    startPoint = processPoint(start, startDir);
   }
-  if ((startDir === "top" || startDir === "bottom") && (endDir === "right" || endDir === "left")) {
-    let needsHook = false;
-    if (startDir === "top" && startPoint.y < endMbr.top) {
-      if (endDir === "right" && endPoint.x > startMbr.right)
-        needsHook = true;
-      if (endDir === "left" && endPoint.x < startMbr.left)
-        needsHook = true;
-    }
-    if (startDir === "bottom" && startPoint.y > endMbr.bottom) {
-      if (endDir === "right" && endPoint.x > startMbr.right)
-        needsHook = true;
-      if (endDir === "left" && endPoint.x < startMbr.left)
-        needsHook = true;
-    }
-    if (needsHook) {
-      return [new Point(startPoint.x, endPoint.y)];
-    }
+  if (end.pointType !== "Board" && endDir) {
+    endPoint = processPoint(end, endDir);
+  }
+  if (startDir) {
+    let stem;
+    if (startDir === "right")
+      stem = new Point(startPoint.x + offset, startPoint.y);
+    else if (startDir === "left")
+      stem = new Point(startPoint.x - offset, startPoint.y);
+    else if (startDir === "bottom")
+      stem = new Point(startPoint.x, startPoint.y + offset);
+    else
+      stem = new Point(startPoint.x, startPoint.y - offset);
+    stemWaypoints.push(stem);
+    allWaypoints.push(stem);
+  }
+  if (endDir) {
+    let stem;
+    if (endDir === "right")
+      stem = new Point(endPoint.x + offset, endPoint.y);
+    else if (endDir === "left")
+      stem = new Point(endPoint.x - offset, endPoint.y);
+    else if (endDir === "bottom")
+      stem = new Point(endPoint.x, endPoint.y + offset);
+    else
+      stem = new Point(endPoint.x, endPoint.y - offset);
+    stemWaypoints.push(stem);
+    allWaypoints.push(stem);
   }
-  return [];
+  return { startPoint, endPoint, stemWaypoints, allWaypoints };
 }
 function findOrthogonalPath(start, end, obstacles, toVisitPoints = []) {
-  const { grid, newStart, newEnd } = createGrid(start, end, toVisitPoints);
-  const startPoint = newStart || start;
-  const endPoint = newEnd || end;
-  const startDir = getPointerDirection(start);
-  const endDir = getPointerDirection(end);
-  const hookWaypoints = createHookWaypoints(startPoint, endPoint, start, end, startDir, endDir);
-  const points = [startPoint, ...hookWaypoints, ...toVisitPoints, endPoint];
-  const pathPoints = findPathPoints(points, grid, obstacles, newStart, newEnd);
+  const { startPoint, endPoint, stemWaypoints, allWaypoints } = preCalculatePathPoints(start, end);
+  const gridPoints = [...allWaypoints, ...toVisitPoints];
+  const { grid, newStart, newEnd } = createGrid(start, end, gridPoints);
+  let finalWaypoints = [startPoint];
+  if (stemWaypoints.length > 0) {
+    finalWaypoints.push(stemWaypoints[0]);
+  }
+  finalWaypoints.push(...toVisitPoints);
+  if (stemWaypoints.length > 1) {
+    finalWaypoints.push(stemWaypoints[1]);
+  }
+  finalWaypoints.push(endPoint);
+  const uniqueWaypoints = finalWaypoints.filter((point5, index2, self2) => index2 === 0 || !point5.barelyEqual(self2[index2 - 1]));
+  const pathPoints = findPathPoints(uniqueWaypoints, grid, obstacles, newStart, newEnd);
   return {
     lines: getLines(pathPoints),
-    newStart,
-    newEnd
+    newStart: startPoint,
+    newEnd: endPoint
   };
 }
 

package/dist/cjs/node.js

@@ -39407,79 +39407,85 @@ function reconstructPath(node2) {
   }
   return path2.reverse();
 }
-function createHookWaypoints(startPoint, endPoint, start, end, startDir, endDir) {
-  if (!startDir || !endDir || start.pointType === "Board" || end.pointType === "Board") {
-    return [];
-  }
-  const startMbr = start.item.getMbr();
-  const endMbr = end.item.getMbr();
-  if (startDir === "right" && endDir === "left" && startPoint.x > endPoint.x) {
-    const midY = (startPoint.y + endPoint.y) / 2;
-    return [new Point(startPoint.x, midY), new Point(endPoint.x, midY)];
-  }
-  if (startDir === "left" && endDir === "right" && startPoint.x < endPoint.x) {
-    const midY = (startPoint.y + endPoint.y) / 2;
-    return [new Point(startPoint.x, midY), new Point(endPoint.x, midY)];
-  }
-  if (startDir === "bottom" && endDir === "top" && startPoint.y > endPoint.y) {
-    const midX = (startPoint.x + endPoint.x) / 2;
-    return [new Point(midX, startPoint.y), new Point(midX, endPoint.y)];
-  }
-  if (startDir === "top" && endDir === "bottom" && startPoint.y < endPoint.y) {
-    const midX = (startPoint.x + endPoint.x) / 2;
-    return [new Point(midX, startPoint.y), new Point(midX, endPoint.y)];
-  }
-  if ((startDir === "right" || startDir === "left") && (endDir === "top" || endDir === "bottom")) {
-    let needsHook = false;
-    if (startDir === "right" && startPoint.x > endMbr.right) {
-      if (endDir === "top" && endPoint.y < startMbr.top)
-        needsHook = true;
-      if (endDir === "bottom" && endPoint.y > startMbr.bottom)
-        needsHook = true;
-    }
-    if (startDir === "left" && startPoint.x < endMbr.left) {
-      if (endDir === "top" && endPoint.y < startMbr.top)
-        needsHook = true;
-      if (endDir === "bottom" && endPoint.y > startMbr.bottom)
-        needsHook = true;
-    }
-    if (needsHook) {
-      return [new Point(endPoint.x, startPoint.y)];
-    }
+function preCalculatePathPoints(start, end) {
+  const startDir = getPointerDirection(start);
+  const endDir = getPointerDirection(end);
+  const offset = conf.CONNECTOR_ITEM_OFFSET;
+  let startPoint = start;
+  let endPoint = end;
+  const stemWaypoints = [];
+  const allWaypoints = [];
+  const processPoint = (point5, dir2) => {
+    if (point5.pointType === "Board") {
+      return point5;
+    }
+    const offsetMap = {
+      top: { x: 0, y: -offset },
+      bottom: { x: 0, y: offset },
+      right: { x: offset, y: 0 },
+      left: { x: -offset, y: 0 }
+    };
+    const itemMbr = point5.item.getMbr();
+    const revertMapDir = { top: 0, bottom: 1, right: 2, left: 3 };
+    const pointOnMbr = itemMbr.getLines()[revertMapDir[dir2]].getNearestPointOnLineSegment(point5);
+    const newPoint = Object.create(Object.getPrototypeOf(point5), Object.getOwnPropertyDescriptors(point5));
+    newPoint.x = pointOnMbr.x + offsetMap[dir2].x;
+    newPoint.y = pointOnMbr.y + offsetMap[dir2].y;
+    return newPoint;
+  };
+  if (start.pointType !== "Board" && startDir) {
+    startPoint = processPoint(start, startDir);
   }
-  if ((startDir === "top" || startDir === "bottom") && (endDir === "right" || endDir === "left")) {
-    let needsHook = false;
-    if (startDir === "top" && startPoint.y < endMbr.top) {
-      if (endDir === "right" && endPoint.x > startMbr.right)
-        needsHook = true;
-      if (endDir === "left" && endPoint.x < startMbr.left)
-        needsHook = true;
-    }
-    if (startDir === "bottom" && startPoint.y > endMbr.bottom) {
-      if (endDir === "right" && endPoint.x > startMbr.right)
-        needsHook = true;
-      if (endDir === "left" && endPoint.x < startMbr.left)
-        needsHook = true;
-    }
-    if (needsHook) {
-      return [new Point(startPoint.x, endPoint.y)];
-    }
+  if (end.pointType !== "Board" && endDir) {
+    endPoint = processPoint(end, endDir);
+  }
+  if (startDir) {
+    let stem;
+    if (startDir === "right")
+      stem = new Point(startPoint.x + offset, startPoint.y);
+    else if (startDir === "left")
+      stem = new Point(startPoint.x - offset, startPoint.y);
+    else if (startDir === "bottom")
+      stem = new Point(startPoint.x, startPoint.y + offset);
+    else
+      stem = new Point(startPoint.x, startPoint.y - offset);
+    stemWaypoints.push(stem);
+    allWaypoints.push(stem);
+  }
+  if (endDir) {
+    let stem;
+    if (endDir === "right")
+      stem = new Point(endPoint.x + offset, endPoint.y);
+    else if (endDir === "left")
+      stem = new Point(endPoint.x - offset, endPoint.y);
+    else if (endDir === "bottom")
+      stem = new Point(endPoint.x, endPoint.y + offset);
+    else
+      stem = new Point(endPoint.x, endPoint.y - offset);
+    stemWaypoints.push(stem);
+    allWaypoints.push(stem);
   }
-  return [];
+  return { startPoint, endPoint, stemWaypoints, allWaypoints };
 }
 function findOrthogonalPath(start, end, obstacles, toVisitPoints = []) {
-  const { grid, newStart, newEnd } = createGrid(start, end, toVisitPoints);
-  const startPoint = newStart || start;
-  const endPoint = newEnd || end;
-  const startDir = getPointerDirection(start);
-  const endDir = getPointerDirection(end);
-  const hookWaypoints = createHookWaypoints(startPoint, endPoint, start, end, startDir, endDir);
-  const points = [startPoint, ...hookWaypoints, ...toVisitPoints, endPoint];
-  const pathPoints = findPathPoints(points, grid, obstacles, newStart, newEnd);
+  const { startPoint, endPoint, stemWaypoints, allWaypoints } = preCalculatePathPoints(start, end);
+  const gridPoints = [...allWaypoints, ...toVisitPoints];
+  const { grid, newStart, newEnd } = createGrid(start, end, gridPoints);
+  let finalWaypoints = [startPoint];
+  if (stemWaypoints.length > 0) {
+    finalWaypoints.push(stemWaypoints[0]);
+  }
+  finalWaypoints.push(...toVisitPoints);
+  if (stemWaypoints.length > 1) {
+    finalWaypoints.push(stemWaypoints[1]);
+  }
+  finalWaypoints.push(endPoint);
+  const uniqueWaypoints = finalWaypoints.filter((point5, index2, self2) => index2 === 0 || !point5.barelyEqual(self2[index2 - 1]));
+  const pathPoints = findPathPoints(uniqueWaypoints, grid, obstacles, newStart, newEnd);
   return {
     lines: getLines(pathPoints),
-    newStart,
-    newEnd
+    newStart: startPoint,
+    newEnd: endPoint
   };
 }
 

package/dist/esm/browser.js

@@ -36779,79 +36779,85 @@ function reconstructPath(node2) {
   }
   return path2.reverse();
 }
-function createHookWaypoints(startPoint, endPoint, start, end, startDir, endDir) {
-  if (!startDir || !endDir || start.pointType === "Board" || end.pointType === "Board") {
-    return [];
-  }
-  const startMbr = start.item.getMbr();
-  const endMbr = end.item.getMbr();
-  if (startDir === "right" && endDir === "left" && startPoint.x > endPoint.x) {
-    const midY = (startPoint.y + endPoint.y) / 2;
-    return [new Point(startPoint.x, midY), new Point(endPoint.x, midY)];
-  }
-  if (startDir === "left" && endDir === "right" && startPoint.x < endPoint.x) {
-    const midY = (startPoint.y + endPoint.y) / 2;
-    return [new Point(startPoint.x, midY), new Point(endPoint.x, midY)];
-  }
-  if (startDir === "bottom" && endDir === "top" && startPoint.y > endPoint.y) {
-    const midX = (startPoint.x + endPoint.x) / 2;
-    return [new Point(midX, startPoint.y), new Point(midX, endPoint.y)];
-  }
-  if (startDir === "top" && endDir === "bottom" && startPoint.y < endPoint.y) {
-    const midX = (startPoint.x + endPoint.x) / 2;
-    return [new Point(midX, startPoint.y), new Point(midX, endPoint.y)];
-  }
-  if ((startDir === "right" || startDir === "left") && (endDir === "top" || endDir === "bottom")) {
-    let needsHook = false;
-    if (startDir === "right" && startPoint.x > endMbr.right) {
-      if (endDir === "top" && endPoint.y < startMbr.top)
-        needsHook = true;
-      if (endDir === "bottom" && endPoint.y > startMbr.bottom)
-        needsHook = true;
-    }
-    if (startDir === "left" && startPoint.x < endMbr.left) {
-      if (endDir === "top" && endPoint.y < startMbr.top)
-        needsHook = true;
-      if (endDir === "bottom" && endPoint.y > startMbr.bottom)
-        needsHook = true;
-    }
-    if (needsHook) {
-      return [new Point(endPoint.x, startPoint.y)];
-    }
+function preCalculatePathPoints(start, end) {
+  const startDir = getPointerDirection(start);
+  const endDir = getPointerDirection(end);
+  const offset = conf.CONNECTOR_ITEM_OFFSET;
+  let startPoint = start;
+  let endPoint = end;
+  const stemWaypoints = [];
+  const allWaypoints = [];
+  const processPoint = (point5, dir2) => {
+    if (point5.pointType === "Board") {
+      return point5;
+    }
+    const offsetMap = {
+      top: { x: 0, y: -offset },
+      bottom: { x: 0, y: offset },
+      right: { x: offset, y: 0 },
+      left: { x: -offset, y: 0 }
+    };
+    const itemMbr = point5.item.getMbr();
+    const revertMapDir = { top: 0, bottom: 1, right: 2, left: 3 };
+    const pointOnMbr = itemMbr.getLines()[revertMapDir[dir2]].getNearestPointOnLineSegment(point5);
+    const newPoint = Object.create(Object.getPrototypeOf(point5), Object.getOwnPropertyDescriptors(point5));
+    newPoint.x = pointOnMbr.x + offsetMap[dir2].x;
+    newPoint.y = pointOnMbr.y + offsetMap[dir2].y;
+    return newPoint;
+  };
+  if (start.pointType !== "Board" && startDir) {
+    startPoint = processPoint(start, startDir);
   }
-  if ((startDir === "top" || startDir === "bottom") && (endDir === "right" || endDir === "left")) {
-    let needsHook = false;
-    if (startDir === "top" && startPoint.y < endMbr.top) {
-      if (endDir === "right" && endPoint.x > startMbr.right)
-        needsHook = true;
-      if (endDir === "left" && endPoint.x < startMbr.left)
-        needsHook = true;
-    }
-    if (startDir === "bottom" && startPoint.y > endMbr.bottom) {
-      if (endDir === "right" && endPoint.x > startMbr.right)
-        needsHook = true;
-      if (endDir === "left" && endPoint.x < startMbr.left)
-        needsHook = true;
-    }
-    if (needsHook) {
-      return [new Point(startPoint.x, endPoint.y)];
-    }
+  if (end.pointType !== "Board" && endDir) {
+    endPoint = processPoint(end, endDir);
+  }
+  if (startDir) {
+    let stem;
+    if (startDir === "right")
+      stem = new Point(startPoint.x + offset, startPoint.y);
+    else if (startDir === "left")
+      stem = new Point(startPoint.x - offset, startPoint.y);
+    else if (startDir === "bottom")
+      stem = new Point(startPoint.x, startPoint.y + offset);
+    else
+      stem = new Point(startPoint.x, startPoint.y - offset);
+    stemWaypoints.push(stem);
+    allWaypoints.push(stem);
+  }
+  if (endDir) {
+    let stem;
+    if (endDir === "right")
+      stem = new Point(endPoint.x + offset, endPoint.y);
+    else if (endDir === "left")
+      stem = new Point(endPoint.x - offset, endPoint.y);
+    else if (endDir === "bottom")
+      stem = new Point(endPoint.x, endPoint.y + offset);
+    else
+      stem = new Point(endPoint.x, endPoint.y - offset);
+    stemWaypoints.push(stem);
+    allWaypoints.push(stem);
   }
-  return [];
+  return { startPoint, endPoint, stemWaypoints, allWaypoints };
 }
 function findOrthogonalPath(start, end, obstacles, toVisitPoints = []) {
-  const { grid, newStart, newEnd } = createGrid(start, end, toVisitPoints);
-  const startPoint = newStart || start;
-  const endPoint = newEnd || end;
-  const startDir = getPointerDirection(start);
-  const endDir = getPointerDirection(end);
-  const hookWaypoints = createHookWaypoints(startPoint, endPoint, start, end, startDir, endDir);
-  const points = [startPoint, ...hookWaypoints, ...toVisitPoints, endPoint];
-  const pathPoints = findPathPoints(points, grid, obstacles, newStart, newEnd);
+  const { startPoint, endPoint, stemWaypoints, allWaypoints } = preCalculatePathPoints(start, end);
+  const gridPoints = [...allWaypoints, ...toVisitPoints];
+  const { grid, newStart, newEnd } = createGrid(start, end, gridPoints);
+  let finalWaypoints = [startPoint];
+  if (stemWaypoints.length > 0) {
+    finalWaypoints.push(stemWaypoints[0]);
+  }
+  finalWaypoints.push(...toVisitPoints);
+  if (stemWaypoints.length > 1) {
+    finalWaypoints.push(stemWaypoints[1]);
+  }
+  finalWaypoints.push(endPoint);
+  const uniqueWaypoints = finalWaypoints.filter((point5, index2, self2) => index2 === 0 || !point5.barelyEqual(self2[index2 - 1]));
+  const pathPoints = findPathPoints(uniqueWaypoints, grid, obstacles, newStart, newEnd);
   return {
     lines: getLines(pathPoints),
-    newStart,
-    newEnd
+    newStart: startPoint,
+    newEnd: endPoint
   };
 }
 

package/dist/esm/index.js

@@ -36772,79 +36772,85 @@ function reconstructPath(node2) {
   }
   return path2.reverse();
 }
-function createHookWaypoints(startPoint, endPoint, start, end, startDir, endDir) {
-  if (!startDir || !endDir || start.pointType === "Board" || end.pointType === "Board") {
-    return [];
-  }
-  const startMbr = start.item.getMbr();
-  const endMbr = end.item.getMbr();
-  if (startDir === "right" && endDir === "left" && startPoint.x > endPoint.x) {
-    const midY = (startPoint.y + endPoint.y) / 2;
-    return [new Point(startPoint.x, midY), new Point(endPoint.x, midY)];
-  }
-  if (startDir === "left" && endDir === "right" && startPoint.x < endPoint.x) {
-    const midY = (startPoint.y + endPoint.y) / 2;
-    return [new Point(startPoint.x, midY), new Point(endPoint.x, midY)];
-  }
-  if (startDir === "bottom" && endDir === "top" && startPoint.y > endPoint.y) {
-    const midX = (startPoint.x + endPoint.x) / 2;
-    return [new Point(midX, startPoint.y), new Point(midX, endPoint.y)];
-  }
-  if (startDir === "top" && endDir === "bottom" && startPoint.y < endPoint.y) {
-    const midX = (startPoint.x + endPoint.x) / 2;
-    return [new Point(midX, startPoint.y), new Point(midX, endPoint.y)];
-  }
-  if ((startDir === "right" || startDir === "left") && (endDir === "top" || endDir === "bottom")) {
-    let needsHook = false;
-    if (startDir === "right" && startPoint.x > endMbr.right) {
-      if (endDir === "top" && endPoint.y < startMbr.top)
-        needsHook = true;
-      if (endDir === "bottom" && endPoint.y > startMbr.bottom)
-        needsHook = true;
-    }
-    if (startDir === "left" && startPoint.x < endMbr.left) {
-      if (endDir === "top" && endPoint.y < startMbr.top)
-        needsHook = true;
-      if (endDir === "bottom" && endPoint.y > startMbr.bottom)
-        needsHook = true;
-    }
-    if (needsHook) {
-      return [new Point(endPoint.x, startPoint.y)];
-    }
+function preCalculatePathPoints(start, end) {
+  const startDir = getPointerDirection(start);
+  const endDir = getPointerDirection(end);
+  const offset = conf.CONNECTOR_ITEM_OFFSET;
+  let startPoint = start;
+  let endPoint = end;
+  const stemWaypoints = [];
+  const allWaypoints = [];
+  const processPoint = (point5, dir2) => {
+    if (point5.pointType === "Board") {
+      return point5;
+    }
+    const offsetMap = {
+      top: { x: 0, y: -offset },
+      bottom: { x: 0, y: offset },
+      right: { x: offset, y: 0 },
+      left: { x: -offset, y: 0 }
+    };
+    const itemMbr = point5.item.getMbr();
+    const revertMapDir = { top: 0, bottom: 1, right: 2, left: 3 };
+    const pointOnMbr = itemMbr.getLines()[revertMapDir[dir2]].getNearestPointOnLineSegment(point5);
+    const newPoint = Object.create(Object.getPrototypeOf(point5), Object.getOwnPropertyDescriptors(point5));
+    newPoint.x = pointOnMbr.x + offsetMap[dir2].x;
+    newPoint.y = pointOnMbr.y + offsetMap[dir2].y;
+    return newPoint;
+  };
+  if (start.pointType !== "Board" && startDir) {
+    startPoint = processPoint(start, startDir);
   }
-  if ((startDir === "top" || startDir === "bottom") && (endDir === "right" || endDir === "left")) {
-    let needsHook = false;
-    if (startDir === "top" && startPoint.y < endMbr.top) {
-      if (endDir === "right" && endPoint.x > startMbr.right)
-        needsHook = true;
-      if (endDir === "left" && endPoint.x < startMbr.left)
-        needsHook = true;
-    }
-    if (startDir === "bottom" && startPoint.y > endMbr.bottom) {
-      if (endDir === "right" && endPoint.x > startMbr.right)
-        needsHook = true;
-      if (endDir === "left" && endPoint.x < startMbr.left)
-        needsHook = true;
-    }
-    if (needsHook) {
-      return [new Point(startPoint.x, endPoint.y)];
-    }
+  if (end.pointType !== "Board" && endDir) {
+    endPoint = processPoint(end, endDir);
+  }
+  if (startDir) {
+    let stem;
+    if (startDir === "right")
+      stem = new Point(startPoint.x + offset, startPoint.y);
+    else if (startDir === "left")
+      stem = new Point(startPoint.x - offset, startPoint.y);
+    else if (startDir === "bottom")
+      stem = new Point(startPoint.x, startPoint.y + offset);
+    else
+      stem = new Point(startPoint.x, startPoint.y - offset);
+    stemWaypoints.push(stem);
+    allWaypoints.push(stem);
+  }
+  if (endDir) {
+    let stem;
+    if (endDir === "right")
+      stem = new Point(endPoint.x + offset, endPoint.y);
+    else if (endDir === "left")
+      stem = new Point(endPoint.x - offset, endPoint.y);
+    else if (endDir === "bottom")
+      stem = new Point(endPoint.x, endPoint.y + offset);
+    else
+      stem = new Point(endPoint.x, endPoint.y - offset);
+    stemWaypoints.push(stem);
+    allWaypoints.push(stem);
   }
-  return [];
+  return { startPoint, endPoint, stemWaypoints, allWaypoints };
 }
 function findOrthogonalPath(start, end, obstacles, toVisitPoints = []) {
-  const { grid, newStart, newEnd } = createGrid(start, end, toVisitPoints);
-  const startPoint = newStart || start;
-  const endPoint = newEnd || end;
-  const startDir = getPointerDirection(start);
-  const endDir = getPointerDirection(end);
-  const hookWaypoints = createHookWaypoints(startPoint, endPoint, start, end, startDir, endDir);
-  const points = [startPoint, ...hookWaypoints, ...toVisitPoints, endPoint];
-  const pathPoints = findPathPoints(points, grid, obstacles, newStart, newEnd);
+  const { startPoint, endPoint, stemWaypoints, allWaypoints } = preCalculatePathPoints(start, end);
+  const gridPoints = [...allWaypoints, ...toVisitPoints];
+  const { grid, newStart, newEnd } = createGrid(start, end, gridPoints);
+  let finalWaypoints = [startPoint];
+  if (stemWaypoints.length > 0) {
+    finalWaypoints.push(stemWaypoints[0]);
+  }
+  finalWaypoints.push(...toVisitPoints);
+  if (stemWaypoints.length > 1) {
+    finalWaypoints.push(stemWaypoints[1]);
+  }
+  finalWaypoints.push(endPoint);
+  const uniqueWaypoints = finalWaypoints.filter((point5, index2, self2) => index2 === 0 || !point5.barelyEqual(self2[index2 - 1]));
+  const pathPoints = findPathPoints(uniqueWaypoints, grid, obstacles, newStart, newEnd);
   return {
     lines: getLines(pathPoints),
-    newStart,
-    newEnd
+    newStart: startPoint,
+    newEnd: endPoint
   };
 }
 

package/dist/esm/node.js

@@ -39240,79 +39240,85 @@ function reconstructPath(node2) {
   }
   return path2.reverse();
 }
-function createHookWaypoints(startPoint, endPoint, start, end, startDir, endDir) {
-  if (!startDir || !endDir || start.pointType === "Board" || end.pointType === "Board") {
-    return [];
-  }
-  const startMbr = start.item.getMbr();
-  const endMbr = end.item.getMbr();
-  if (startDir === "right" && endDir === "left" && startPoint.x > endPoint.x) {
-    const midY = (startPoint.y + endPoint.y) / 2;
-    return [new Point(startPoint.x, midY), new Point(endPoint.x, midY)];
-  }
-  if (startDir === "left" && endDir === "right" && startPoint.x < endPoint.x) {
-    const midY = (startPoint.y + endPoint.y) / 2;
-    return [new Point(startPoint.x, midY), new Point(endPoint.x, midY)];
-  }
-  if (startDir === "bottom" && endDir === "top" && startPoint.y > endPoint.y) {
-    const midX = (startPoint.x + endPoint.x) / 2;
-    return [new Point(midX, startPoint.y), new Point(midX, endPoint.y)];
-  }
-  if (startDir === "top" && endDir === "bottom" && startPoint.y < endPoint.y) {
-    const midX = (startPoint.x + endPoint.x) / 2;
-    return [new Point(midX, startPoint.y), new Point(midX, endPoint.y)];
-  }
-  if ((startDir === "right" || startDir === "left") && (endDir === "top" || endDir === "bottom")) {
-    let needsHook = false;
-    if (startDir === "right" && startPoint.x > endMbr.right) {
-      if (endDir === "top" && endPoint.y < startMbr.top)
-        needsHook = true;
-      if (endDir === "bottom" && endPoint.y > startMbr.bottom)
-        needsHook = true;
-    }
-    if (startDir === "left" && startPoint.x < endMbr.left) {
-      if (endDir === "top" && endPoint.y < startMbr.top)
-        needsHook = true;
-      if (endDir === "bottom" && endPoint.y > startMbr.bottom)
-        needsHook = true;
-    }
-    if (needsHook) {
-      return [new Point(endPoint.x, startPoint.y)];
-    }
+function preCalculatePathPoints(start, end) {
+  const startDir = getPointerDirection(start);
+  const endDir = getPointerDirection(end);
+  const offset = conf.CONNECTOR_ITEM_OFFSET;
+  let startPoint = start;
+  let endPoint = end;
+  const stemWaypoints = [];
+  const allWaypoints = [];
+  const processPoint = (point5, dir2) => {
+    if (point5.pointType === "Board") {
+      return point5;
+    }
+    const offsetMap = {
+      top: { x: 0, y: -offset },
+      bottom: { x: 0, y: offset },
+      right: { x: offset, y: 0 },
+      left: { x: -offset, y: 0 }
+    };
+    const itemMbr = point5.item.getMbr();
+    const revertMapDir = { top: 0, bottom: 1, right: 2, left: 3 };
+    const pointOnMbr = itemMbr.getLines()[revertMapDir[dir2]].getNearestPointOnLineSegment(point5);
+    const newPoint = Object.create(Object.getPrototypeOf(point5), Object.getOwnPropertyDescriptors(point5));
+    newPoint.x = pointOnMbr.x + offsetMap[dir2].x;
+    newPoint.y = pointOnMbr.y + offsetMap[dir2].y;
+    return newPoint;
+  };
+  if (start.pointType !== "Board" && startDir) {
+    startPoint = processPoint(start, startDir);
   }
-  if ((startDir === "top" || startDir === "bottom") && (endDir === "right" || endDir === "left")) {
-    let needsHook = false;
-    if (startDir === "top" && startPoint.y < endMbr.top) {
-      if (endDir === "right" && endPoint.x > startMbr.right)
-        needsHook = true;
-      if (endDir === "left" && endPoint.x < startMbr.left)
-        needsHook = true;
-    }
-    if (startDir === "bottom" && startPoint.y > endMbr.bottom) {
-      if (endDir === "right" && endPoint.x > startMbr.right)
-        needsHook = true;
-      if (endDir === "left" && endPoint.x < startMbr.left)
-        needsHook = true;
-    }
-    if (needsHook) {
-      return [new Point(startPoint.x, endPoint.y)];
-    }
+  if (end.pointType !== "Board" && endDir) {
+    endPoint = processPoint(end, endDir);
+  }
+  if (startDir) {
+    let stem;
+    if (startDir === "right")
+      stem = new Point(startPoint.x + offset, startPoint.y);
+    else if (startDir === "left")
+      stem = new Point(startPoint.x - offset, startPoint.y);
+    else if (startDir === "bottom")
+      stem = new Point(startPoint.x, startPoint.y + offset);
+    else
+      stem = new Point(startPoint.x, startPoint.y - offset);
+    stemWaypoints.push(stem);
+    allWaypoints.push(stem);
+  }
+  if (endDir) {
+    let stem;
+    if (endDir === "right")
+      stem = new Point(endPoint.x + offset, endPoint.y);
+    else if (endDir === "left")
+      stem = new Point(endPoint.x - offset, endPoint.y);
+    else if (endDir === "bottom")
+      stem = new Point(endPoint.x, endPoint.y + offset);
+    else
+      stem = new Point(endPoint.x, endPoint.y - offset);
+    stemWaypoints.push(stem);
+    allWaypoints.push(stem);
   }
-  return [];
+  return { startPoint, endPoint, stemWaypoints, allWaypoints };
 }
 function findOrthogonalPath(start, end, obstacles, toVisitPoints = []) {
-  const { grid, newStart, newEnd } = createGrid(start, end, toVisitPoints);
-  const startPoint = newStart || start;
-  const endPoint = newEnd || end;
-  const startDir = getPointerDirection(start);
-  const endDir = getPointerDirection(end);
-  const hookWaypoints = createHookWaypoints(startPoint, endPoint, start, end, startDir, endDir);
-  const points = [startPoint, ...hookWaypoints, ...toVisitPoints, endPoint];
-  const pathPoints = findPathPoints(points, grid, obstacles, newStart, newEnd);
+  const { startPoint, endPoint, stemWaypoints, allWaypoints } = preCalculatePathPoints(start, end);
+  const gridPoints = [...allWaypoints, ...toVisitPoints];
+  const { grid, newStart, newEnd } = createGrid(start, end, gridPoints);
+  let finalWaypoints = [startPoint];
+  if (stemWaypoints.length > 0) {
+    finalWaypoints.push(stemWaypoints[0]);
+  }
+  finalWaypoints.push(...toVisitPoints);
+  if (stemWaypoints.length > 1) {
+    finalWaypoints.push(stemWaypoints[1]);
+  }
+  finalWaypoints.push(endPoint);
+  const uniqueWaypoints = finalWaypoints.filter((point5, index2, self2) => index2 === 0 || !point5.barelyEqual(self2[index2 - 1]));
+  const pathPoints = findPathPoints(uniqueWaypoints, grid, obstacles, newStart, newEnd);
   return {
     lines: getLines(pathPoints),
-    newStart,
-    newEnd
+    newStart: startPoint,
+    newEnd: endPoint
   };
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "microboard-temp",
-  "version": "0.5.80",
+  "version": "0.5.82",
   "description": "A flexible interactive whiteboard library",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",