@operato/scene-storage 10.0.0-beta.41 → 10.0.0-beta.43

package/src/rack-grid-location.ts

@@ -1,286 +0,0 @@
-/*
- * 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)
-}

package/src/storage-cell-3d.ts

@@ -1,101 +0,0 @@
-/*
- * Copyright © HatioLab Inc. All rights reserved.
- *
- * RackCell 3D — invisible anchor group positioned at the cell's location
- * within the parent rack's 3D coordinate space.
- *
- * RackCell has no geometry of its own. Its sole 3D purpose is to provide
- * an Object3D that carriers can be attached to (via Three.js `.attach()`),
- * placed at the exact cell position within the rack. The position is derived
- * from the parent Rack's CellMap (by cellId), not from 2D state fields —
- * rack cells occupy 3D levels that have no 2D analogue.
- *
- * updateTransform() override: things-scene's standard updateTransform
- * reads `component.center` (2D) and flattens it to 3D. For rack cells this
- * is wrong — we need the 3D cell position (bay x, level y, row z) from the
- * parent rack. So we override and read it directly from the CellMap.
- */
-
-import * as THREE from 'three'
-import { RealObjectGroup } from '@hatiolab/things-scene'
-
-export class StorageCell3D extends RealObjectGroup {
-  build() {
-    super.build()
-    this._repositionFromCellMap()
-  }
-
-  updateDimension() {
-    // intentional no-op — size comes from the cell definition, not state
-  }
-
-  updateTransform() {
-    this._repositionFromCellMap()
-  }
-
-  updateAlpha() {
-    // invisible — no materials to update
-  }
-
-  /**
-   * Position this group at the cell's localPosition within the rack's 3D space.
-   *
-   * CellMap.grid() places cell origins at:
-   *   x = b * bayWidth,  y = l * levelHeight,  z = r * rowDepth
-   * (starting from 0,0,0 at the rack's bottom-left-front corner).
-   *
-   * The rack's object3d is centered: X spans [-width/2, +width/2],
-   * Y spans [-depth/2, +depth/2], Z spans [-height/2, +height/2].
-   *
-   * So the cell centre in rack-local 3D space:
-   *   x3d = cellPos.x + bayWidth/2   - width/2
-   *   y3d = cellPos.y + levelHeight/2 - rackDepth/2
-   *   z3d = cellPos.z + rowDepth/2   - rackHeight/2
-   */
-  _repositionFromCellMap() {
-    const rack = (this.component as any).parent
-    if (!rack?.cellMap) return
-
-    const cellId = this.component.state.cellId as string | undefined
-    if (!cellId) return
-
-    const cell = rack.cellMap.findById(cellId)
-    if (!cell) return
-
-    const rs = rack.state as any
-    const rackWidth = (rs?.width as number) || 1000
-    const rackDepth = (rs?.depth as number) || 3000   // Y dimension (floor→ceiling)
-    const rackHeight = (rs?.height as number) || 600  // Z dimension (front→back, 2D height)
-    const bays = Math.max(1, Math.floor(rs?.bays || 5))
-    const levels = Math.max(1, Math.floor(rs?.levels || 4))
-    const rows = 1
-
-    const bayWidth = rackWidth / bays
-    const levelHeight = rackDepth / levels
-    const rowDepth = rackHeight / rows
-
-    const x3d = cell.localPosition.x + bayWidth / 2 - rackWidth / 2
-    const y3d = cell.localPosition.y + levelHeight / 2 - rackDepth / 2
-    const z3d = cell.localPosition.z + rowDepth / 2 - rackHeight / 2
-
-    this.object3d.position.set(x3d, y3d, z3d)
-
-    // Optionally visualise cells in debug mode (outline box, very faint)
-    if (process.env.NODE_ENV !== 'production' && (rack.state as any)?.debugCells) {
-      this._addDebugBox(bayWidth, levelHeight, rowDepth)
-    }
-  }
-
-  private _debugBox?: THREE.LineSegments
-
-  private _addDebugBox(w: number, h: number, d: number) {
-    if (this._debugBox) return
-    const geo = new THREE.BoxGeometry(w * 0.98, h * 0.98, d * 0.98)
-    const edges = new THREE.EdgesGeometry(geo)
-    this._debugBox = new THREE.LineSegments(
-      edges,
-      new THREE.LineBasicMaterial({ color: 0x00ff88, transparent: true, opacity: 0.2 })
-    )
-    this.object3d.add(this._debugBox)
-  }
-}

package/src/storage-cell.ts

@@ -1,267 +0,0 @@
-/*
- * Copyright © HatioLab Inc. All rights reserved.
- *
- * RackCell — a single storage slot within an Rack.
- *
- * A RackCell is a virtual component: it occupies a specific (bay, row, level)
- * coordinate within the parent rack and acts as a CarrierHolder for one carrier
- * (or several, depending on `cellType`).
- *
- * The crane (or any picker) navigates toward a RackCell as its `place()` destination —
- * because the rack cell is a discrete component, Mover.moveTo() can target it
- * directly and arrive at exactly the right bay × level position.
- *
- * Visual: invisible in 2D (no visible 2D footprint — rack cells don't make
- * sense as 2D top-down boxes). In 3D, each cell is an invisible Group
- * positioned within the rack's coordinate space (RackCell3D handles
- * this via updateTransform override).
- *
- * Lifecycle: Rack._buildCells() instantiates RackCell children.
- * Do not create RackCell components manually — they are managed by the rack.
- *
- * Domain aliases:
- *   cell.store(carrier)            ← cell.receive(carrier)
- *   cell.retrieve(carrier, target) ← cell.dispatch(carrier, target)
- */
-
-import {
-  Component,
-  ComponentNature,
-  ContainerAbstract,
-  RealObject,
-  TRANSFER_SLOT_KEY,
-  sceneComponent
-} from '@hatiolab/things-scene'
-import type { State, Material3D } from '@hatiolab/things-scene'
-import { CarrierHolder, type AttachFrame } from '@operato/scene-base'
-
-import { StorageCell3D } from './storage-cell-3d.js'
-
-/**
- * How many carriers a cell can hold simultaneously.
- * - single: exactly 1 (typical pallet bay)
- * - multi:  small stack (up to 4, e.g. a multi-deep tray)
- * - bulk:   unlimited (e.g. a floor area measured in slots)
- */
-export type StorageCellType = 'single' | 'multi' | 'bulk'
-
-/** RackCell 컴포넌트 state */
-export interface StorageCellState extends State {
-  // ── 식별 ──
-  cellId?: string
-  cellType?: StorageCellType
-  /**
-   * 자동 할당된 location ID — RackTable.assignLocations() 가 set. 외부 시스템
-   * (WMS, picker 명령 등) 이 cell 을 지칭하는 사람-친화 ID. RackTable 없이
-   * 단독으로 Rack 을 사용할 땐 unset.
-   */
-  locationId?: string
-
-  // ── 3D 재질 ──
-  material3d?: Material3D
-}
-
-const NATURE: ComponentNature = {
-  mutable: false,
-  resizable: false,
-  rotatable: false,
-  properties: [
-    {
-      type: 'string',
-      label: 'cell-id',
-      name: 'cellId',
-      placeholder: 'e.g. 0-0-0'
-    },
-    {
-      type: 'select',
-      label: 'cell-type',
-      name: 'cellType',
-      property: {
-        options: [
-          { display: 'Single', value: 'single' },
-          { display: 'Multi', value: 'multi' },
-          { display: 'Bulk', value: 'bulk' }
-        ]
-      }
-    }
-  ],
-  help: 'scene/component/storage-cell'
-}
-
-/**
- * RackCell — single-slot storage cell inside an Rack.
- *
- * Mixin chain: CarrierHolder(ContainerAbstract)
- *   - CarrierHolder: publishes attachPointFor(), gates containable() to Carriables
- *   - ContainerAbstract: manages child carrier components
- *
- * No Placeable mixin — RackCell3D self-positions from the parent rack's
- * CellMap (via updateTransform override), bypassing things-scene's standard
- * 2D→3D coordinate mapping which cannot express 3D levels.
- */
-@sceneComponent('storage-cell')
-export default class RackCell extends CarrierHolder(ContainerAbstract) {
-  declare state: StorageCellState
-
-  // ── Identification ────────────────────────────────────────────────────────
-
-  get cellId(): string {
-    return this.state.cellId ?? ''
-  }
-
-  get cellType(): StorageCellType {
-    return this.state.cellType ?? 'single'
-  }
-
-  /** Maximum carrier count for this cell based on cellType. */
-  get capacity(): number {
-    switch (this.cellType) {
-      case 'single': return 1
-      case 'multi': return 4
-      case 'bulk': return Infinity
-    }
-  }
-
-  // ── Interface ─────────────────────────────────────────────────────────────
-
-  get nature(): ComponentNature {
-    return NATURE
-  }
-
-  get anchors(): [] {
-    return []
-  }
-
-  // ── Transfer protocol ─────────────────────────────────────────────────────
-
-  /** True when fewer carriers are currently held than capacity. */
-  canReceive(_component?: any): boolean {
-    const occupied = (this.components as Component[] | undefined)?.length ?? 0
-    return occupied < this.capacity
-  }
-
-  /**
-   * Accept a carrier into this cell.
-   * Sets TRANSFER_SLOT_KEY = cellId on the carrier, then reparents.
-   * Fires 'transfer-received' so monitors can react.
-   */
-  async receive(carrier: any, options: any = {}): Promise<void> {
-    if (!this.canReceive(carrier)) {
-      this.trigger('transfer-rejected', {
-        type: 'transfer-rejected',
-        component: carrier,
-        container: this,
-        reason: 'no-slot'
-      })
-      return
-    }
-    carrier[TRANSFER_SLOT_KEY] = this.cellId
-    this.reparent(carrier, options)
-
-    // carrier.state.left/top/zPos 을 *cell-local center* 로 명시. 이전 holder
-    // 의 state (예: crane-local center) 가 그대로 남으면 *다음 pick 시
-    // moveTo(carrier) 의 target.center 계산이 *잘못된 좌표* 로 → 엉뚱한 위치
-    // 이동 결함. transient placement 'carried' 라 3D obj3d.position 영향 X,
-    // 2D render 와 moveTo 의 center 계산에만 영향.
-    const cw = numOr((this as any).state?.width, 0)
-    const ch = numOr((this as any).state?.height, 0)
-    const carrierW = numOr(carrier?.state?.width, 0)
-    const carrierH = numOr(carrier?.state?.height, 0)
-    carrier.setState?.({
-      left: (cw - carrierW) / 2,
-      top: (ch - carrierH) / 2,
-      zPos: 0
-    })
-
-    this.trigger('transfer-received', {
-      type: 'transfer-received',
-      component: carrier,
-      container: this,
-      slotId: this.cellId
-    })
-  }
-
-  /**
-   * Release a carrier from this cell to `target`.
-   * Delegates to `target.receive()` if available, otherwise `target.reparent()`.
-   */
-  async dispatch(carrier: any, target: any, options: any = {}): Promise<void> {
-    if (target?.canReceive && !target.canReceive(carrier)) {
-      this.trigger('transfer-rejected', {
-        type: 'transfer-rejected',
-        component: carrier,
-        container: this,
-        reason: 'target-full'
-      })
-      return
-    }
-    delete carrier[TRANSFER_SLOT_KEY]
-    if (typeof target?.receive === 'function') {
-      await target.receive(carrier, options)
-    } else {
-      ;(target as any).reparent?.(carrier, options)
-    }
-    this.trigger('transfer-dispatched', {
-      type: 'transfer-dispatched',
-      component: carrier,
-      container: this,
-      target
-    })
-  }
-
-  // ── Domain aliases ────────────────────────────────────────────────────────
-
-  /** Alias for receive() — semantic sugar for the storage domain. */
-  store(carrier: any, options?: any): Promise<void> {
-    return this.receive(carrier, options)
-  }
-
-  /** Alias for dispatch() — semantic sugar for the storage domain. */
-  retrieve(carrier: any, target: any, options?: any): Promise<void> {
-    return this.dispatch(carrier, target, options)
-  }
-
-  // ── 3D attach frame ───────────────────────────────────────────────────────
-
-  /**
-   * Return the 3D attach frame for carriers placed in this cell.
-   *
-   * Center-origin convention: cell 의 *local origin* 은 cell 의 center
-   * (= levelHeight/2 above the shelf beam). carrier 의 *bottom face* 가 cell
-   * 의 *bottom* (= local Y -cellDepth/2) 에 닿도록 carrier center =
-   * -cellDepth/2 + carrierDepth/2.
-   */
-  attachPointFor(carrier: Component): AttachFrame | null {
-    const root = this._realObject?.object3d
-    if (!root) return null
-    const carrierDepth = resolveCarrierDepth(carrier)
-    const cellDepth = numOr((this as any).state?.depth, 0)
-    return {
-      attach: root,
-      localPosition: { x: 0, y: -cellDepth / 2 + carrierDepth / 2, z: 0 }
-    }
-  }
-
-  // ── 2D rendering ──────────────────────────────────────────────────────────
-
-  /** RackCell has no 2D visual — the rack draws its own structure. */
-  render(_ctx: CanvasRenderingContext2D) {
-    // intentional no-op
-  }
-
-  // ── 3D ───────────────────────────────────────────────────────────────────
-
-  buildRealObject(): RealObject | undefined {
-    return new StorageCell3D(this)
-  }
-}
-
-function resolveCarrierDepth(c: Component): number {
-  const eff = (c as any)._realObject?.effectiveDepth
-  if (typeof eff === 'number' && Number.isFinite(eff)) return eff
-  return numOr((c as any)?.state?.depth, 0)
-}
-
-function numOr(v: unknown, dflt: number): number {
-  return typeof v === 'number' && Number.isFinite(v) ? v : dflt
-}