microboard-temp 0.5.82 → 0.5.83

package/dist/cjs/browser.js

@@ -36731,50 +36731,45 @@ function createGrid(start, end, toVisitPoints = []) {
   const startDir = getPointerDirection(start);
   const endDir = getPointerDirection(end);
   const revertMapDir = { top: 0, bottom: 1, right: 2, left: 3 };
+  const offset = conf.CONNECTOR_ITEM_OFFSET;
   const offsetMap = {
-    top: { x: 0, y: -conf.CONNECTOR_ITEM_OFFSET },
-    bottom: { x: 0, y: conf.CONNECTOR_ITEM_OFFSET },
-    right: { x: conf.CONNECTOR_ITEM_OFFSET, y: 0 },
-    left: { x: -conf.CONNECTOR_ITEM_OFFSET, y: 0 }
+    top: { x: 0, y: -offset },
+    bottom: { x: 0, y: offset },
+    right: { x: offset, y: 0 },
+    left: { x: -offset, y: 0 }
   };
   const horizontalLines = [];
   const verticalLines = [];
-  let newStart;
-  let newEnd;
   const processPoint = (point5, dir2) => {
+    if (point5.pointType === "Board")
+      return;
     const itemMbr = point5.item.getMbr();
-    const mbrFloored = new Mbr(Math.floor(itemMbr.left), Math.floor(itemMbr.top), Math.floor(itemMbr.right), Math.floor(itemMbr.bottom));
-    const pointOnMbr = mbrFloored.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;
-    verticalLines.push(mbrFloored.left - conf.CONNECTOR_ITEM_OFFSET, mbrFloored.left, pointOnMbr.x, mbrFloored.right, mbrFloored.right + conf.CONNECTOR_ITEM_OFFSET);
-    horizontalLines.push(mbrFloored.top - conf.CONNECTOR_ITEM_OFFSET, mbrFloored.top, pointOnMbr.y, mbrFloored.bottom, mbrFloored.bottom + conf.CONNECTOR_ITEM_OFFSET);
-    return newPoint;
+    const pointOnMbrX = point5.x - offsetMap[dir2].x;
+    const pointOnMbrY = point5.y - offsetMap[dir2].y;
+    verticalLines.push(itemMbr.left - offset, itemMbr.left, pointOnMbrX, itemMbr.right, itemMbr.right + offset);
+    horizontalLines.push(itemMbr.top - offset, itemMbr.top, pointOnMbrY, itemMbr.bottom, itemMbr.bottom + offset);
   };
   if (start.pointType !== "Board" && startDir) {
-    newStart = processPoint(start, startDir);
+    processPoint(start, startDir);
   }
   if (end.pointType !== "Board" && endDir) {
-    newEnd = processPoint(end, endDir);
-  }
-  const finalStart = newStart || start;
-  const finalEnd = newEnd || end;
-  const middle = new Point((finalStart.x + finalEnd.x) / 2, (finalStart.y + finalEnd.y) / 2);
-  horizontalLines.push(middle.y, finalStart.y, finalEnd.y);
-  verticalLines.push(middle.x, finalStart.x, finalEnd.x);
-  toVisitPoints.forEach((p3) => {
+    processPoint(end, endDir);
+  }
+  const allPoints = [start, end, ...toVisitPoints];
+  allPoints.forEach((p3) => {
     horizontalLines.push(p3.y);
     verticalLines.push(p3.x);
   });
+  const middle = new Point((start.x + end.x) / 2, (start.y + end.y) / 2);
+  horizontalLines.push(middle.y);
+  verticalLines.push(middle.x);
   const uniqueHorizontalLines = Array.from(new Set(horizontalLines)).sort((a2, b) => a2 - b);
   const uniqueVerticalLines = Array.from(new Set(verticalLines)).sort((a2, b) => a2 - b);
   const grid = uniqueVerticalLines.map((x) => uniqueHorizontalLines.map((y) => new Point(x, y)));
   return {
     grid,
-    newStart,
-    newEnd,
-    middlePoint: middle
+    newStart: start,
+    newEnd: end
   };
 }
 function findPath(start, end, grid, obstacles, existingPath, newStart, newEnd) {
@@ -36934,18 +36929,15 @@ function reconstructPath(node2) {
   }
   return path2.reverse();
 }
-function preCalculatePathPoints(start, end) {
+function findOrthogonalPath(start, end, obstacles, toVisitPoints = []) {
   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") {
+    if (point5.pointType === "Board")
       return point5;
-    }
     const offsetMap = {
       top: { x: 0, y: -offset },
       bottom: { x: 0, y: offset },
@@ -36966,6 +36958,7 @@ function preCalculatePathPoints(start, end) {
   if (end.pointType !== "Board" && endDir) {
     endPoint = processPoint(end, endDir);
   }
+  const stemWaypoints = [];
   if (startDir) {
     let stem;
     if (startDir === "right")
@@ -36977,7 +36970,6 @@ function preCalculatePathPoints(start, end) {
     else
       stem = new Point(startPoint.x, startPoint.y - offset);
     stemWaypoints.push(stem);
-    allWaypoints.push(stem);
   }
   if (endDir) {
     let stem;
@@ -36990,14 +36982,9 @@ function preCalculatePathPoints(start, end) {
     else
       stem = new Point(endPoint.x, endPoint.y - offset);
     stemWaypoints.push(stem);
-    allWaypoints.push(stem);
   }
-  return { startPoint, endPoint, stemWaypoints, allWaypoints };
-}
-function findOrthogonalPath(start, end, obstacles, toVisitPoints = []) {
-  const { startPoint, endPoint, stemWaypoints, allWaypoints } = preCalculatePathPoints(start, end);
-  const gridPoints = [...allWaypoints, ...toVisitPoints];
-  const { grid, newStart, newEnd } = createGrid(start, end, gridPoints);
+  const allGridPoints = [startPoint, endPoint, ...stemWaypoints, ...toVisitPoints];
+  const { grid } = createGrid(startPoint, endPoint, allGridPoints);
   let finalWaypoints = [startPoint];
   if (stemWaypoints.length > 0) {
     finalWaypoints.push(stemWaypoints[0]);
@@ -37008,7 +36995,7 @@ function findOrthogonalPath(start, end, obstacles, toVisitPoints = []) {
   }
   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);
+  const pathPoints = findPathPoints(uniqueWaypoints, grid, obstacles, startPoint, endPoint);
   return {
     lines: getLines(pathPoints),
     newStart: startPoint,

package/dist/cjs/index.js

@@ -36731,50 +36731,45 @@ function createGrid(start, end, toVisitPoints = []) {
   const startDir = getPointerDirection(start);
   const endDir = getPointerDirection(end);
   const revertMapDir = { top: 0, bottom: 1, right: 2, left: 3 };
+  const offset = conf.CONNECTOR_ITEM_OFFSET;
   const offsetMap = {
-    top: { x: 0, y: -conf.CONNECTOR_ITEM_OFFSET },
-    bottom: { x: 0, y: conf.CONNECTOR_ITEM_OFFSET },
-    right: { x: conf.CONNECTOR_ITEM_OFFSET, y: 0 },
-    left: { x: -conf.CONNECTOR_ITEM_OFFSET, y: 0 }
+    top: { x: 0, y: -offset },
+    bottom: { x: 0, y: offset },
+    right: { x: offset, y: 0 },
+    left: { x: -offset, y: 0 }
   };
   const horizontalLines = [];
   const verticalLines = [];
-  let newStart;
-  let newEnd;
   const processPoint = (point5, dir2) => {
+    if (point5.pointType === "Board")
+      return;
     const itemMbr = point5.item.getMbr();
-    const mbrFloored = new Mbr(Math.floor(itemMbr.left), Math.floor(itemMbr.top), Math.floor(itemMbr.right), Math.floor(itemMbr.bottom));
-    const pointOnMbr = mbrFloored.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;
-    verticalLines.push(mbrFloored.left - conf.CONNECTOR_ITEM_OFFSET, mbrFloored.left, pointOnMbr.x, mbrFloored.right, mbrFloored.right + conf.CONNECTOR_ITEM_OFFSET);
-    horizontalLines.push(mbrFloored.top - conf.CONNECTOR_ITEM_OFFSET, mbrFloored.top, pointOnMbr.y, mbrFloored.bottom, mbrFloored.bottom + conf.CONNECTOR_ITEM_OFFSET);
-    return newPoint;
+    const pointOnMbrX = point5.x - offsetMap[dir2].x;
+    const pointOnMbrY = point5.y - offsetMap[dir2].y;
+    verticalLines.push(itemMbr.left - offset, itemMbr.left, pointOnMbrX, itemMbr.right, itemMbr.right + offset);
+    horizontalLines.push(itemMbr.top - offset, itemMbr.top, pointOnMbrY, itemMbr.bottom, itemMbr.bottom + offset);
   };
   if (start.pointType !== "Board" && startDir) {
-    newStart = processPoint(start, startDir);
+    processPoint(start, startDir);
   }
   if (end.pointType !== "Board" && endDir) {
-    newEnd = processPoint(end, endDir);
-  }
-  const finalStart = newStart || start;
-  const finalEnd = newEnd || end;
-  const middle = new Point((finalStart.x + finalEnd.x) / 2, (finalStart.y + finalEnd.y) / 2);
-  horizontalLines.push(middle.y, finalStart.y, finalEnd.y);
-  verticalLines.push(middle.x, finalStart.x, finalEnd.x);
-  toVisitPoints.forEach((p3) => {
+    processPoint(end, endDir);
+  }
+  const allPoints = [start, end, ...toVisitPoints];
+  allPoints.forEach((p3) => {
     horizontalLines.push(p3.y);
     verticalLines.push(p3.x);
   });
+  const middle = new Point((start.x + end.x) / 2, (start.y + end.y) / 2);
+  horizontalLines.push(middle.y);
+  verticalLines.push(middle.x);
   const uniqueHorizontalLines = Array.from(new Set(horizontalLines)).sort((a2, b) => a2 - b);
   const uniqueVerticalLines = Array.from(new Set(verticalLines)).sort((a2, b) => a2 - b);
   const grid = uniqueVerticalLines.map((x) => uniqueHorizontalLines.map((y) => new Point(x, y)));
   return {
     grid,
-    newStart,
-    newEnd,
-    middlePoint: middle
+    newStart: start,
+    newEnd: end
   };
 }
 function findPath(start, end, grid, obstacles, existingPath, newStart, newEnd) {
@@ -36934,18 +36929,15 @@ function reconstructPath(node2) {
   }
   return path2.reverse();
 }
-function preCalculatePathPoints(start, end) {
+function findOrthogonalPath(start, end, obstacles, toVisitPoints = []) {
   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") {
+    if (point5.pointType === "Board")
       return point5;
-    }
     const offsetMap = {
       top: { x: 0, y: -offset },
       bottom: { x: 0, y: offset },
@@ -36966,6 +36958,7 @@ function preCalculatePathPoints(start, end) {
   if (end.pointType !== "Board" && endDir) {
     endPoint = processPoint(end, endDir);
   }
+  const stemWaypoints = [];
   if (startDir) {
     let stem;
     if (startDir === "right")
@@ -36977,7 +36970,6 @@ function preCalculatePathPoints(start, end) {
     else
       stem = new Point(startPoint.x, startPoint.y - offset);
     stemWaypoints.push(stem);
-    allWaypoints.push(stem);
   }
   if (endDir) {
     let stem;
@@ -36990,14 +36982,9 @@ function preCalculatePathPoints(start, end) {
     else
       stem = new Point(endPoint.x, endPoint.y - offset);
     stemWaypoints.push(stem);
-    allWaypoints.push(stem);
   }
-  return { startPoint, endPoint, stemWaypoints, allWaypoints };
-}
-function findOrthogonalPath(start, end, obstacles, toVisitPoints = []) {
-  const { startPoint, endPoint, stemWaypoints, allWaypoints } = preCalculatePathPoints(start, end);
-  const gridPoints = [...allWaypoints, ...toVisitPoints];
-  const { grid, newStart, newEnd } = createGrid(start, end, gridPoints);
+  const allGridPoints = [startPoint, endPoint, ...stemWaypoints, ...toVisitPoints];
+  const { grid } = createGrid(startPoint, endPoint, allGridPoints);
   let finalWaypoints = [startPoint];
   if (stemWaypoints.length > 0) {
     finalWaypoints.push(stemWaypoints[0]);
@@ -37008,7 +36995,7 @@ function findOrthogonalPath(start, end, obstacles, toVisitPoints = []) {
   }
   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);
+  const pathPoints = findPathPoints(uniqueWaypoints, grid, obstacles, startPoint, endPoint);
   return {
     lines: getLines(pathPoints),
     newStart: startPoint,

package/dist/cjs/node.js

@@ -39204,50 +39204,45 @@ function createGrid(start, end, toVisitPoints = []) {
   const startDir = getPointerDirection(start);
   const endDir = getPointerDirection(end);
   const revertMapDir = { top: 0, bottom: 1, right: 2, left: 3 };
+  const offset = conf.CONNECTOR_ITEM_OFFSET;
   const offsetMap = {
-    top: { x: 0, y: -conf.CONNECTOR_ITEM_OFFSET },
-    bottom: { x: 0, y: conf.CONNECTOR_ITEM_OFFSET },
-    right: { x: conf.CONNECTOR_ITEM_OFFSET, y: 0 },
-    left: { x: -conf.CONNECTOR_ITEM_OFFSET, y: 0 }
+    top: { x: 0, y: -offset },
+    bottom: { x: 0, y: offset },
+    right: { x: offset, y: 0 },
+    left: { x: -offset, y: 0 }
   };
   const horizontalLines = [];
   const verticalLines = [];
-  let newStart;
-  let newEnd;
   const processPoint = (point5, dir2) => {
+    if (point5.pointType === "Board")
+      return;
     const itemMbr = point5.item.getMbr();
-    const mbrFloored = new Mbr(Math.floor(itemMbr.left), Math.floor(itemMbr.top), Math.floor(itemMbr.right), Math.floor(itemMbr.bottom));
-    const pointOnMbr = mbrFloored.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;
-    verticalLines.push(mbrFloored.left - conf.CONNECTOR_ITEM_OFFSET, mbrFloored.left, pointOnMbr.x, mbrFloored.right, mbrFloored.right + conf.CONNECTOR_ITEM_OFFSET);
-    horizontalLines.push(mbrFloored.top - conf.CONNECTOR_ITEM_OFFSET, mbrFloored.top, pointOnMbr.y, mbrFloored.bottom, mbrFloored.bottom + conf.CONNECTOR_ITEM_OFFSET);
-    return newPoint;
+    const pointOnMbrX = point5.x - offsetMap[dir2].x;
+    const pointOnMbrY = point5.y - offsetMap[dir2].y;
+    verticalLines.push(itemMbr.left - offset, itemMbr.left, pointOnMbrX, itemMbr.right, itemMbr.right + offset);
+    horizontalLines.push(itemMbr.top - offset, itemMbr.top, pointOnMbrY, itemMbr.bottom, itemMbr.bottom + offset);
   };
   if (start.pointType !== "Board" && startDir) {
-    newStart = processPoint(start, startDir);
+    processPoint(start, startDir);
   }
   if (end.pointType !== "Board" && endDir) {
-    newEnd = processPoint(end, endDir);
-  }
-  const finalStart = newStart || start;
-  const finalEnd = newEnd || end;
-  const middle = new Point((finalStart.x + finalEnd.x) / 2, (finalStart.y + finalEnd.y) / 2);
-  horizontalLines.push(middle.y, finalStart.y, finalEnd.y);
-  verticalLines.push(middle.x, finalStart.x, finalEnd.x);
-  toVisitPoints.forEach((p3) => {
+    processPoint(end, endDir);
+  }
+  const allPoints = [start, end, ...toVisitPoints];
+  allPoints.forEach((p3) => {
     horizontalLines.push(p3.y);
     verticalLines.push(p3.x);
   });
+  const middle = new Point((start.x + end.x) / 2, (start.y + end.y) / 2);
+  horizontalLines.push(middle.y);
+  verticalLines.push(middle.x);
   const uniqueHorizontalLines = Array.from(new Set(horizontalLines)).sort((a2, b) => a2 - b);
   const uniqueVerticalLines = Array.from(new Set(verticalLines)).sort((a2, b) => a2 - b);
   const grid = uniqueVerticalLines.map((x) => uniqueHorizontalLines.map((y) => new Point(x, y)));
   return {
     grid,
-    newStart,
-    newEnd,
-    middlePoint: middle
+    newStart: start,
+    newEnd: end
   };
 }
 function findPath(start, end, grid, obstacles, existingPath, newStart, newEnd) {
@@ -39407,18 +39402,15 @@ function reconstructPath(node2) {
   }
   return path2.reverse();
 }
-function preCalculatePathPoints(start, end) {
+function findOrthogonalPath(start, end, obstacles, toVisitPoints = []) {
   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") {
+    if (point5.pointType === "Board")
       return point5;
-    }
     const offsetMap = {
       top: { x: 0, y: -offset },
       bottom: { x: 0, y: offset },
@@ -39439,6 +39431,7 @@ function preCalculatePathPoints(start, end) {
   if (end.pointType !== "Board" && endDir) {
     endPoint = processPoint(end, endDir);
   }
+  const stemWaypoints = [];
   if (startDir) {
     let stem;
     if (startDir === "right")
@@ -39450,7 +39443,6 @@ function preCalculatePathPoints(start, end) {
     else
       stem = new Point(startPoint.x, startPoint.y - offset);
     stemWaypoints.push(stem);
-    allWaypoints.push(stem);
   }
   if (endDir) {
     let stem;
@@ -39463,14 +39455,9 @@ function preCalculatePathPoints(start, end) {
     else
       stem = new Point(endPoint.x, endPoint.y - offset);
     stemWaypoints.push(stem);
-    allWaypoints.push(stem);
   }
-  return { startPoint, endPoint, stemWaypoints, allWaypoints };
-}
-function findOrthogonalPath(start, end, obstacles, toVisitPoints = []) {
-  const { startPoint, endPoint, stemWaypoints, allWaypoints } = preCalculatePathPoints(start, end);
-  const gridPoints = [...allWaypoints, ...toVisitPoints];
-  const { grid, newStart, newEnd } = createGrid(start, end, gridPoints);
+  const allGridPoints = [startPoint, endPoint, ...stemWaypoints, ...toVisitPoints];
+  const { grid } = createGrid(startPoint, endPoint, allGridPoints);
   let finalWaypoints = [startPoint];
   if (stemWaypoints.length > 0) {
     finalWaypoints.push(stemWaypoints[0]);
@@ -39481,7 +39468,7 @@ function findOrthogonalPath(start, end, obstacles, toVisitPoints = []) {
   }
   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);
+  const pathPoints = findPathPoints(uniqueWaypoints, grid, obstacles, startPoint, endPoint);
   return {
     lines: getLines(pathPoints),
     newStart: startPoint,

package/dist/esm/browser.js

@@ -36576,50 +36576,45 @@ function createGrid(start, end, toVisitPoints = []) {
   const startDir = getPointerDirection(start);
   const endDir = getPointerDirection(end);
   const revertMapDir = { top: 0, bottom: 1, right: 2, left: 3 };
+  const offset = conf.CONNECTOR_ITEM_OFFSET;
   const offsetMap = {
-    top: { x: 0, y: -conf.CONNECTOR_ITEM_OFFSET },
-    bottom: { x: 0, y: conf.CONNECTOR_ITEM_OFFSET },
-    right: { x: conf.CONNECTOR_ITEM_OFFSET, y: 0 },
-    left: { x: -conf.CONNECTOR_ITEM_OFFSET, y: 0 }
+    top: { x: 0, y: -offset },
+    bottom: { x: 0, y: offset },
+    right: { x: offset, y: 0 },
+    left: { x: -offset, y: 0 }
   };
   const horizontalLines = [];
   const verticalLines = [];
-  let newStart;
-  let newEnd;
   const processPoint = (point5, dir2) => {
+    if (point5.pointType === "Board")
+      return;
     const itemMbr = point5.item.getMbr();
-    const mbrFloored = new Mbr(Math.floor(itemMbr.left), Math.floor(itemMbr.top), Math.floor(itemMbr.right), Math.floor(itemMbr.bottom));
-    const pointOnMbr = mbrFloored.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;
-    verticalLines.push(mbrFloored.left - conf.CONNECTOR_ITEM_OFFSET, mbrFloored.left, pointOnMbr.x, mbrFloored.right, mbrFloored.right + conf.CONNECTOR_ITEM_OFFSET);
-    horizontalLines.push(mbrFloored.top - conf.CONNECTOR_ITEM_OFFSET, mbrFloored.top, pointOnMbr.y, mbrFloored.bottom, mbrFloored.bottom + conf.CONNECTOR_ITEM_OFFSET);
-    return newPoint;
+    const pointOnMbrX = point5.x - offsetMap[dir2].x;
+    const pointOnMbrY = point5.y - offsetMap[dir2].y;
+    verticalLines.push(itemMbr.left - offset, itemMbr.left, pointOnMbrX, itemMbr.right, itemMbr.right + offset);
+    horizontalLines.push(itemMbr.top - offset, itemMbr.top, pointOnMbrY, itemMbr.bottom, itemMbr.bottom + offset);
   };
   if (start.pointType !== "Board" && startDir) {
-    newStart = processPoint(start, startDir);
+    processPoint(start, startDir);
   }
   if (end.pointType !== "Board" && endDir) {
-    newEnd = processPoint(end, endDir);
-  }
-  const finalStart = newStart || start;
-  const finalEnd = newEnd || end;
-  const middle = new Point((finalStart.x + finalEnd.x) / 2, (finalStart.y + finalEnd.y) / 2);
-  horizontalLines.push(middle.y, finalStart.y, finalEnd.y);
-  verticalLines.push(middle.x, finalStart.x, finalEnd.x);
-  toVisitPoints.forEach((p3) => {
+    processPoint(end, endDir);
+  }
+  const allPoints = [start, end, ...toVisitPoints];
+  allPoints.forEach((p3) => {
     horizontalLines.push(p3.y);
     verticalLines.push(p3.x);
   });
+  const middle = new Point((start.x + end.x) / 2, (start.y + end.y) / 2);
+  horizontalLines.push(middle.y);
+  verticalLines.push(middle.x);
   const uniqueHorizontalLines = Array.from(new Set(horizontalLines)).sort((a2, b) => a2 - b);
   const uniqueVerticalLines = Array.from(new Set(verticalLines)).sort((a2, b) => a2 - b);
   const grid = uniqueVerticalLines.map((x) => uniqueHorizontalLines.map((y) => new Point(x, y)));
   return {
     grid,
-    newStart,
-    newEnd,
-    middlePoint: middle
+    newStart: start,
+    newEnd: end
   };
 }
 function findPath(start, end, grid, obstacles, existingPath, newStart, newEnd) {
@@ -36779,18 +36774,15 @@ function reconstructPath(node2) {
   }
   return path2.reverse();
 }
-function preCalculatePathPoints(start, end) {
+function findOrthogonalPath(start, end, obstacles, toVisitPoints = []) {
   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") {
+    if (point5.pointType === "Board")
       return point5;
-    }
     const offsetMap = {
       top: { x: 0, y: -offset },
       bottom: { x: 0, y: offset },
@@ -36811,6 +36803,7 @@ function preCalculatePathPoints(start, end) {
   if (end.pointType !== "Board" && endDir) {
     endPoint = processPoint(end, endDir);
   }
+  const stemWaypoints = [];
   if (startDir) {
     let stem;
     if (startDir === "right")
@@ -36822,7 +36815,6 @@ function preCalculatePathPoints(start, end) {
     else
       stem = new Point(startPoint.x, startPoint.y - offset);
     stemWaypoints.push(stem);
-    allWaypoints.push(stem);
   }
   if (endDir) {
     let stem;
@@ -36835,14 +36827,9 @@ function preCalculatePathPoints(start, end) {
     else
       stem = new Point(endPoint.x, endPoint.y - offset);
     stemWaypoints.push(stem);
-    allWaypoints.push(stem);
   }
-  return { startPoint, endPoint, stemWaypoints, allWaypoints };
-}
-function findOrthogonalPath(start, end, obstacles, toVisitPoints = []) {
-  const { startPoint, endPoint, stemWaypoints, allWaypoints } = preCalculatePathPoints(start, end);
-  const gridPoints = [...allWaypoints, ...toVisitPoints];
-  const { grid, newStart, newEnd } = createGrid(start, end, gridPoints);
+  const allGridPoints = [startPoint, endPoint, ...stemWaypoints, ...toVisitPoints];
+  const { grid } = createGrid(startPoint, endPoint, allGridPoints);
   let finalWaypoints = [startPoint];
   if (stemWaypoints.length > 0) {
     finalWaypoints.push(stemWaypoints[0]);
@@ -36853,7 +36840,7 @@ function findOrthogonalPath(start, end, obstacles, toVisitPoints = []) {
   }
   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);
+  const pathPoints = findPathPoints(uniqueWaypoints, grid, obstacles, startPoint, endPoint);
   return {
     lines: getLines(pathPoints),
     newStart: startPoint,

package/dist/esm/index.js

@@ -36569,50 +36569,45 @@ function createGrid(start, end, toVisitPoints = []) {
   const startDir = getPointerDirection(start);
   const endDir = getPointerDirection(end);
   const revertMapDir = { top: 0, bottom: 1, right: 2, left: 3 };
+  const offset = conf.CONNECTOR_ITEM_OFFSET;
   const offsetMap = {
-    top: { x: 0, y: -conf.CONNECTOR_ITEM_OFFSET },
-    bottom: { x: 0, y: conf.CONNECTOR_ITEM_OFFSET },
-    right: { x: conf.CONNECTOR_ITEM_OFFSET, y: 0 },
-    left: { x: -conf.CONNECTOR_ITEM_OFFSET, y: 0 }
+    top: { x: 0, y: -offset },
+    bottom: { x: 0, y: offset },
+    right: { x: offset, y: 0 },
+    left: { x: -offset, y: 0 }
   };
   const horizontalLines = [];
   const verticalLines = [];
-  let newStart;
-  let newEnd;
   const processPoint = (point5, dir2) => {
+    if (point5.pointType === "Board")
+      return;
     const itemMbr = point5.item.getMbr();
-    const mbrFloored = new Mbr(Math.floor(itemMbr.left), Math.floor(itemMbr.top), Math.floor(itemMbr.right), Math.floor(itemMbr.bottom));
-    const pointOnMbr = mbrFloored.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;
-    verticalLines.push(mbrFloored.left - conf.CONNECTOR_ITEM_OFFSET, mbrFloored.left, pointOnMbr.x, mbrFloored.right, mbrFloored.right + conf.CONNECTOR_ITEM_OFFSET);
-    horizontalLines.push(mbrFloored.top - conf.CONNECTOR_ITEM_OFFSET, mbrFloored.top, pointOnMbr.y, mbrFloored.bottom, mbrFloored.bottom + conf.CONNECTOR_ITEM_OFFSET);
-    return newPoint;
+    const pointOnMbrX = point5.x - offsetMap[dir2].x;
+    const pointOnMbrY = point5.y - offsetMap[dir2].y;
+    verticalLines.push(itemMbr.left - offset, itemMbr.left, pointOnMbrX, itemMbr.right, itemMbr.right + offset);
+    horizontalLines.push(itemMbr.top - offset, itemMbr.top, pointOnMbrY, itemMbr.bottom, itemMbr.bottom + offset);
   };
   if (start.pointType !== "Board" && startDir) {
-    newStart = processPoint(start, startDir);
+    processPoint(start, startDir);
   }
   if (end.pointType !== "Board" && endDir) {
-    newEnd = processPoint(end, endDir);
-  }
-  const finalStart = newStart || start;
-  const finalEnd = newEnd || end;
-  const middle = new Point((finalStart.x + finalEnd.x) / 2, (finalStart.y + finalEnd.y) / 2);
-  horizontalLines.push(middle.y, finalStart.y, finalEnd.y);
-  verticalLines.push(middle.x, finalStart.x, finalEnd.x);
-  toVisitPoints.forEach((p3) => {
+    processPoint(end, endDir);
+  }
+  const allPoints = [start, end, ...toVisitPoints];
+  allPoints.forEach((p3) => {
     horizontalLines.push(p3.y);
     verticalLines.push(p3.x);
   });
+  const middle = new Point((start.x + end.x) / 2, (start.y + end.y) / 2);
+  horizontalLines.push(middle.y);
+  verticalLines.push(middle.x);
   const uniqueHorizontalLines = Array.from(new Set(horizontalLines)).sort((a2, b) => a2 - b);
   const uniqueVerticalLines = Array.from(new Set(verticalLines)).sort((a2, b) => a2 - b);
   const grid = uniqueVerticalLines.map((x) => uniqueHorizontalLines.map((y) => new Point(x, y)));
   return {
     grid,
-    newStart,
-    newEnd,
-    middlePoint: middle
+    newStart: start,
+    newEnd: end
   };
 }
 function findPath(start, end, grid, obstacles, existingPath, newStart, newEnd) {
@@ -36772,18 +36767,15 @@ function reconstructPath(node2) {
   }
   return path2.reverse();
 }
-function preCalculatePathPoints(start, end) {
+function findOrthogonalPath(start, end, obstacles, toVisitPoints = []) {
   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") {
+    if (point5.pointType === "Board")
       return point5;
-    }
     const offsetMap = {
       top: { x: 0, y: -offset },
       bottom: { x: 0, y: offset },
@@ -36804,6 +36796,7 @@ function preCalculatePathPoints(start, end) {
   if (end.pointType !== "Board" && endDir) {
     endPoint = processPoint(end, endDir);
   }
+  const stemWaypoints = [];
   if (startDir) {
     let stem;
     if (startDir === "right")
@@ -36815,7 +36808,6 @@ function preCalculatePathPoints(start, end) {
     else
       stem = new Point(startPoint.x, startPoint.y - offset);
     stemWaypoints.push(stem);
-    allWaypoints.push(stem);
   }
   if (endDir) {
     let stem;
@@ -36828,14 +36820,9 @@ function preCalculatePathPoints(start, end) {
     else
       stem = new Point(endPoint.x, endPoint.y - offset);
     stemWaypoints.push(stem);
-    allWaypoints.push(stem);
   }
-  return { startPoint, endPoint, stemWaypoints, allWaypoints };
-}
-function findOrthogonalPath(start, end, obstacles, toVisitPoints = []) {
-  const { startPoint, endPoint, stemWaypoints, allWaypoints } = preCalculatePathPoints(start, end);
-  const gridPoints = [...allWaypoints, ...toVisitPoints];
-  const { grid, newStart, newEnd } = createGrid(start, end, gridPoints);
+  const allGridPoints = [startPoint, endPoint, ...stemWaypoints, ...toVisitPoints];
+  const { grid } = createGrid(startPoint, endPoint, allGridPoints);
   let finalWaypoints = [startPoint];
   if (stemWaypoints.length > 0) {
     finalWaypoints.push(stemWaypoints[0]);
@@ -36846,7 +36833,7 @@ function findOrthogonalPath(start, end, obstacles, toVisitPoints = []) {
   }
   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);
+  const pathPoints = findPathPoints(uniqueWaypoints, grid, obstacles, startPoint, endPoint);
   return {
     lines: getLines(pathPoints),
     newStart: startPoint,

package/dist/esm/node.js

@@ -39037,50 +39037,45 @@ function createGrid(start, end, toVisitPoints = []) {
   const startDir = getPointerDirection(start);
   const endDir = getPointerDirection(end);
   const revertMapDir = { top: 0, bottom: 1, right: 2, left: 3 };
+  const offset = conf.CONNECTOR_ITEM_OFFSET;
   const offsetMap = {
-    top: { x: 0, y: -conf.CONNECTOR_ITEM_OFFSET },
-    bottom: { x: 0, y: conf.CONNECTOR_ITEM_OFFSET },
-    right: { x: conf.CONNECTOR_ITEM_OFFSET, y: 0 },
-    left: { x: -conf.CONNECTOR_ITEM_OFFSET, y: 0 }
+    top: { x: 0, y: -offset },
+    bottom: { x: 0, y: offset },
+    right: { x: offset, y: 0 },
+    left: { x: -offset, y: 0 }
   };
   const horizontalLines = [];
   const verticalLines = [];
-  let newStart;
-  let newEnd;
   const processPoint = (point5, dir2) => {
+    if (point5.pointType === "Board")
+      return;
     const itemMbr = point5.item.getMbr();
-    const mbrFloored = new Mbr(Math.floor(itemMbr.left), Math.floor(itemMbr.top), Math.floor(itemMbr.right), Math.floor(itemMbr.bottom));
-    const pointOnMbr = mbrFloored.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;
-    verticalLines.push(mbrFloored.left - conf.CONNECTOR_ITEM_OFFSET, mbrFloored.left, pointOnMbr.x, mbrFloored.right, mbrFloored.right + conf.CONNECTOR_ITEM_OFFSET);
-    horizontalLines.push(mbrFloored.top - conf.CONNECTOR_ITEM_OFFSET, mbrFloored.top, pointOnMbr.y, mbrFloored.bottom, mbrFloored.bottom + conf.CONNECTOR_ITEM_OFFSET);
-    return newPoint;
+    const pointOnMbrX = point5.x - offsetMap[dir2].x;
+    const pointOnMbrY = point5.y - offsetMap[dir2].y;
+    verticalLines.push(itemMbr.left - offset, itemMbr.left, pointOnMbrX, itemMbr.right, itemMbr.right + offset);
+    horizontalLines.push(itemMbr.top - offset, itemMbr.top, pointOnMbrY, itemMbr.bottom, itemMbr.bottom + offset);
   };
   if (start.pointType !== "Board" && startDir) {
-    newStart = processPoint(start, startDir);
+    processPoint(start, startDir);
   }
   if (end.pointType !== "Board" && endDir) {
-    newEnd = processPoint(end, endDir);
-  }
-  const finalStart = newStart || start;
-  const finalEnd = newEnd || end;
-  const middle = new Point((finalStart.x + finalEnd.x) / 2, (finalStart.y + finalEnd.y) / 2);
-  horizontalLines.push(middle.y, finalStart.y, finalEnd.y);
-  verticalLines.push(middle.x, finalStart.x, finalEnd.x);
-  toVisitPoints.forEach((p3) => {
+    processPoint(end, endDir);
+  }
+  const allPoints = [start, end, ...toVisitPoints];
+  allPoints.forEach((p3) => {
     horizontalLines.push(p3.y);
     verticalLines.push(p3.x);
   });
+  const middle = new Point((start.x + end.x) / 2, (start.y + end.y) / 2);
+  horizontalLines.push(middle.y);
+  verticalLines.push(middle.x);
   const uniqueHorizontalLines = Array.from(new Set(horizontalLines)).sort((a2, b) => a2 - b);
   const uniqueVerticalLines = Array.from(new Set(verticalLines)).sort((a2, b) => a2 - b);
   const grid = uniqueVerticalLines.map((x) => uniqueHorizontalLines.map((y) => new Point(x, y)));
   return {
     grid,
-    newStart,
-    newEnd,
-    middlePoint: middle
+    newStart: start,
+    newEnd: end
   };
 }
 function findPath(start, end, grid, obstacles, existingPath, newStart, newEnd) {
@@ -39240,18 +39235,15 @@ function reconstructPath(node2) {
   }
   return path2.reverse();
 }
-function preCalculatePathPoints(start, end) {
+function findOrthogonalPath(start, end, obstacles, toVisitPoints = []) {
   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") {
+    if (point5.pointType === "Board")
       return point5;
-    }
     const offsetMap = {
       top: { x: 0, y: -offset },
       bottom: { x: 0, y: offset },
@@ -39272,6 +39264,7 @@ function preCalculatePathPoints(start, end) {
   if (end.pointType !== "Board" && endDir) {
     endPoint = processPoint(end, endDir);
   }
+  const stemWaypoints = [];
   if (startDir) {
     let stem;
     if (startDir === "right")
@@ -39283,7 +39276,6 @@ function preCalculatePathPoints(start, end) {
     else
       stem = new Point(startPoint.x, startPoint.y - offset);
     stemWaypoints.push(stem);
-    allWaypoints.push(stem);
   }
   if (endDir) {
     let stem;
@@ -39296,14 +39288,9 @@ function preCalculatePathPoints(start, end) {
     else
       stem = new Point(endPoint.x, endPoint.y - offset);
     stemWaypoints.push(stem);
-    allWaypoints.push(stem);
   }
-  return { startPoint, endPoint, stemWaypoints, allWaypoints };
-}
-function findOrthogonalPath(start, end, obstacles, toVisitPoints = []) {
-  const { startPoint, endPoint, stemWaypoints, allWaypoints } = preCalculatePathPoints(start, end);
-  const gridPoints = [...allWaypoints, ...toVisitPoints];
-  const { grid, newStart, newEnd } = createGrid(start, end, gridPoints);
+  const allGridPoints = [startPoint, endPoint, ...stemWaypoints, ...toVisitPoints];
+  const { grid } = createGrid(startPoint, endPoint, allGridPoints);
   let finalWaypoints = [startPoint];
   if (stemWaypoints.length > 0) {
     finalWaypoints.push(stemWaypoints[0]);
@@ -39314,7 +39301,7 @@ function findOrthogonalPath(start, end, obstacles, toVisitPoints = []) {
   }
   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);
+  const pathPoints = findPathPoints(uniqueWaypoints, grid, obstacles, startPoint, endPoint);
   return {
     lines: getLines(pathPoints),
     newStart: startPoint,

package/package.json

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