@operato/scene-storage 10.0.0-beta.28 → 10.0.0-beta.31

package/test/setup.js

@@ -0,0 +1,279 @@
+/*
+ * Browser polyfills for Node.js test environment.
+ * Required when importing @hatiolab/things-scene bundle which uses browser globals at module scope.
+ */
+
+var noop = function () {}
+
+// Image polyfill (used at module scope in move-handle.ts)
+if (typeof global.Image === 'undefined') {
+  global.Image = class Image {
+    constructor() {
+      this.onload = null
+      this.onerror = null
+      this.src = ''
+      this.width = 0
+      this.height = 0
+    }
+    set src(v) { this._src = v }
+    get src() { return this._src || '' }
+    addEventListener(evt, fn) {}
+    removeEventListener() {}
+  }
+}
+
+// HTMLCanvasElement polyfill
+if (typeof global.HTMLCanvasElement === 'undefined') {
+  global.HTMLCanvasElement = class HTMLCanvasElement {
+    constructor() { this.width = 0; this.height = 0 }
+    getContext() { return null }
+    toDataURL() { return '' }
+    addEventListener() {}
+    removeEventListener() {}
+  }
+}
+
+// HTMLElement / HTMLVideoElement stubs
+if (typeof global.HTMLElement === 'undefined') {
+  global.HTMLElement = class HTMLElement {}
+}
+if (typeof global.HTMLVideoElement === 'undefined') {
+  global.HTMLVideoElement = class HTMLVideoElement {}
+}
+
+// MutationObserver polyfill
+if (typeof global.MutationObserver === 'undefined') {
+  global.MutationObserver = class MutationObserver {
+    constructor(callback) {}
+    observe() {}
+    disconnect() {}
+    takeRecords() { return [] }
+  }
+}
+
+// ResizeObserver polyfill
+if (typeof global.ResizeObserver === 'undefined') {
+  global.ResizeObserver = class ResizeObserver {
+    constructor(callback) {}
+    observe() {}
+    unobserve() {}
+    disconnect() {}
+  }
+}
+
+// Mini-DOM Node implementation
+function createNode(nodeType, tagName) {
+  var node = {
+    nodeType: nodeType,
+    tagName: tagName || '',
+    parentNode: null,
+    parentElement: null,
+    childNodes: [],
+    firstChild: null,
+    lastChild: null,
+    nextSibling: null,
+    previousSibling: null,
+    style: nodeType === 1 ? new Proxy({}, {
+      set: function(t,p,v){ t[p]=v; return true },
+      get: function(t,p){ if(p==='setProperty') return function(k,v){ t[k]=v }; return t[p] || '' }
+    }) : {},
+    textContent: '',
+    data: '',
+    setAttribute: noop,
+    getAttribute: function () { return null },
+    removeAttribute: noop,
+    addEventListener: noop,
+    removeEventListener: noop,
+    getContext: function() { return null },
+    contains: function () { return false },
+    querySelector: function() { return null },
+    querySelectorAll: function() { return [] },
+
+    appendChild: function (child) {
+      if (child.nodeType === 11) {
+        while (child.childNodes.length > 0) node.appendChild(child.childNodes[0])
+        return child
+      }
+      if (child.parentNode) child.parentNode.removeChild(child)
+      node.childNodes.push(child)
+      child.parentNode = node
+      child.parentElement = nodeType === 1 ? node : null
+      if (node.childNodes.length > 1) {
+        var prev = node.childNodes[node.childNodes.length - 2]
+        prev.nextSibling = child
+        child.previousSibling = prev
+      }
+      child.nextSibling = null
+      node.firstChild = node.childNodes[0]
+      node.lastChild = child
+      return child
+    },
+
+    removeChild: function (child) {
+      var idx = node.childNodes.indexOf(child)
+      if (idx === -1) return child
+      node.childNodes.splice(idx, 1)
+      if (child.previousSibling) child.previousSibling.nextSibling = child.nextSibling
+      if (child.nextSibling) child.nextSibling.previousSibling = child.previousSibling
+      child.parentNode = null; child.parentElement = null
+      child.previousSibling = null; child.nextSibling = null
+      node.firstChild = node.childNodes[0] || null
+      node.lastChild = node.childNodes[node.childNodes.length - 1] || null
+      return child
+    },
+
+    remove: function () { if (node.parentNode) node.parentNode.removeChild(node) },
+
+    insertBefore: function (newChild, refChild) {
+      if (!refChild) return node.appendChild(newChild)
+      if (newChild.nodeType === 11) {
+        var children = newChild.childNodes.slice()
+        for (var i = 0; i < children.length; i++) node.insertBefore(children[i], refChild)
+        return newChild
+      }
+      if (newChild.parentNode) newChild.parentNode.removeChild(newChild)
+      var idx = node.childNodes.indexOf(refChild)
+      if (idx === -1) return node.appendChild(newChild)
+      node.childNodes.splice(idx, 0, newChild)
+      newChild.parentNode = node
+      newChild.parentElement = nodeType === 1 ? node : null
+      newChild.nextSibling = refChild
+      newChild.previousSibling = refChild.previousSibling
+      if (refChild.previousSibling) refChild.previousSibling.nextSibling = newChild
+      refChild.previousSibling = newChild
+      node.firstChild = node.childNodes[0]
+      node.lastChild = node.childNodes[node.childNodes.length - 1]
+      return newChild
+    },
+
+    cloneNode: function (deep) {
+      var clone = createNode(nodeType, tagName)
+      clone.data = node.data; clone.textContent = node.textContent
+      if (deep && node.childNodes.length) {
+        for (var i = 0; i < node.childNodes.length; i++) clone.appendChild(node.childNodes[i].cloneNode(true))
+      }
+      return clone
+    },
+
+    replaceChild: function (newChild, oldChild) {
+      node.insertBefore(newChild, oldChild); node.removeChild(oldChild); return oldChild
+    }
+  }
+
+  if (nodeType === 1) {
+    node.children = []
+    if (tagName === 'template') {
+      node.content = createNode(11, '')
+      Object.defineProperty(node, 'innerHTML', {
+        get: function () { return '' },
+        set: function (html) { node.content = createNode(11, '') }
+      })
+    } else {
+      node.innerHTML = ''
+    }
+  }
+  return node
+}
+
+// document polyfill
+if (typeof global.document === 'undefined') {
+  global.document = {
+    documentElement: {},
+    fonts: { ready: Promise.resolve() },
+    createElement: function (tagName) { return createNode(1, tagName) },
+    createComment: function (data) { var n = createNode(8, ''); n.data = data || ''; return n },
+    createTextNode: function (data) { var n = createNode(3, ''); n.data = data || ''; return n },
+    createDocumentFragment: function () { return createNode(11, '') },
+    createTreeWalker: function (root, whatToShow) {
+      var walker = {
+        currentNode: root,
+        nextNode: function () {
+          var cur = walker.currentNode
+          if (!cur) return null
+          if (cur.childNodes && cur.childNodes.length > 0) { walker.currentNode = cur.childNodes[0]; return walker.currentNode }
+          var node = cur
+          while (node && node !== root) {
+            if (node.nextSibling) { walker.currentNode = node.nextSibling; return walker.currentNode }
+            node = node.parentNode
+          }
+          return null
+        }
+      }
+      return walker
+    },
+    importNode: function (node, deep) { return node && node.cloneNode ? node.cloneNode(deep) : node },
+    adoptNode: function (node) { return node },
+    querySelector: function() { return null },
+    querySelectorAll: function() { return [] },
+    body: createNode(1, 'body'),
+    head: createNode(1, 'head')
+  }
+}
+
+// getComputedStyle polyfill
+if (typeof global.getComputedStyle !== 'function') {
+  global.getComputedStyle = function () {
+    return { getPropertyValue: function () { return '' }, fontFamily: 'sans-serif' }
+  }
+}
+
+// window polyfill
+if (typeof global.window === 'undefined') {
+  global.window = global
+}
+
+global.addEventListener = global.addEventListener || noop
+global.removeEventListener = global.removeEventListener || noop
+
+if (!global.window.location) {
+  global.window.location = { hostname: 'localhost', href: 'http://localhost/' }
+}
+
+// screen polyfill
+if (typeof global.screen === 'undefined') {
+  global.screen = { width: 1280, height: 800 }
+}
+
+// requestAnimationFrame polyfill
+if (typeof global.requestAnimationFrame === 'undefined') {
+  var lastTime = 0
+  global.requestAnimationFrame = function (callback) {
+    var currTime = Date.now()
+    var timeToCall = Math.max(0, 16 - (currTime - lastTime))
+    var id = setTimeout(function () { callback(currTime + timeToCall) }, timeToCall)
+    lastTime = currTime + timeToCall
+    return id
+  }
+  global.cancelAnimationFrame = function (id) { clearTimeout(id) }
+}
+
+// performance polyfill
+if (typeof global.performance === 'undefined') {
+  global.performance = {}
+}
+if (!global.performance.now) {
+  var nowOffset = Date.now()
+  global.performance.now = function () { return Date.now() - nowOffset }
+}
+
+// WebGL stub (Three.js renderer check)
+if (typeof global.WebGLRenderingContext === 'undefined') {
+  global.WebGLRenderingContext = class WebGLRenderingContext {}
+}
+
+// CSS polyfill
+if (typeof global.CSS === 'undefined') {
+  global.CSS = { supports: function() { return false } }
+}
+
+// CustomEvent polyfill
+if (typeof global.CustomEvent === 'undefined') {
+  global.CustomEvent = class CustomEvent {
+    constructor(type, init) { this.type = type; this.detail = (init || {}).detail }
+  }
+}
+
+// URL polyfill (Node.js has this but in some versions it may be missing from global)
+if (typeof global.URL === 'undefined') {
+  global.URL = require('url').URL
+}

package/test/test-asrs-crane.ts

@@ -0,0 +1,319 @@
+/*
+ * Copyright © HatioLab Inc. All rights reserved.
+ *
+ * AsrsCrane integration tests — pick/place data-flow for the ASRS crane.
+ *
+ * Uses fake/minimal containers (no DOM, no Three.js, no RAF) so they run in
+ * Node with tsx.
+ *
+ * Test infrastructure mirrors test-transfer-scenarios.ts in scene-base:
+ *   - FakeBase: minimal child-tracking container with setState support
+ *   - FakeCrane: Mover(ContainerCapacity(FakeBase)) — instant moveTo, AsrsCrane
+ *     engage() semantics (status + carriageHeight), slots = [{id:'forks', maxCount:1}]
+ *   - FakeRackCell: mimics RackCell.receive / dispatch / canReceive protocol
+ */
+
+import 'should'
+import { ContainerCapacity, TRANSFER_SLOT_KEY } from '@hatiolab/things-scene'
+import Mover from '../../scene-base/src/mover.js'
+
+// ── Shared fake infrastructure ─────────────────────────────────────────────────
+
+class FakeBase {
+  _components: any[] = []
+  state: Record<string, any>
+  parent: any = null
+  root: any = null
+
+  constructor(state: Record<string, any> = {}) {
+    this.state = state
+  }
+
+  get components() {
+    return this._components
+  }
+
+  setState(keyOrObj: string | Record<string, any>, value?: any) {
+    if (typeof keyOrObj === 'object') {
+      Object.assign(this.state, keyOrObj)
+    } else {
+      this.state[keyOrObj as string] = value
+    }
+  }
+
+  getState(key: string) {
+    return this.state[key]
+  }
+
+  addComponent(child: any) {
+    if (child.parent && child.parent !== this) {
+      const idx = child.parent._components?.indexOf(child) ?? -1
+      if (idx >= 0) child.parent._components.splice(idx, 1)
+      child.parent = null
+    }
+    if (!this._components.includes(child)) {
+      this._components.push(child)
+    }
+    child.parent = this
+  }
+
+  removeComponent(child: any) {
+    const idx = this._components.indexOf(child)
+    if (idx >= 0) this._components.splice(idx, 1)
+    if (child.parent === this) child.parent = null
+  }
+
+  reparent(child: any, _options?: any) {
+    this.addComponent(child)
+  }
+
+  trigger(_name: string, ..._args: any[]) {}
+}
+
+function makeCarrier(zPos?: number) {
+  return {
+    parent: null as any,
+    state: { type: 'pallet', ...(zPos !== undefined ? { zPos } : {}) },
+    type: 'pallet',
+    [TRANSFER_SLOT_KEY]: undefined as any,
+    setState(_s: any) {}
+  }
+}
+
+// FakeCrane: Mover(ContainerCapacity(FakeBase)) with instant moveTo +
+// AsrsCrane engage() semantics (status + carriageHeight snap from carrier.state.zPos).
+const FakeCraneBase = Mover(ContainerCapacity(FakeBase as any))
+
+class FakeCrane extends (FakeCraneBase as any) {
+  constructor(state: Record<string, any> = {}) {
+    super({ status: 'idle', carriageHeight: 0, ...state })
+  }
+
+  get slots() {
+    return [{ id: 'forks', maxCount: 1 }]
+  }
+
+  moveTo(_target: any, _options: any = {}): Promise<void> {
+    return Promise.resolve()
+  }
+
+  async engage(target: any, kind: 'pick' | 'place'): Promise<void> {
+    if (kind === 'pick') {
+      this.state.status = 'loading'
+      const carrierY = target?.state?.zPos ?? null
+      if (carrierY !== null) this.state.carriageHeight = carrierY
+    } else {
+      this.state.status = 'unloading'
+    }
+  }
+
+  /** Semantic alias for pick (matches AsrsCrane.fetch). */
+  fetch(carrier: any, options?: any): Promise<void> {
+    return (this as any).pick(carrier, options)
+  }
+
+  /** Semantic alias for place (matches AsrsCrane.deposit). */
+  deposit(carrier: any, cell: any, options?: any): Promise<void> {
+    return (this as any).place(carrier, cell, options)
+  }
+}
+
+// FakeRackCell: mimics RackCell.receive / dispatch / canReceive protocol.
+// capacity=1 (single-slot cell).
+class FakeRackCell extends FakeBase {
+  cellId: string
+
+  constructor(state: Record<string, any> = {}) {
+    super(state)
+    this.cellId = (state.cellId as string) || 'cell-0-0-0'
+  }
+
+  canReceive(_component?: any): boolean {
+    return this._components.length < 1
+  }
+
+  async receive(carrier: any, options: any = {}): Promise<void> {
+    if (!this.canReceive(carrier)) return
+    carrier[TRANSFER_SLOT_KEY] = this.cellId
+    this.reparent(carrier, options)
+  }
+
+  async dispatch(carrier: any, target: any, options: any = {}): Promise<void> {
+    this.removeComponent(carrier)
+    if (typeof target?.receive === 'function') {
+      await target.receive(carrier, options)
+    } else {
+      target?.reparent?.(carrier, options)
+    }
+  }
+}
+
+// ── Scenario 1: fetch (pick) ──────────────────────────────────────────────────
+
+describe('AsrsCrane: fetch (pick)', () => {
+  it('fetch 후 carrier가 crane의 child', async () => {
+    const crane = new FakeCrane()
+    const carrier = makeCarrier()
+
+    await crane.fetch(carrier)
+
+    crane._components.should.containEql(carrier)
+  })
+
+  it('fetch 후 TRANSFER_SLOT_KEY = forks', async () => {
+    const crane = new FakeCrane()
+    const carrier = makeCarrier()
+
+    await crane.fetch(carrier)
+
+    carrier[TRANSFER_SLOT_KEY].should.equal('forks')
+  })
+
+  it('fetch engage → status loading', async () => {
+    const crane = new FakeCrane()
+    const carrier = makeCarrier()
+
+    await crane.fetch(carrier)
+
+    crane.state.status.should.equal('loading')
+  })
+
+  it('carrier에 zPos 있으면 carriageHeight 스냅', async () => {
+    const crane = new FakeCrane()
+    const carrier = makeCarrier(1500)
+
+    await crane.fetch(carrier)
+
+    crane.state.carriageHeight.should.equal(1500)
+  })
+
+  it('zPos 없으면 carriageHeight 변경 없음', async () => {
+    const crane = new FakeCrane({ carriageHeight: 500 })
+    const carrier = makeCarrier() // no zPos
+
+    await crane.fetch(carrier)
+
+    crane.state.carriageHeight.should.equal(500)
+  })
+
+  it('fetch 전에 carrier가 rack cell에 있었으면 거기서 제거', async () => {
+    const crane = new FakeCrane()
+    const cell = new FakeRackCell({ cellId: 'cell-0-0-0' })
+    const carrier = makeCarrier()
+    await cell.receive(carrier)
+
+    await crane.fetch(carrier)
+
+    crane._components.should.containEql(carrier)
+    cell._components.should.not.containEql(carrier)
+  })
+
+  it('maxCount(1) 가득 차면 canReceive false', async () => {
+    const crane = new FakeCrane()
+    const c1 = makeCarrier()
+    const c2 = makeCarrier()
+
+    await crane.fetch(c1)
+    ;(crane as any).canReceive(c2).should.be.false()
+  })
+})
+
+// ── Scenario 2: deposit (place) ───────────────────────────────────────────────
+
+describe('AsrsCrane: deposit (place)', () => {
+  it('deposit 후 carrier가 rackCell의 child', async () => {
+    const crane = new FakeCrane()
+    const cell = new FakeRackCell({ cellId: 'cell-1-0-2' })
+    const carrier = makeCarrier()
+
+    crane.addComponent(carrier)
+    carrier[TRANSFER_SLOT_KEY] = 'forks'
+
+    await crane.deposit(carrier, cell)
+
+    cell._components.should.containEql(carrier)
+    crane._components.should.not.containEql(carrier)
+  })
+
+  it('deposit engage → status unloading', async () => {
+    const crane = new FakeCrane()
+    const cell = new FakeRackCell()
+    const carrier = makeCarrier()
+
+    crane.addComponent(carrier)
+    carrier[TRANSFER_SLOT_KEY] = 'forks'
+
+    await crane.deposit(carrier, cell)
+
+    crane.state.status.should.equal('unloading')
+  })
+
+  it('deposit 후 TRANSFER_SLOT_KEY = cellId', async () => {
+    const crane = new FakeCrane()
+    const cell = new FakeRackCell({ cellId: 'cell-3-0-1' })
+    const carrier = makeCarrier()
+
+    crane.addComponent(carrier)
+    carrier[TRANSFER_SLOT_KEY] = 'forks'
+
+    await crane.deposit(carrier, cell)
+
+    carrier[TRANSFER_SLOT_KEY].should.equal('cell-3-0-1')
+  })
+})
+
+// ── Scenario 3: fetch → deposit 전체 사이클 ──────────────────────────────────
+
+describe('AsrsCrane: fetch → deposit 전체 사이클', () => {
+  it('cell-A → crane → cell-B', async () => {
+    const crane = new FakeCrane()
+    const cellA = new FakeRackCell({ cellId: 'cell-0-0-0' })
+    const cellB = new FakeRackCell({ cellId: 'cell-5-0-3' })
+    const carrier = makeCarrier()
+
+    // Pre-place carrier in cellA
+    await cellA.receive(carrier)
+    cellA._components.should.containEql(carrier)
+    carrier[TRANSFER_SLOT_KEY].should.equal('cell-0-0-0')
+
+    // Fetch from cellA
+    await crane.fetch(carrier)
+    crane._components.should.containEql(carrier)
+    cellA._components.should.not.containEql(carrier)
+    carrier[TRANSFER_SLOT_KEY].should.equal('forks')
+
+    // Deposit into cellB
+    await crane.deposit(carrier, cellB)
+    cellB._components.should.containEql(carrier)
+    crane._components.should.not.containEql(carrier)
+    carrier[TRANSFER_SLOT_KEY].should.equal('cell-5-0-3')
+  })
+
+  it('fetch → deposit 후 status 순서: loading → unloading', async () => {
+    const crane = new FakeCrane()
+    const cell = new FakeRackCell({ cellId: 'cell-0-0-0' })
+    const carrier = makeCarrier()
+
+    await crane.fetch(carrier)
+    crane.state.status.should.equal('loading')
+
+    await crane.deposit(carrier, cell)
+    crane.state.status.should.equal('unloading')
+  })
+
+  it('pickAndPlace: carrier를 cellA에서 cellB로 한 번에', async () => {
+    const crane = new FakeCrane()
+    const cellA = new FakeRackCell({ cellId: 'cell-2-0-1' })
+    const cellB = new FakeRackCell({ cellId: 'cell-7-0-3' })
+    const carrier = makeCarrier()
+
+    await cellA.receive(carrier)
+
+    await (crane as any).pickAndPlace(carrier, cellB)
+
+    cellB._components.should.containEql(carrier)
+    cellA._components.should.not.containEql(carrier)
+    crane._components.should.not.containEql(carrier)
+    carrier[TRANSFER_SLOT_KEY].should.equal('cell-7-0-3')
+  })
+})

package/tsconfig.json

@@ -19,5 +19,6 @@
     "incremental": true,
     "skipLibCheck": true
   },
-  "include": ["**/*.ts", "*.d.ts"]
+  "include": ["src/**/*.ts"],
+  "exclude": ["dist/**", "test/**", "node_modules"]
 }