@operato/scene-storage 10.0.0-beta.33 → 10.0.0-beta.34

package/src/rack-grid-location.ts

@@ -0,0 +1,286 @@
+/*
+ * Copyright © HatioLab Inc. All rights reserved.
+ *
+ * RackGrid location management utilities.
+ * Extracted from rack-table.ts for separation of concerns.
+ */
+
+import type { RackGridCell } from './rack-grid-cell.js'
+
+/**
+ * Classify cells by their row index.
+ */
+export function classifyByRow(cells: RackGridCell[]): RackGridCell[][] {
+  const classified: RackGridCell[][] = []
+
+  cells.forEach(c => {
+    const { row, column } = c.index
+
+    if (!classified[row]) {
+      classified[row] = []
+    }
+
+    classified[row][column] = c
+  })
+
+  return classified
+}
+
+/**
+ * Find aisle rows (rows where all cells are empty).
+ */
+export function findAisle(rows?: RackGridCell[][]): RackGridCell[][] {
+  if (!rows) {
+    return []
+  }
+
+  return rows.filter(r => {
+    return r[0] && r[0].isAisle
+  })
+}
+
+/**
+ * Get indices of aisle rows.
+ */
+export function getAisleRowIndices(rows: RackGridCell[][]): number[] {
+  const aisles = findAisle(rows)
+  const aisleRowIndices: number[] = []
+
+  aisles.forEach(aisle => {
+    aisleRowIndices.push(rows.indexOf(aisle))
+  })
+
+  return aisleRowIndices
+}
+
+/**
+ * Classify rows into sections separated by aisle rows.
+ */
+export function classifyCellsBySection(
+  rows: RackGridCell[][],
+  aisleRowIndices: number[]
+): RackGridCell[][][] {
+  const sections: RackGridCell[][][] = []
+  let wasAisle = false
+  let section!: RackGridCell[][]
+
+  rows.forEach((row, i) => {
+    const isAisle = aisleRowIndices.indexOf(i) > -1
+
+    if (!(wasAisle || isAisle)) {
+      section = []
+      sections.push(section)
+    }
+
+    wasAisle = isAisle
+
+    section.push(row)
+  })
+
+  return sections
+}
+
+/**
+ * Rearrange cells by aisle direction pattern.
+ */
+export function rearrangeByAisle(type: string, sections: RackGridCell[][][]): RackGridCell[][][] {
+  const rearranged: RackGridCell[][][] = []
+
+  switch (type.toLowerCase()) {
+    case 'cw': {
+      let reverse = false
+      sections.forEach(rows => {
+        const section: RackGridCell[][] = []
+        rearranged.push(section)
+        rows.forEach((r, i) => {
+          if (reverse) r.reverse()
+
+          if (i % 2 === 0) {
+            section.push(r)
+            reverse = !reverse
+          }
+        })
+      })
+      break
+    }
+    case 'ccw': {
+      let reverse = true
+      sections.forEach(rows => {
+        const section: RackGridCell[][] = []
+        rearranged.push(section)
+        rows.forEach((r, i) => {
+          if (reverse) r.reverse()
+
+          if (i % 2 === 0) {
+            section.push(r)
+            reverse = !reverse
+          }
+        })
+      })
+      break
+    }
+    case 'zigzag':
+      sections.forEach(rows => {
+        const section: RackGridCell[][] = []
+
+        rows.forEach((r, i) => {
+          if (i % 2 === 0) {
+            section.push(r)
+          }
+        })
+
+        const sectionLength = section.length
+        const tempRow: RackGridCell[] = []
+        const tempSection: RackGridCell[][] = []
+
+        section.forEach((row, rowIdx) => {
+          row.forEach((cell, idx) => {
+            tempRow[rowIdx + idx * section.length] = cell
+          })
+        })
+
+        const chunkSize = tempRow.length / sectionLength
+        for (let idx = 0; idx < sectionLength; idx++) {
+          tempSection.push(tempRow.slice(idx * chunkSize, (idx + 1) * chunkSize))
+        }
+
+        rearranged.push(tempSection)
+      })
+      break
+    case 'zigzag-reverse':
+      sections.forEach(rows => {
+        const section: RackGridCell[][] = []
+
+        rows.forEach((r, i) => {
+          if (i % 2 === 0) {
+            r.reverse()
+            section.push(r)
+          }
+        })
+
+        const sectionLength = section.length
+        const tempRow: RackGridCell[] = []
+        const tempSection: RackGridCell[][] = []
+
+        section.forEach((row, rowIdx) => {
+          row.forEach((cell, idx) => {
+            tempRow[rowIdx + idx * section.length] = cell
+          })
+        })
+
+        const chunkSize = tempRow.length / sectionLength
+        for (let idx = 0; idx < sectionLength; idx++) {
+          tempSection.push(tempRow.slice(idx * chunkSize, (idx + 1) * chunkSize))
+        }
+
+        rearranged.push(tempSection)
+      })
+      break
+  }
+
+  return rearranged
+}
+
+/**
+ * Remove empty cells from sections.
+ */
+export function removeEmptyCells(sections: RackGridCell[][][]): RackGridCell[][][] {
+  const newSections: RackGridCell[][][] = []
+  sections.forEach(rows => {
+    const newRows: RackGridCell[][] = []
+    newSections.push(newRows)
+    rows.forEach(row => {
+      const newRow: RackGridCell[] = []
+      newRows.push(newRow)
+      row.forEach(c => {
+        if (!c.isEmpty) newRow.push(c)
+      })
+    })
+  })
+
+  return newSections
+}
+
+/**
+ * Merge section rows into flat arrays.
+ */
+export function mergeRows(sections: RackGridCell[][][]): RackGridCell[][] {
+  const merged: RackGridCell[][] = []
+
+  sections.forEach(section => {
+    let newSection: RackGridCell[] = []
+
+    section.forEach(rows => {
+      let mergedRow: RackGridCell[] = []
+      rows.forEach(row => {
+        mergedRow = mergedRow.concat(row)
+      })
+      newSection = newSection.concat(mergedRow)
+    })
+    merged.push(newSection)
+  })
+
+  return merged
+}
+
+/**
+ * Set section/unit location on cells.
+ */
+export function setLocations(
+  sections: RackGridCell[][],
+  startSection: number,
+  startUnit: number,
+  sectionDigits: number,
+  unitDigits: number
+) {
+  let sectionNumber = Number(startSection) || 1
+
+  sections.forEach(section => {
+    let unitNumber = Number(startUnit) || 1
+    section.forEach(c => {
+      if (!c.isEmpty) {
+        c.set('section', String(sectionNumber).padStart(sectionDigits, '0'))
+        c.set('unit', String(unitNumber).padStart(unitDigits, '0'))
+      } else {
+        c.set('section', null)
+        c.set('unit', null)
+      }
+      unitNumber++
+    })
+    sectionNumber++
+  })
+}
+
+/**
+ * Run the full location increase flow.
+ */
+export function increaseLocation(
+  selectedCells: RackGridCell[],
+  type: string,
+  skipNumbering: boolean,
+  startSection: number,
+  startUnit: number,
+  sectionDigits: number,
+  unitDigits: number
+) {
+  // step 1: classify cells by row
+  const classified = classifyByRow(selectedCells)
+
+  // step 2: find aisle row indices
+  const aisleRowIndices = getAisleRowIndices(classified)
+
+  // step 3: classify cells by section
+  const sections = classifyCellsBySection(classified, aisleRowIndices)
+
+  // step 4: rearrange by aisle
+  let rearranged = rearrangeByAisle(type, sections)
+
+  // step 5: if skip numbering, remove empty cells
+  if (skipNumbering) rearranged = removeEmptyCells(rearranged)
+
+  // step 6: merge rows
+  const merged = mergeRows(rearranged)
+
+  // step 7: set location
+  setLocations(merged, startSection, startUnit, sectionDigits, unitDigits)
+}