@eturnity/eturnity_maths 8.46.2 → 9.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eturnity/eturnity_maths",
-  "version": "8.46.2",
+  "version": "9.7.0",
   "author": "Eturnity Team",
   "main": "src/index.js",
   "private": false,

package/src/geometry.js

@@ -29,8 +29,19 @@ export function getPolylineLength(outline) {
     )
   }, 0)
 }
-export function getConcaveOutlines(selectedPanels, onePanelOutline) {
-  let buckets = groupAdjacentObjects(selectedPanels)
+/**
+ * Gets the concave outlines of the selected panels.
+ * @param {Array} selectedPanels - Array of selected panels
+ * @param {Array} onePanelOutline - Outline of one panel
+ * @param {Function} customAdjacentFn - Optional callback (objA, objB) => boolean for additional adjacency checks (e.g., cross-grid)
+ * @returns {Object} Object with outlines and buckets
+ */
+export function getConcaveOutlines(
+  selectedPanels,
+  onePanelOutline,
+  customAdjacentFn = null
+) {
+  let buckets = groupAdjacentObjects(selectedPanels, customAdjacentFn)
   const outlines = []
   for (let bucketIndex = 0; bucketIndex < buckets.length; bucketIndex++) {
     outlines.push(
@@ -898,7 +909,13 @@ export function isClockWise(outline) {
   }
   return sum > 0
 }
-export function groupAdjacentObjects(objects) {
+/**
+ * Groups objects into buckets of adjacent objects based on row_index and col_index.
+ * @param {Array} objects - Array of objects with row_index, col_index, and optionally moduleField.id and gridIndex
+ * @param {Function} customAdjacentFn - Optional callback (objA, objB) => boolean for additional adjacency checks (e.g., cross-grid)
+ * @returns {Array} Array of buckets, where each bucket is an array of indices into the original objects array
+ */
+export function groupAdjacentObjects(objects, customAdjacentFn = null) {
   if (!objects || objects.length == 0) return []
   // objects with 2D indexes
   // Check if the objects form an adjacent group
@@ -906,6 +923,23 @@ export function groupAdjacentObjects(objects) {
   let indexList = Array.from({ length: numberOfObjects }, (e, i) => i)
   let buckets = []
   let inBucket = 0
+
+  // Pre-compute custom adjacency pairs if callback provided
+  const customAdjacentPairs = new Map()
+  if (customAdjacentFn) {
+    for (let i = 0; i < numberOfObjects; i++) {
+      customAdjacentPairs.set(i, [])
+    }
+    for (let i = 0; i < numberOfObjects; i++) {
+      for (let j = i + 1; j < numberOfObjects; j++) {
+        if (customAdjacentFn(objects[i], objects[j])) {
+          customAdjacentPairs.get(i).push(j)
+          customAdjacentPairs.get(j).push(i)
+        }
+      }
+    }
+  }
+
   while (inBucket < objects.length) {
     let detatchedIndex = indexList.find((i) => !buckets.flat().includes(i))
     if (detatchedIndex == null) break
@@ -916,24 +950,40 @@ export function groupAdjacentObjects(objects) {
       if (visited.indexOf(currentObjectIndex) == -1) {
         //if next queued index hasn't been visited, we mark it as visited and we collect all neighbourg to queue
         visited.push(currentObjectIndex)
-        let x = objects[currentObjectIndex].row_index
-        let y = objects[currentObjectIndex].col_index
+        const currentObject = objects[currentObjectIndex]
+        let x = currentObject.row_index
+        let y = currentObject.col_index
+        const moduleFieldId = currentObject.moduleField?.id
+        const gridIndex = currentObject.gridIndex
+        const isSameGrid = (o) =>
+          o.moduleField?.id == moduleFieldId && o.gridIndex == gridIndex
+
+        // Same-grid neighbors (index-based)
         const left = objects.findIndex(
-          (o) => o.row_index == x - 1 && o.col_index == y
+          (o) => o.row_index == x - 1 && o.col_index == y && isSameGrid(o)
         )
         const right = objects.findIndex(
-          (o) => o.row_index == x + 1 && o.col_index == y
+          (o) => o.row_index == x + 1 && o.col_index == y && isSameGrid(o)
         )
         const top = objects.findIndex(
-          (o) => o.row_index == x && o.col_index == y - 1
+          (o) => o.row_index == x && o.col_index == y - 1 && isSameGrid(o)
         )
         const bottom = objects.findIndex(
-          (o) => o.row_index == x && o.col_index == y + 1
+          (o) => o.row_index == x && o.col_index == y + 1 && isSameGrid(o)
         )
         if (left != -1 && visited.indexOf(left) == -1) queue.push(left)
         if (right != -1 && visited.indexOf(right) == -1) queue.push(right)
         if (top != -1 && visited.indexOf(top) == -1) queue.push(top)
         if (bottom != -1 && visited.indexOf(bottom) == -1) queue.push(bottom)
+
+        // Custom adjacency (e.g., cross-grid)
+        if (customAdjacentFn) {
+          for (const neighborIndex of customAdjacentPairs.get(
+            currentObjectIndex
+          )) {
+            if (visited.indexOf(neighborIndex) == -1) queue.push(neighborIndex)
+          }
+        }
       }
     }
     inBucket += visited.length