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

package/test/test-toscene-convention.ts

@@ -0,0 +1,162 @@
+/*
+ * things-scene 의 toScene 컨벤션 *결정적* 검증.
+ *
+ * 미리 분석한 가설들:
+ *   (A) toScene(x, y) 의 입력 (x, y) 는 self 의 *parent 좌표계* (= 형제와 같은 좌표).
+ *   (B) toScene(x, y) 의 입력 (x, y) 는 *self-center-origin-local* (rotation 적용 전).
+ *
+ * 어느 쪽인지 *모의 컴포넌트* 로 직접 호출하여 결정.
+ *
+ * 모의 컴포넌트는 ComponentBase 의 *최소 표면* 만 구현 — parent / state / bounds /
+ * center / rotatePoint / _delta / isLayer / transcoordS2P. transcoordS2P 가 본
+ * 함수 호출 시 *transcoord 함수가 자체 동작* 하도록 things-scene 의 source 직접
+ * import (mjs 번들 아닌, src/ 안의 .ts).
+ */
+import 'should'
+import {
+  transcoordS2P,
+  transcoordS2T,
+  transcoordRR
+} from '../../../../things-scene/src/components/geometry/transcoord'
+
+// ── Mock Component 구조 — transcoord 함수의 ComponentBase 인터페이스 충족 ──────
+
+interface MockComp {
+  parent?: MockComp
+  state: { rotation?: number; scale?: { x: number; y: number }; translate?: { x: number; y: number }; left?: number; top?: number; width?: number; height?: number }
+  scalable: boolean
+  bounds: { left: number; top: number; width: number; height: number }
+  rotatePoint: { x: number; y: number }
+  model: any
+  rootModel: any
+  _delta: { theta: number; tx: number; ty: number; sx: number; sy: number }
+  isLayer(): boolean
+  transcoordS2P(x: number, y: number): { x: number; y: number }
+  transcoordP2S(x: number, y: number): { x: number; y: number }
+  transcoordS2T(x: number, y: number, top?: MockComp): { x: number; y: number }
+  transcoordT2S(x: number, y: number): { x: number; y: number }
+  transcoordT2P(x: number, y: number): { x: number; y: number }
+  get(prop: string): any
+}
+
+function makeMock(opts: {
+  left: number; top: number; width: number; height: number; rotation?: number; parent?: MockComp
+}): MockComp {
+  const state = {
+    left: opts.left, top: opts.top, width: opts.width, height: opts.height, rotation: opts.rotation ?? 0
+  }
+  const bounds = { left: opts.left, top: opts.top, width: opts.width, height: opts.height }
+  const center = { x: opts.left + opts.width / 2, y: opts.top + opts.height / 2 }
+  const comp: any = {
+    parent: opts.parent,
+    state,
+    scalable: false,
+    bounds,
+    rotatePoint: center,
+    model: null,
+    _delta: { theta: 0, tx: 0, ty: 0, sx: 1, sy: 1 },
+    isLayer: () => false,
+    get: (prop: string) => (state as any)[prop],
+  }
+  comp.rootModel = opts.parent?.rootModel ?? comp
+  comp.transcoordS2P = function (x: number, y: number) { return transcoordS2P.call(this, x, y) }
+  comp.transcoordS2T = function (x: number, y: number, top?: MockComp) { return transcoordS2T.call(this, x, y, top) }
+  // toScene = transcoordS2T
+  ;(comp as any).toScene = function (x: number, y: number, top?: MockComp) { return transcoordS2T.call(this, x, y, top) }
+  return comp
+}
+
+describe('things-scene toScene 컨벤션 검증', () => {
+
+  it('rotation=0 인 rack: rack.toScene(rack.center.x, rack.center.y) === rack.center', () => {
+    const root = makeMock({ left: 0, top: 0, width: 2000, height: 2000 })  // root (parent=undefined)
+    const rack = makeMock({ left: 365.17, top: 478.6, width: 800, height: 50, parent: root })
+    rack.rootModel = root
+
+    // rack.center (parent-좌표계) = (765.17, 503.6)
+    const cx = rack.bounds.left + rack.bounds.width / 2
+    const cy = rack.bounds.top + rack.bounds.height / 2
+
+    // 가설 (A): toScene 의 입력 = parent-좌표 → rack.toScene(cx, cy) = (cx, cy) (회전 없으면)
+    // 가설 (B): toScene 의 입력 = self-center-origin → rack.toScene(0, 0) = (cx, cy)
+    const resultA = (rack as any).toScene(cx, cy)
+    const resultB = (rack as any).toScene(0, 0)
+
+    console.log('[toScene 컨벤션] rotation=0 rack center')
+    console.log(`  rack.center = (${cx}, ${cy})`)
+    console.log(`  toScene(rack.center.x, rack.center.y) = (${resultA.x.toFixed(2)}, ${resultA.y.toFixed(2)})`)
+    console.log(`  toScene(0, 0)                          = (${resultB.x.toFixed(2)}, ${resultB.y.toFixed(2)})`)
+
+    // 결론: 어느 가설이 맞는지 결과로 판단
+    // (A) 면 resultA == (cx, cy) 이고 resultB == (0, 0)
+    // (B) 면 resultA == (?, ?) 이고 resultB == (cx, cy)
+  })
+
+  it('rotation=30° 인 rack: anchor.world 와 toScene 결과 비교', () => {
+    const root = makeMock({ left: 0, top: 0, width: 2000, height: 2000 })
+    const theta = Math.PI / 6  // 30°
+    const rack = makeMock({ left: 365.17, top: 478.6, width: 800, height: 50, rotation: theta, parent: root })
+    rack.rootModel = root
+
+    const cx = rack.bounds.left + rack.bounds.width / 2  // 765.17
+    const cy = rack.bounds.top + rack.bounds.height / 2  // 503.6
+
+    // bay 0 (cell 0-0-0) 의 *rack-local-center-origin* X = -380
+    // 즉 rack 의 center 에서 X=-380 만큼 떨어진 점. rotation 적용 후 *parent 좌표* 의 위치는?
+    // Manual: 점 (cx-380, cy) 를 rp=(cx, cy) 기준 30° 회전:
+    //   (cx-380-cx)*cos - (cy-cy)*sin + cx = -380*cos(30°) + 765.17 = -329.09 + 765.17 = 436.08
+    //   (cx-380-cx)*sin + (cy-cy)*cos + cy = -380*sin(30°) + 503.6 = -190 + 503.6 = 313.6
+
+    // 가설 (A): toScene 의 입력은 *parent-좌표*. 즉 *bay 0 의 parent-좌표 점* = (cx-380, cy) = (385.17, 503.6)
+    const resultA = (rack as any).toScene(cx + (-380), cy)
+    // 가설 (B): toScene 의 입력은 *self-center-origin*. 즉 *bay 0 의 local-center 점* = (-380, 0)
+    const resultB = (rack as any).toScene(-380, 0)
+    // 가설 (C): toScene 의 입력은 *rack 의 top-left-origin*. 즉 *bay 0 의 top-left 점* = (20, 25)
+    const resultC = (rack as any).toScene(20, 25)
+
+    console.log('[toScene 컨벤션] rotation=30° rack, bay 0 cell center')
+    console.log(`  rack.center                          = (${cx}, ${cy})`)
+    console.log(`  Manual 회전 후 (parent-좌표 의 bay 0) = (436.08, 313.60)`)
+    console.log(`  (A) toScene(parent-좌표)   = (${resultA.x.toFixed(2)}, ${resultA.y.toFixed(2)})`)
+    console.log(`  (B) toScene(center-origin) = (${resultB.x.toFixed(2)}, ${resultB.y.toFixed(2)})`)
+    console.log(`  (C) toScene(top-left-origin)= (${resultC.x.toFixed(2)}, ${resultC.y.toFixed(2)})`)
+  })
+
+  it('rotation=0 rack, bay 0 cell — anchor의 *3D world* 와 *2D scene 좌표* 매핑 검증', () => {
+    // 사용자 콘솔 로그 기준:
+    //   rackState: left=365.17, top=478.6, W=800, D=800, H=50, bays=20, levels=20, shelfBase=10
+    //   rackObj3d=(65.17, 400.00, -16.40)    ← 3D world position of rack.object3d
+    //   anchor world=(-264.60, 23.82, 172.41) — rack의 3D rotation ≈ 30° (Y axis) 적용된 후
+    //
+    // 가설:
+    //   sceneCenter.x ≈ 300  (rackObj3d.x = state.left - sceneCenter.x = 365.17 - 300 = 65.17)
+    //   sceneCenter.y ≈ 495  (rackObj3d.z = state.top - sceneCenter.y = 478.6 - 495 ≈ -16.4)
+    //
+    // anchor 의 *2D scene 좌표* = (anchor.world.x + sceneCenter.x, anchor.world.z + sceneCenter.y)
+    //   = (-264.60 + 300, 172.41 + 495) = (35.40, 667.41)
+    //
+    // 이게 cellCenter2D.toScene() 의 *목표값*.
+    // 만약 rack 의 *2D rotation* 이 0 이고 *3D Y축 회전* 만 있다면 2D toScene 은 회전 미적용.
+    // 그러면 cellCenter2D 가 *어떤 X, Y* 일 때 toScene 가 (35.40, 667.41) 를 반환?
+
+    const root = makeMock({ left: 0, top: 0, width: 2000, height: 2000 })
+    const rack = makeMock({ left: 365.17, top: 478.6, width: 800, height: 50, parent: root })
+    rack.rootModel = root
+
+    const target = { x: 35.40, y: 667.41 }
+    console.log('[toScene 역추적] target (= anchor 의 scene2D) =', target)
+
+    // 후보 X 값들 — bay 0 cell 의 다양한 origin 표현
+    const candidates: Array<[string, number, number]> = [
+      ['(A) parent-좌표 (rack.left + 20)', 365.17 + 20, 478.6 + 25],
+      ['(B) self-center-origin (-380, 0)', -380, 0],
+      ['(C) rack top-left-origin (20, 25)', 20, 25]
+    ]
+    for (const [label, x, y] of candidates) {
+      const out = (rack as any).toScene(x, y)
+      const dx = out.x - target.x
+      const dy = out.y - target.y
+      console.log(`  ${label}: toScene(${x}, ${y}) = (${out.x.toFixed(2)}, ${out.y.toFixed(2)})  Δ=(${dx.toFixed(2)}, ${dy.toFixed(2)})`)
+    }
+  })
+})

package/test/test-user-scenario-sequential.ts

@@ -0,0 +1,334 @@
+/*
+ * 사용자가 보고한 *정확한 시퀀스* 재현:
+ *
+ *   [A] 외부 parcel → rack '0-0-6' 으로 pickAndPlace (성공 보고)
+ *   [B] rack '0-0-6' 의 transient → rack '2-0-3' 으로 pickAndPlace (실패 보고)
+ *
+ * 가설: [A] 후 state.data 의 갱신이 정상이면 [B] 도 정상 진행. 실제 결함이면 이 테스트가
+ * fail 해서 정확한 *어느 step* 에서 깨지는지 드러남.
+ */
+
+import 'should'
+import * as THREE from 'three'
+
+// Same fixture as test-external-to-rack — Plan A 정신을 가능한 한 가깝게 재현
+class FakeRack {
+  state: any = { data: [] }
+  components: any[] = []
+  rootObject3d = new THREE.Group()
+  _slotAnchors = new Map<string, THREE.Object3D>()
+
+  records(): any[] { return this.state.data ?? [] }
+  carrierAt(cellId: string): any {
+    return this.components.find(c => c.placement === 'operation' && c.state?.cellId === cellId)
+  }
+  hasCarrierAt(cellId: string): boolean {
+    return !!this.carrierAt(cellId) || this.records().some(r => r?.cellId === cellId)
+  }
+  canReceiveAt(cellId: string, carrier?: any): boolean {
+    if (this.records().some(r => r?.cellId === cellId)) return false
+    const existing = this.carrierAt(cellId)
+    if (existing && existing !== carrier) return false
+    return true
+  }
+  addComponent(c: any): void { c.parent = this; this.components.push(c) }
+  removeComponent(c: any): void {
+    const i = this.components.indexOf(c)
+    if (i >= 0) this.components.splice(i, 1)
+    c.parent = null
+  }
+  ensureSlotAnchor(cellId: string): THREE.Object3D {
+    let a = this._slotAnchors.get(cellId)
+    if (!a) {
+      a = new THREE.Object3D()
+      a.name = `slot:${cellId}`
+      this.rootObject3d.add(a)
+      this._slotAnchors.set(cellId, a)
+    }
+    return a
+  }
+  attachPointFor(carrier: any) {
+    const cellId = carrier.state?.cellId
+    return { attach: this.ensureSlotAnchor(cellId ?? '?'), localPosition: { x: 0, y: 0, z: 0 } }
+  }
+
+  slotTargetAt(cellId: string): any {
+    const rack = this
+    return {
+      slotId: cellId,
+      holder: rack,
+      canReceive: (c: any) => rack.canReceiveAt(cellId, c),
+      async receive(c: any) { await rack.receiveAt(cellId, c) }
+    }
+  }
+
+  obtainCarrier(cellId: string): any {
+    const existing = this.carrierAt(cellId)
+    if (existing) return existing
+    const records = this.records()
+    const idx = records.findIndex(r => r?.cellId === cellId)
+    if (idx === -1) return null
+    const record = records[idx]
+    const { id: _id, refid: _refid, ...rest } = record
+    const c: any = {
+      placement: 'operation',
+      state: { ...rest, cellId, type: rest.type ?? 'parcel' },
+      parent: null,
+      _disposed: false,
+      _realObject: { object3d: new THREE.Group() },
+      dispose() {
+        this._disposed = true
+        if (this._realObject?.object3d?.parent?.remove) {
+          this._realObject.object3d.parent.remove(this._realObject.object3d)
+        }
+        this._realObject.object3d.clear()
+      }
+    }
+    this.addComponent(c)
+    const pt = this.attachPointFor(c)
+    pt.attach.attach(c._realObject.object3d)
+    c._realObject.object3d.position.set(0, 0, 0)
+    this.state.data = records.filter(r => r?.cellId !== cellId)
+    return c
+  }
+
+  async receiveAt(cellId: string, carrier: any): Promise<void> {
+    if (carrier?._disposed) throw new Error('R18: carrier disposed')
+    if (!this.canReceiveAt(cellId, carrier)) {
+      const err: any = new Error('slot occupied')
+      err.reason = 'slot-occupied'
+      throw err
+    }
+    const p = carrier.parent
+    if (p?.removeComponent) p.removeComponent(carrier)
+    const obj = carrier._realObject?.object3d
+    if (obj?.parent?.remove) obj.parent.remove(obj)
+    carrier.dispose?.()
+    const remaining = this.records().filter(r => r?.cellId !== cellId)
+    const rec: any = { cellId, type: carrier.state.type ?? 'parcel' }
+    for (const k of Object.keys(carrier.state)) {
+      if (['id', 'refid', 'left', 'top', 'zPos', 'cellId', '_transferSlotId'].includes(k)) continue
+      rec[k] = carrier.state[k]
+    }
+    this.state.data = [...remaining, rec]
+  }
+}
+
+class FakeCrane {
+  components: any[] = []
+  forkObject3d = new THREE.Object3D()
+  constructor() { this.forkObject3d.name = 'crane-fork' }
+
+  canReceive(_c: any): boolean {
+    return this.components.filter(c => c._transferSlotId === 'forks').length < 1
+  }
+  async receive(carrier: any): Promise<void> {
+    if (!this.canReceive(carrier)) {
+      const err: any = new Error('crane full')
+      err.reason = 'all-slots-full'
+      throw err
+    }
+    const op = carrier.parent
+    if (op?.removeComponent) op.removeComponent(carrier)
+    carrier.parent = this
+    this.components.push(carrier)
+    carrier._transferSlotId = 'forks'
+    const obj = carrier._realObject?.object3d
+    if (obj) {
+      if (obj.parent?.remove) obj.parent.remove(obj)
+      this.forkObject3d.attach(obj)
+      obj.position.set(0, 0, 0)
+    }
+  }
+  removeComponent(c: any): void {
+    const i = this.components.indexOf(c)
+    if (i >= 0) this.components.splice(i, 1)
+    c.parent = null
+  }
+  async dispatch(carrier: any, target: any): Promise<void> {
+    if (target.canReceive && !target.canReceive(carrier)) {
+      const err: any = new Error('target rejected')
+      err.reason = 'cannot-receive'
+      throw err
+    }
+    delete carrier._transferSlotId
+    if (typeof target.receive === 'function') await target.receive(carrier)
+  }
+
+  async pickAndPlace(carrier: any, target: any, options: { timeoutMs?: number } = {}): Promise<void> {
+    // R18 guard
+    if (!carrier) throw new Error('Mover.pick: carrier is null/undefined')
+    if (carrier._disposed) throw new Error('Mover.pickAndPlace: carrier is already disposed')
+
+    const sourceParent: any = carrier.parent
+    const sourceCellId: string | undefined = carrier.state?.cellId
+
+    try {
+      // pick
+      if (carrier.parent !== this) await this.receive(carrier)
+
+      // place
+      const holder = target
+      const timeoutMs = options.timeoutMs ?? 1000
+      const started = Date.now()
+      // R19: post-engage absorb check 시뮬 — receive 후 _disposed true 면 return
+      // (실 Mover.place 와 동일: engage('place') 의 mid-Transfer 가 receive → absorb)
+      if (typeof holder?.receive === 'function') {
+        await holder.receive(carrier)
+        if (carrier.parent === holder) return    // 보통 holder
+        if (carrier._disposed) return            // R19 absorb 경로
+      }
+
+      // polling fallback (도달하지 않아야 함)
+      while (holder?.canReceive && !holder.canReceive(carrier)) {
+        if (Date.now() - started > timeoutMs) throw new Error('Mover.place timeout')
+        await new Promise(r => setTimeout(r, 5))
+      }
+      if (holder?.receive && carrier.parent !== holder && !carrier._disposed) {
+        await this.dispatch(carrier, holder)
+      }
+    } catch (err) {
+      // Rollback
+      if (this.components.includes(carrier)) {
+        const slotTarget = sourceParent?.slotTargetAt?.(sourceCellId)
+        if (slotTarget?.canReceive?.(carrier)) {
+          try { await this.dispatch(carrier, slotTarget) } catch {}
+        } else {
+          this.removeComponent(carrier)
+        }
+      }
+      throw err
+    }
+  }
+}
+
+// ── 사용자 시나리오 정확 재현 ────────────────────────────────────────────────
+
+describe('User scenario — sequential pickAndPlace (external → rack → another slot)', () => {
+  it('[A] 외부 parcel → rack.slotTargetAt(0-0-6) — *성공*', async () => {
+    const rack = new FakeRack()
+    const crane = new FakeCrane()
+    const parcel: any = {
+      placement: 'operation',
+      state: { id: 'parcel', type: 'parcel', sku: 'X' },
+      parent: null,
+      _disposed: false,
+      _realObject: { object3d: new THREE.Group() },
+      dispose() { this._disposed = true; this._realObject.object3d.clear() }
+    }
+    // 외부 (model-layer 시뮬 — 사실 parent 가 있긴 함)
+    const modelLayer: any = {
+      components: [] as any[],
+      addComponent(c: any) { c.parent = this; this.components.push(c) },
+      removeComponent(c: any) { const i = this.components.indexOf(c); if (i >= 0) this.components.splice(i, 1); c.parent = null },
+      canReceive(_c: any) { return true },
+      async receive(c: any) { const p = c.parent; if (p?.removeComponent) p.removeComponent(c); this.addComponent(c) }
+    }
+    modelLayer.addComponent(parcel)
+
+    await crane.pickAndPlace(parcel, rack.slotTargetAt('0-0-6'))
+
+    // 검증: parcel disposed, state.data 갱신, crane 비어있음
+    parcel._disposed.should.be.true()
+    rack.records().length.should.equal(1)
+    rack.records()[0].cellId.should.equal('0-0-6')
+    rack.records()[0].sku.should.equal('X')
+    crane.components.length.should.equal(0)
+  })
+
+  it('[A] 직후 [B] obtainCarrier(0-0-6) — *transient 반환*', async () => {
+    const rack = new FakeRack()
+    const crane = new FakeCrane()
+    const parcel: any = {
+      placement: 'operation',
+      state: { id: 'parcel', type: 'parcel', sku: 'X' },
+      parent: null,
+      _disposed: false,
+      _realObject: { object3d: new THREE.Group() },
+      dispose() { this._disposed = true; this._realObject.object3d.clear() }
+    }
+    const modelLayer: any = {
+      components: [] as any[],
+      addComponent(c: any) { c.parent = this; this.components.push(c) },
+      removeComponent(c: any) { const i = this.components.indexOf(c); if (i >= 0) this.components.splice(i, 1); c.parent = null },
+      canReceive(_c: any) { return true },
+      async receive(c: any) { const p = c.parent; if (p?.removeComponent) p.removeComponent(c); this.addComponent(c) }
+    }
+    modelLayer.addComponent(parcel)
+
+    // [A]
+    await crane.pickAndPlace(parcel, rack.slotTargetAt('0-0-6'))
+
+    // [B] obtainCarrier
+    const carrier = rack.obtainCarrier('0-0-6')
+    // *결정 검증*: carrier 가 null 이 아니어야 함 — 사용자 보고와 일치하는지 확인
+    ;(carrier === null).should.be.false()
+    carrier.state.cellId.should.equal('0-0-6')
+    carrier.state.sku.should.equal('X')
+    carrier._disposed.should.be.false()
+    ;(carrier !== parcel).should.be.true()   // 새 transient, 원본 parcel 아님
+
+    // state.data 에서 '0-0-6' record 제거됨 (obtain 의 부수효과)
+    rack.records().some((r: any) => r.cellId === '0-0-6').should.be.false()
+  })
+
+  it('[A] → [B] 전체 흐름 — 0-0-6 에서 2-0-3 으로 이동', async () => {
+    const rack = new FakeRack()
+    const crane = new FakeCrane()
+    const parcel: any = {
+      placement: 'operation',
+      state: { id: 'parcel', type: 'parcel', sku: 'X' },
+      parent: null,
+      _disposed: false,
+      _realObject: { object3d: new THREE.Group() },
+      dispose() { this._disposed = true; this._realObject.object3d.clear() }
+    }
+    const modelLayer: any = {
+      components: [] as any[],
+      addComponent(c: any) { c.parent = this; this.components.push(c) },
+      removeComponent(c: any) { const i = this.components.indexOf(c); if (i >= 0) this.components.splice(i, 1); c.parent = null },
+      canReceive(_c: any) { return true },
+      async receive(c: any) { const p = c.parent; if (p?.removeComponent) p.removeComponent(c); this.addComponent(c) }
+    }
+    modelLayer.addComponent(parcel)
+
+    // [A] 외부 → 0-0-6
+    await crane.pickAndPlace(parcel, rack.slotTargetAt('0-0-6'))
+
+    // [B] 0-0-6 → 2-0-3 (사용자가 본 두 번째 script 와 동일)
+    const carrier = rack.obtainCarrier('0-0-6')
+    if (!carrier) throw new Error('[B] obtainCarrier returned null — sequence broken!')
+    const dest = rack.slotTargetAt('2-0-3')
+    await crane.pickAndPlace(carrier, dest)
+
+    // 검증: 2-0-3 에 record 있고, 0-0-6 비어있고, crane 깨끗
+    rack.records().length.should.equal(1)
+    rack.records()[0].cellId.should.equal('2-0-3')
+    rack.records()[0].sku.should.equal('X')
+    rack.hasCarrierAt('0-0-6').should.be.false()
+    crane.components.length.should.equal(0)
+  })
+
+  it('rapid 클릭 시나리오 — [B] 가 두 번 빠르게 호출되면?', async () => {
+    const rack = new FakeRack()
+    rack.state.data = [{ cellId: '0-0-6', sku: 'X' }]
+    const crane = new FakeCrane()
+
+    // 동시 클릭 시뮬
+    const c1 = rack.obtainCarrier('0-0-6')
+    const c2 = rack.obtainCarrier('0-0-6')   // 같은 인스턴스 idempotent 반환
+
+    c1!.should.equal(c2)   // 같은 carrier
+    rack.records().length.should.equal(0)   // record 한 번만 빠짐
+    rack.components.length.should.equal(1)  // carrier 도 하나만
+
+    // 두 클릭 모두 pickAndPlace 호출 시
+    const r1 = crane.pickAndPlace(c1, rack.slotTargetAt('A'))
+    const r2 = crane.pickAndPlace(c2, rack.slotTargetAt('B'))
+    const results = await Promise.allSettled([r1, r2])
+
+    // 한 쪽은 성공, 다른 쪽은 disposed 이라 fail (R18 guard) 또는 crane full 이라 fail
+    const failures = results.filter(r => r.status === 'rejected')
+    failures.length.should.be.greaterThanOrEqual(1)
+  })
+})

package/translations/en.json

@@ -34,6 +34,8 @@
   "label.is-empty": "is empty",
   "label.hide-empty-stock": "hide empty stock",
   "label.hide-rack-frame": "hide rack frame",
+  "label.hide-horizontal-frame": "hide horizontal frame",
+  "label.popup-ref": "popup ref",
   "label.stock-scale": "stock scale",
   "label.legend-target": "legend target",
   "label.shelf-base-height": "shelf base height",

package/translations/ja.json

@@ -34,6 +34,8 @@
   "label.is-empty": "空セル",
   "label.hide-empty-stock": "空在庫を非表示",
   "label.hide-rack-frame": "ラックフレームを非表示",
+  "label.hide-horizontal-frame": "横フレームを非表示",
+  "label.popup-ref": "ポップアップ参照",
   "label.stock-scale": "在庫スケール",
   "label.legend-target": "凡例対象",
   "label.shelf-base-height": "棚の基準高さ",

package/translations/ko.json

@@ -34,6 +34,8 @@
   "label.is-empty": "빈 셀",
   "label.hide-empty-stock": "빈 재고 숨김",
   "label.hide-rack-frame": "랙 프레임 숨김",
+  "label.hide-horizontal-frame": "가로 프레임 숨김",
+  "label.popup-ref": "팝업 참조",
   "label.stock-scale": "재고 크기",
   "label.legend-target": "범례 대상",
   "label.shelf-base-height": "선반 시작 높이",

package/translations/ms.json

@@ -34,6 +34,8 @@
   "label.is-empty": "sel kosong",
   "label.hide-empty-stock": "sembunyi stok kosong",
   "label.hide-rack-frame": "sembunyi rangka rak",
+  "label.hide-horizontal-frame": "sembunyi rangka mendatar",
+  "label.popup-ref": "rujukan popup",
   "label.stock-scale": "skala stok",
   "label.legend-target": "sasaran legenda",
   "label.shelf-base-height": "tinggi asas rak",

package/translations/zh.json

@@ -34,6 +34,8 @@
   "label.is-empty": "空单元",
   "label.hide-empty-stock": "隐藏空库存",
   "label.hide-rack-frame": "隐藏货架框架",
+  "label.hide-horizontal-frame": "隐藏横向框架",
+  "label.popup-ref": "弹窗引用",
   "label.stock-scale": "库存比例",
   "label.legend-target": "图例对象",
   "label.shelf-base-height": "货架基准高度",