npm - microboard-temp - Versions diffs - 0.5.81 → 0.5.83 - Mend

microboard-temp 0.5.81 → 0.5.83

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (7) hide show

package/dist/cjs/browser.js CHANGED Viewed

@@ -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,71 +36929,77 @@ function reconstructPath(node2) {
   }
   return path2.reverse();
 }
-function createStemWaypoints(startPoint, endPoint, startDir, endDir) {
-  const waypoints = [];
+function findOrthogonalPath(start, end, obstacles, toVisitPoints = []) {
+  const startDir = getPointerDirection(start);
+  const endDir = getPointerDirection(end);
   const offset = conf.CONNECTOR_ITEM_OFFSET;
-  if (offset <= 0) {
-    return [];
+  let startPoint = start;
+  let endPoint = end;
+  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 (end.pointType !== "Board" && endDir) {
+    endPoint = processPoint(end, endDir);
   }
+  const stemWaypoints = [];
   if (startDir) {
-    let waypoint;
-    switch (startDir) {
-      case "right":
-        waypoint = new Point(startPoint.x + offset, startPoint.y);
-        break;
-      case "left":
-        waypoint = new Point(startPoint.x - offset, startPoint.y);
-        break;
-      case "bottom":
-        waypoint = new Point(startPoint.x, startPoint.y + offset);
-        break;
-      case "top":
-        waypoint = new Point(startPoint.x, startPoint.y - offset);
-        break;
-    }
-    waypoints.push(waypoint);
+    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);
   }
   if (endDir) {
-    let waypoint;
-    switch (endDir) {
-      case "right":
-        waypoint = new Point(endPoint.x + offset, endPoint.y);
-        break;
-      case "left":
-        waypoint = new Point(endPoint.x - offset, endPoint.y);
-        break;
-      case "bottom":
-        waypoint = new Point(endPoint.x, endPoint.y + offset);
-        break;
-      case "top":
-        waypoint = new Point(endPoint.x, endPoint.y - offset);
-        break;
-    }
-    waypoints.push(waypoint);
+    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);
   }
-  return waypoints;
-}
-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 stemWaypoints = createStemWaypoints(startPoint, endPoint, startDir, endDir);
-  let finalWaypoints = [];
+  const allGridPoints = [startPoint, endPoint, ...stemWaypoints, ...toVisitPoints];
+  const { grid } = createGrid(startPoint, endPoint, allGridPoints);
+  let finalWaypoints = [startPoint];
   if (stemWaypoints.length > 0) {
-    const startStem = stemWaypoints[0];
-    const endStem = stemWaypoints[1] || startStem;
-    finalWaypoints = [startPoint, startStem, ...toVisitPoints, endStem, endPoint];
-  } else {
-    finalWaypoints = [startPoint, ...toVisitPoints, endPoint];
+    finalWaypoints.push(stemWaypoints[0]);
+  }
+  finalWaypoints.push(...toVisitPoints);
+  if (stemWaypoints.length > 1) {
+    finalWaypoints.push(stemWaypoints[1]);
   }
-  const uniqueWaypoints = finalWaypoints.filter((point5, index2, self2) => index2 === self2.findIndex((p3) => p3.x === point5.x && p3.y === point5.y));
-  const pathPoints = findPathPoints(uniqueWaypoints, grid, obstacles, newStart, newEnd);
+  finalWaypoints.push(endPoint);
+  const uniqueWaypoints = finalWaypoints.filter((point5, index2, self2) => index2 === 0 || !point5.barelyEqual(self2[index2 - 1]));
+  const pathPoints = findPathPoints(uniqueWaypoints, grid, obstacles, startPoint, endPoint);
   return {
     lines: getLines(pathPoints),
-    newStart,
-    newEnd
+    newStart: startPoint,
+    newEnd: endPoint
   };
 }

package/dist/cjs/index.js CHANGED Viewed

@@ -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,71 +36929,77 @@ function reconstructPath(node2) {
   }
   return path2.reverse();
 }
-function createStemWaypoints(startPoint, endPoint, startDir, endDir) {
-  const waypoints = [];
+function findOrthogonalPath(start, end, obstacles, toVisitPoints = []) {
+  const startDir = getPointerDirection(start);
+  const endDir = getPointerDirection(end);
   const offset = conf.CONNECTOR_ITEM_OFFSET;
-  if (offset <= 0) {
-    return [];
+  let startPoint = start;
+  let endPoint = end;
+  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 (end.pointType !== "Board" && endDir) {
+    endPoint = processPoint(end, endDir);
   }
+  const stemWaypoints = [];
   if (startDir) {
-    let waypoint;
-    switch (startDir) {
-      case "right":
-        waypoint = new Point(startPoint.x + offset, startPoint.y);
-        break;
-      case "left":
-        waypoint = new Point(startPoint.x - offset, startPoint.y);
-        break;
-      case "bottom":
-        waypoint = new Point(startPoint.x, startPoint.y + offset);
-        break;
-      case "top":
-        waypoint = new Point(startPoint.x, startPoint.y - offset);
-        break;
-    }
-    waypoints.push(waypoint);
+    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);
   }
   if (endDir) {
-    let waypoint;
-    switch (endDir) {
-      case "right":
-        waypoint = new Point(endPoint.x + offset, endPoint.y);
-        break;
-      case "left":
-        waypoint = new Point(endPoint.x - offset, endPoint.y);
-        break;
-      case "bottom":
-        waypoint = new Point(endPoint.x, endPoint.y + offset);
-        break;
-      case "top":
-        waypoint = new Point(endPoint.x, endPoint.y - offset);
-        break;
-    }
-    waypoints.push(waypoint);
+    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);
   }
-  return waypoints;
-}
-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 stemWaypoints = createStemWaypoints(startPoint, endPoint, startDir, endDir);
-  let finalWaypoints = [];
+  const allGridPoints = [startPoint, endPoint, ...stemWaypoints, ...toVisitPoints];
+  const { grid } = createGrid(startPoint, endPoint, allGridPoints);
+  let finalWaypoints = [startPoint];
   if (stemWaypoints.length > 0) {
-    const startStem = stemWaypoints[0];
-    const endStem = stemWaypoints[1] || startStem;
-    finalWaypoints = [startPoint, startStem, ...toVisitPoints, endStem, endPoint];
-  } else {
-    finalWaypoints = [startPoint, ...toVisitPoints, endPoint];
+    finalWaypoints.push(stemWaypoints[0]);
+  }
+  finalWaypoints.push(...toVisitPoints);
+  if (stemWaypoints.length > 1) {
+    finalWaypoints.push(stemWaypoints[1]);
   }
-  const uniqueWaypoints = finalWaypoints.filter((point5, index2, self2) => index2 === self2.findIndex((p3) => p3.x === point5.x && p3.y === point5.y));
-  const pathPoints = findPathPoints(uniqueWaypoints, grid, obstacles, newStart, newEnd);
+  finalWaypoints.push(endPoint);
+  const uniqueWaypoints = finalWaypoints.filter((point5, index2, self2) => index2 === 0 || !point5.barelyEqual(self2[index2 - 1]));
+  const pathPoints = findPathPoints(uniqueWaypoints, grid, obstacles, startPoint, endPoint);
   return {
     lines: getLines(pathPoints),
-    newStart,
-    newEnd
+    newStart: startPoint,
+    newEnd: endPoint
   };
 }

package/dist/cjs/node.js CHANGED Viewed

@@ -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,71 +39402,77 @@ function reconstructPath(node2) {
   }
   return path2.reverse();
 }
-function createStemWaypoints(startPoint, endPoint, startDir, endDir) {
-  const waypoints = [];
+function findOrthogonalPath(start, end, obstacles, toVisitPoints = []) {
+  const startDir = getPointerDirection(start);
+  const endDir = getPointerDirection(end);
   const offset = conf.CONNECTOR_ITEM_OFFSET;
-  if (offset <= 0) {
-    return [];
+  let startPoint = start;
+  let endPoint = end;
+  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 (end.pointType !== "Board" && endDir) {
+    endPoint = processPoint(end, endDir);
   }
+  const stemWaypoints = [];
   if (startDir) {
-    let waypoint;
-    switch (startDir) {
-      case "right":
-        waypoint = new Point(startPoint.x + offset, startPoint.y);
-        break;
-      case "left":
-        waypoint = new Point(startPoint.x - offset, startPoint.y);
-        break;
-      case "bottom":
-        waypoint = new Point(startPoint.x, startPoint.y + offset);
-        break;
-      case "top":
-        waypoint = new Point(startPoint.x, startPoint.y - offset);
-        break;
-    }
-    waypoints.push(waypoint);
+    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);
   }
   if (endDir) {
-    let waypoint;
-    switch (endDir) {
-      case "right":
-        waypoint = new Point(endPoint.x + offset, endPoint.y);
-        break;
-      case "left":
-        waypoint = new Point(endPoint.x - offset, endPoint.y);
-        break;
-      case "bottom":
-        waypoint = new Point(endPoint.x, endPoint.y + offset);
-        break;
-      case "top":
-        waypoint = new Point(endPoint.x, endPoint.y - offset);
-        break;
-    }
-    waypoints.push(waypoint);
+    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);
   }
-  return waypoints;
-}
-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 stemWaypoints = createStemWaypoints(startPoint, endPoint, startDir, endDir);
-  let finalWaypoints = [];
+  const allGridPoints = [startPoint, endPoint, ...stemWaypoints, ...toVisitPoints];
+  const { grid } = createGrid(startPoint, endPoint, allGridPoints);
+  let finalWaypoints = [startPoint];
   if (stemWaypoints.length > 0) {
-    const startStem = stemWaypoints[0];
-    const endStem = stemWaypoints[1] || startStem;
-    finalWaypoints = [startPoint, startStem, ...toVisitPoints, endStem, endPoint];
-  } else {
-    finalWaypoints = [startPoint, ...toVisitPoints, endPoint];
+    finalWaypoints.push(stemWaypoints[0]);
+  }
+  finalWaypoints.push(...toVisitPoints);
+  if (stemWaypoints.length > 1) {
+    finalWaypoints.push(stemWaypoints[1]);
   }
-  const uniqueWaypoints = finalWaypoints.filter((point5, index2, self2) => index2 === self2.findIndex((p3) => p3.x === point5.x && p3.y === point5.y));
-  const pathPoints = findPathPoints(uniqueWaypoints, grid, obstacles, newStart, newEnd);
+  finalWaypoints.push(endPoint);
+  const uniqueWaypoints = finalWaypoints.filter((point5, index2, self2) => index2 === 0 || !point5.barelyEqual(self2[index2 - 1]));
+  const pathPoints = findPathPoints(uniqueWaypoints, grid, obstacles, startPoint, endPoint);
   return {
     lines: getLines(pathPoints),
-    newStart,
-    newEnd
+    newStart: startPoint,
+    newEnd: endPoint
   };
 }

package/dist/esm/browser.js CHANGED Viewed

@@ -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,71 +36774,77 @@ function reconstructPath(node2) {
   }
   return path2.reverse();
 }
-function createStemWaypoints(startPoint, endPoint, startDir, endDir) {
-  const waypoints = [];
+function findOrthogonalPath(start, end, obstacles, toVisitPoints = []) {
+  const startDir = getPointerDirection(start);
+  const endDir = getPointerDirection(end);
   const offset = conf.CONNECTOR_ITEM_OFFSET;
-  if (offset <= 0) {
-    return [];
+  let startPoint = start;
+  let endPoint = end;
+  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 (end.pointType !== "Board" && endDir) {
+    endPoint = processPoint(end, endDir);
   }
+  const stemWaypoints = [];
   if (startDir) {
-    let waypoint;
-    switch (startDir) {
-      case "right":
-        waypoint = new Point(startPoint.x + offset, startPoint.y);
-        break;
-      case "left":
-        waypoint = new Point(startPoint.x - offset, startPoint.y);
-        break;
-      case "bottom":
-        waypoint = new Point(startPoint.x, startPoint.y + offset);
-        break;
-      case "top":
-        waypoint = new Point(startPoint.x, startPoint.y - offset);
-        break;
-    }
-    waypoints.push(waypoint);
+    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);
   }
   if (endDir) {
-    let waypoint;
-    switch (endDir) {
-      case "right":
-        waypoint = new Point(endPoint.x + offset, endPoint.y);
-        break;
-      case "left":
-        waypoint = new Point(endPoint.x - offset, endPoint.y);
-        break;
-      case "bottom":
-        waypoint = new Point(endPoint.x, endPoint.y + offset);
-        break;
-      case "top":
-        waypoint = new Point(endPoint.x, endPoint.y - offset);
-        break;
-    }
-    waypoints.push(waypoint);
+    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);
   }
-  return waypoints;
-}
-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 stemWaypoints = createStemWaypoints(startPoint, endPoint, startDir, endDir);
-  let finalWaypoints = [];
+  const allGridPoints = [startPoint, endPoint, ...stemWaypoints, ...toVisitPoints];
+  const { grid } = createGrid(startPoint, endPoint, allGridPoints);
+  let finalWaypoints = [startPoint];
   if (stemWaypoints.length > 0) {
-    const startStem = stemWaypoints[0];
-    const endStem = stemWaypoints[1] || startStem;
-    finalWaypoints = [startPoint, startStem, ...toVisitPoints, endStem, endPoint];
-  } else {
-    finalWaypoints = [startPoint, ...toVisitPoints, endPoint];
+    finalWaypoints.push(stemWaypoints[0]);
+  }
+  finalWaypoints.push(...toVisitPoints);
+  if (stemWaypoints.length > 1) {
+    finalWaypoints.push(stemWaypoints[1]);
   }
-  const uniqueWaypoints = finalWaypoints.filter((point5, index2, self2) => index2 === self2.findIndex((p3) => p3.x === point5.x && p3.y === point5.y));
-  const pathPoints = findPathPoints(uniqueWaypoints, grid, obstacles, newStart, newEnd);
+  finalWaypoints.push(endPoint);
+  const uniqueWaypoints = finalWaypoints.filter((point5, index2, self2) => index2 === 0 || !point5.barelyEqual(self2[index2 - 1]));
+  const pathPoints = findPathPoints(uniqueWaypoints, grid, obstacles, startPoint, endPoint);
   return {
     lines: getLines(pathPoints),
-    newStart,
-    newEnd
+    newStart: startPoint,
+    newEnd: endPoint
   };
 }

package/dist/esm/index.js CHANGED Viewed

@@ -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,71 +36767,77 @@ function reconstructPath(node2) {
   }
   return path2.reverse();
 }
-function createStemWaypoints(startPoint, endPoint, startDir, endDir) {
-  const waypoints = [];
+function findOrthogonalPath(start, end, obstacles, toVisitPoints = []) {
+  const startDir = getPointerDirection(start);
+  const endDir = getPointerDirection(end);
   const offset = conf.CONNECTOR_ITEM_OFFSET;
-  if (offset <= 0) {
-    return [];
+  let startPoint = start;
+  let endPoint = end;
+  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 (end.pointType !== "Board" && endDir) {
+    endPoint = processPoint(end, endDir);
   }
+  const stemWaypoints = [];
   if (startDir) {
-    let waypoint;
-    switch (startDir) {
-      case "right":
-        waypoint = new Point(startPoint.x + offset, startPoint.y);
-        break;
-      case "left":
-        waypoint = new Point(startPoint.x - offset, startPoint.y);
-        break;
-      case "bottom":
-        waypoint = new Point(startPoint.x, startPoint.y + offset);
-        break;
-      case "top":
-        waypoint = new Point(startPoint.x, startPoint.y - offset);
-        break;
-    }
-    waypoints.push(waypoint);
+    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);
   }
   if (endDir) {
-    let waypoint;
-    switch (endDir) {
-      case "right":
-        waypoint = new Point(endPoint.x + offset, endPoint.y);
-        break;
-      case "left":
-        waypoint = new Point(endPoint.x - offset, endPoint.y);
-        break;
-      case "bottom":
-        waypoint = new Point(endPoint.x, endPoint.y + offset);
-        break;
-      case "top":
-        waypoint = new Point(endPoint.x, endPoint.y - offset);
-        break;
-    }
-    waypoints.push(waypoint);
+    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);
   }
-  return waypoints;
-}
-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 stemWaypoints = createStemWaypoints(startPoint, endPoint, startDir, endDir);
-  let finalWaypoints = [];
+  const allGridPoints = [startPoint, endPoint, ...stemWaypoints, ...toVisitPoints];
+  const { grid } = createGrid(startPoint, endPoint, allGridPoints);
+  let finalWaypoints = [startPoint];
   if (stemWaypoints.length > 0) {
-    const startStem = stemWaypoints[0];
-    const endStem = stemWaypoints[1] || startStem;
-    finalWaypoints = [startPoint, startStem, ...toVisitPoints, endStem, endPoint];
-  } else {
-    finalWaypoints = [startPoint, ...toVisitPoints, endPoint];
+    finalWaypoints.push(stemWaypoints[0]);
+  }
+  finalWaypoints.push(...toVisitPoints);
+  if (stemWaypoints.length > 1) {
+    finalWaypoints.push(stemWaypoints[1]);
   }
-  const uniqueWaypoints = finalWaypoints.filter((point5, index2, self2) => index2 === self2.findIndex((p3) => p3.x === point5.x && p3.y === point5.y));
-  const pathPoints = findPathPoints(uniqueWaypoints, grid, obstacles, newStart, newEnd);
+  finalWaypoints.push(endPoint);
+  const uniqueWaypoints = finalWaypoints.filter((point5, index2, self2) => index2 === 0 || !point5.barelyEqual(self2[index2 - 1]));
+  const pathPoints = findPathPoints(uniqueWaypoints, grid, obstacles, startPoint, endPoint);
   return {
     lines: getLines(pathPoints),
-    newStart,
-    newEnd
+    newStart: startPoint,
+    newEnd: endPoint
   };
 }

package/dist/esm/node.js CHANGED Viewed

@@ -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,71 +39235,77 @@ function reconstructPath(node2) {
   }
   return path2.reverse();
 }
-function createStemWaypoints(startPoint, endPoint, startDir, endDir) {
-  const waypoints = [];
+function findOrthogonalPath(start, end, obstacles, toVisitPoints = []) {
+  const startDir = getPointerDirection(start);
+  const endDir = getPointerDirection(end);
   const offset = conf.CONNECTOR_ITEM_OFFSET;
-  if (offset <= 0) {
-    return [];
+  let startPoint = start;
+  let endPoint = end;
+  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 (end.pointType !== "Board" && endDir) {
+    endPoint = processPoint(end, endDir);
   }
+  const stemWaypoints = [];
   if (startDir) {
-    let waypoint;
-    switch (startDir) {
-      case "right":
-        waypoint = new Point(startPoint.x + offset, startPoint.y);
-        break;
-      case "left":
-        waypoint = new Point(startPoint.x - offset, startPoint.y);
-        break;
-      case "bottom":
-        waypoint = new Point(startPoint.x, startPoint.y + offset);
-        break;
-      case "top":
-        waypoint = new Point(startPoint.x, startPoint.y - offset);
-        break;
-    }
-    waypoints.push(waypoint);
+    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);
   }
   if (endDir) {
-    let waypoint;
-    switch (endDir) {
-      case "right":
-        waypoint = new Point(endPoint.x + offset, endPoint.y);
-        break;
-      case "left":
-        waypoint = new Point(endPoint.x - offset, endPoint.y);
-        break;
-      case "bottom":
-        waypoint = new Point(endPoint.x, endPoint.y + offset);
-        break;
-      case "top":
-        waypoint = new Point(endPoint.x, endPoint.y - offset);
-        break;
-    }
-    waypoints.push(waypoint);
+    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);
   }
-  return waypoints;
-}
-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 stemWaypoints = createStemWaypoints(startPoint, endPoint, startDir, endDir);
-  let finalWaypoints = [];
+  const allGridPoints = [startPoint, endPoint, ...stemWaypoints, ...toVisitPoints];
+  const { grid } = createGrid(startPoint, endPoint, allGridPoints);
+  let finalWaypoints = [startPoint];
   if (stemWaypoints.length > 0) {
-    const startStem = stemWaypoints[0];
-    const endStem = stemWaypoints[1] || startStem;
-    finalWaypoints = [startPoint, startStem, ...toVisitPoints, endStem, endPoint];
-  } else {
-    finalWaypoints = [startPoint, ...toVisitPoints, endPoint];
+    finalWaypoints.push(stemWaypoints[0]);
+  }
+  finalWaypoints.push(...toVisitPoints);
+  if (stemWaypoints.length > 1) {
+    finalWaypoints.push(stemWaypoints[1]);
   }
-  const uniqueWaypoints = finalWaypoints.filter((point5, index2, self2) => index2 === self2.findIndex((p3) => p3.x === point5.x && p3.y === point5.y));
-  const pathPoints = findPathPoints(uniqueWaypoints, grid, obstacles, newStart, newEnd);
+  finalWaypoints.push(endPoint);
+  const uniqueWaypoints = finalWaypoints.filter((point5, index2, self2) => index2 === 0 || !point5.barelyEqual(self2[index2 - 1]));
+  const pathPoints = findPathPoints(uniqueWaypoints, grid, obstacles, startPoint, endPoint);
   return {
     lines: getLines(pathPoints),
-    newStart,
-    newEnd
+    newStart: startPoint,
+    newEnd: endPoint
   };
 }

package/package.json CHANGED Viewed

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