@operato/scene-visualizer 8.0.0-beta.0 → 8.0.0-beta.2

package/src/polygon.ts

@@ -1,88 +0,0 @@
-/*
- * Copyright © HatioLab Inc. All rights reserved.
- */
-
-import { POINT, Polygon } from '@hatiolab/things-scene'
-import * as THREE from 'three'
-import { RealObjectExtrude } from './threed/real-object-extrude'
-
-export class PolygonExtrude extends RealObjectExtrude {
-  _minMax?: {
-    minX?: number
-    minY?: number
-    maxX?: number
-    maxY?: number
-  }
-
-  get shape() {
-    var { path = [], round = 0 } = this.component.state
-
-    var shape = new THREE.Shape()
-
-    for (var i = 0; i < path.length; i++) {
-      const prev = path[(i - 1 + path.length) % path.length]
-      const cursor = path[(i + path.length) % path.length]
-      const next = path[(i + 1) % path.length]
-
-      if (prev.x === cursor.x && prev.y === cursor.y) {
-        continue
-      }
-
-      var length = Math.sqrt((prev.x - cursor.x) * (prev.x - cursor.x) + (prev.y - cursor.y) * (prev.y - cursor.y))
-      var theta = length !== 0 ? Math.atan2(prev.x - cursor.x, prev.y - cursor.y) : 0
-      var x = Math.sin(theta) * Math.min(round, length / 2) + cursor.x
-      var y = Math.cos(theta) * Math.min(round, length / 2) + cursor.y
-
-      const p1 = round > 0 || length !== 0 ? { x, y } : cursor
-
-      var length = Math.sqrt((next.x - cursor.x) * (next.x - cursor.x) + (next.y - cursor.y) * (next.y - cursor.y))
-      theta = length !== 0 ? Math.atan2(next.x - cursor.x, next.y - cursor.y) : 0
-      x = Math.sin(theta) * Math.min(round, length / 2) + cursor.x
-      y = Math.cos(theta) * Math.min(round, length / 2) + cursor.y
-
-      const p2 = round > 0 || length !== 0 ? { x, y } : cursor
-
-      i == 0 ? shape.moveTo(p1.x, p1.y) : shape.lineTo(p1.x, p1.y)
-      round > 0 && shape.quadraticCurveTo(cursor.x, cursor.y, p2.x, p2.y)
-    }
-
-    return shape
-  }
-
-  get minMax() {
-    if (!this._minMax) {
-      var { path } = this.component.state
-
-      var minX: number | undefined
-      var minY: number | undefined
-      var maxX: number | undefined
-      var maxY: number | undefined
-
-      path.forEach((p: POINT, i: number) => {
-        if (i == 0) {
-          minX = maxX = p.x
-          minY = maxY = p.y
-          return
-        }
-
-        minX = Math.min(minX!, p.x)
-        maxX = Math.max(maxX!, p.x)
-        minY = Math.min(minY!, p.y)
-        maxY = Math.max(maxY!, p.y)
-      })
-
-      this._minMax = {
-        minX,
-        minY,
-        maxX,
-        maxY
-      }
-    }
-
-    return this._minMax
-  }
-}
-
-Polygon.prototype.buildRealObject = function () {
-  return new PolygonExtrude(this)
-}

package/src/rack-table-cell.ts

@@ -1,386 +0,0 @@
-/*
- * Copyright © HatioLab Inc. All rights reserved.
- */
-import { Component, Properties, RectPath } from '@hatiolab/things-scene'
-import { Rack } from './rack'
-import { RealObject } from './threed/real-object'
-
-const EMPTY_BORDER = {}
-
-function isBottomMost(idx: number, rows: number, columns: number) {
-  return idx >= (rows - 1) * columns
-}
-
-function isRightMost(idx: number, rows: number, columns: number) {
-  return (idx + 1) % columns == 0
-}
-
-function hasAnyProperty(o: any, ...properties: string[]) {
-  for (let p in properties) {
-    if (o.hasOwnProperty(properties[p])) {
-      return true
-    }
-  }
-}
-
-const EMPTY_CELL_STROKE_STYLE = '#ccc'
-const EMPTY_CELL_LINE_WIDTH = 1
-const EMPTY_CELL_FILL_STYLE = '#efefef'
-
-/**
- * 1. 스타일을 상속 받아야 함. (cascade-style)
- * 2. 스타일을 동적처리할 수 있음. (로직처리)
- * 3. 데이타를 받을 수 있음.
- */
-export class RackTableCell extends RectPath(Component) {
-  _focused: boolean = false
-
-  get hasTextProperty() {
-    return false
-  }
-
-  get nature() {
-    return {
-      mutable: false,
-      resizable: true,
-      rotatable: true,
-      properties: [
-        {
-          type: 'string',
-          label: 'section',
-          name: 'section'
-        },
-        {
-          type: 'string',
-          label: 'unit',
-          name: 'unit'
-        },
-        {
-          type: 'string',
-          label: 'shelf-locations',
-          name: 'shelfLocations',
-          placeholder: '1,2,3,... / ,,,04'
-        },
-        {
-          type: 'textarea',
-          label: 'bin-locations',
-          name: 'binLocations',
-          placeholder: '1,2,3,...'
-        },
-        {
-          type: 'checkbox',
-          label: 'is-empty',
-          name: 'isEmpty'
-        },
-        {
-          type: 'location-increase-pattern',
-          label: '',
-          name: '',
-          property: {
-            event: {
-              'increase-location-pattern': (event: CustomEvent) => {
-                var { increasingDirection, skipNumbering, startSection, startUnit } = event.detail
-                const rackTable = this.parent as any
-                rackTable.increaseLocation(increasingDirection, skipNumbering, startSection, startUnit)
-              }
-            }
-          }
-        },
-        {
-          type: 'editor-table',
-          label: '',
-          name: '',
-          property: {
-            merge: false,
-            split: false
-          }
-        }
-      ]
-    }
-  }
-
-  buildRealObject(): RealObject | undefined {
-    return new Rack(this)
-  }
-
-  set merged(merged) {
-    this.set('merged', !!merged)
-    if (merged) this.set('text', '')
-  }
-
-  get merged() {
-    return this.getState('merged')
-  }
-
-  set rowspan(rowspan) {
-    this.set('rowspan', rowspan)
-  }
-
-  get rowspan() {
-    return this.getState('rowspan')
-  }
-
-  set colspan(colspan) {
-    this.set('colspan', colspan)
-  }
-
-  get colspan() {
-    return this.getState('colspan')
-  }
-
-  get border() {
-    return this.state.border || EMPTY_BORDER
-  }
-
-  get isEmpty() {
-    return this.getState('isEmpty')
-  }
-
-  _drawBorder(context: CanvasRenderingContext2D, x: number, y: number, to_x: number, to_y: number, style: any) {
-    if (style && style.strokeStyle && style.lineWidth && style.lineDash) {
-      context.beginPath()
-      context.moveTo(x, y)
-      context.lineTo(to_x, to_y)
-
-      Component.drawStroke(context, style)
-    }
-  }
-
-  render(context: CanvasRenderingContext2D) {
-    var { left, top, width, height } = this.bounds
-    var { isEmpty } = this.state
-
-    var border = this.border
-
-    if (!isEmpty) {
-      this._draw_rack_cell(context)
-    }
-
-    // Cell 채우기.
-    context.beginPath()
-    context.lineWidth = 0
-    context.rect(left, top, width, height)
-
-    // Border 그리기
-    var parent = this.parent as any
-    var idx = parent.components.indexOf(this)
-    var columns = parent.columns || 1
-    var rows = parent.rows || 1
-
-    this._drawBorder(context, left, top, left + width, top, border.top)
-    this._drawBorder(context, left, top + height, left, top, border.left)
-    if (isRightMost(idx, rows, columns))
-      this._drawBorder(context, left + width, top, left + width, top + height, border.right)
-    if (isBottomMost(idx, rows, columns))
-      this._drawBorder(context, left + width, top + height, left, top + height, border.bottom)
-  }
-
-  _draw_rack_cell(context: CanvasRenderingContext2D) {
-    var { left, top, width, height } = this.bounds
-
-    context.save()
-    context.fillStyle = EMPTY_CELL_FILL_STYLE
-    context.fillRect(left, top, width, height)
-
-    context.beginPath()
-    context.lineWidth = EMPTY_CELL_LINE_WIDTH
-    context.strokeStyle = EMPTY_CELL_STROKE_STYLE
-
-    context.moveTo(left, top)
-    context.lineTo(left + width, top + height)
-    context.moveTo(left + width, top)
-    context.lineTo(left, top + height)
-
-    context.stroke()
-    context.closePath()
-    context.restore()
-  }
-
-  get decotag() {
-    var rackTable = this.parent
-    var { locPattern, zone = '' } = rackTable.model
-
-    locPattern = locPattern.substring(0, locPattern.indexOf('{u}') + 3)
-
-    var locationString = ''
-    if (this.getState('section') && this.getState('unit'))
-      locationString = locPattern
-        .replace('{z}', zone)
-        .replace('{s}', this.getState('section'))
-        .replace('{u}', this.getState('unit'))
-
-    return locationString || ''
-  }
-
-  get index() {
-    let rackTable = this.parent as any
-    var index = rackTable.components.indexOf(this)
-
-    var rowIndex = Math.floor(index / rackTable.columns)
-    var columnIndex = index % rackTable.columns
-
-    return {
-      row: rowIndex,
-      column: columnIndex
-    }
-  }
-
-  get rowIndex() {
-    return this.index.row
-  }
-
-  get columnIndex() {
-    return this.index.column
-  }
-
-  get leftCell() {
-    let rackTable = this.parent as any
-    var index = rackTable.components.indexOf(this)
-
-    var rowIndex = this.rowIndex
-    var columnIndex = this.columnIndex
-
-    if (columnIndex === 0) return null
-
-    var leftCell = rackTable.components[rowIndex * rackTable.columns + columnIndex - 1]
-
-    return leftCell
-  }
-
-  get rightCell() {
-    let rackTable = this.parent as any
-    var index = rackTable.components.indexOf(this)
-
-    var rowIndex = this.rowIndex
-    var columnIndex = this.columnIndex
-
-    if (columnIndex === rackTable.columns) return null
-
-    var rightCell = rackTable.components[rowIndex * rackTable.columns + columnIndex + 1]
-
-    return rightCell
-  }
-
-  get aboveCell() {
-    let rackTable = this.parent as any
-    var index = rackTable.components.indexOf(this)
-
-    var rowIndex = this.rowIndex
-    var columnIndex = this.columnIndex
-
-    if (rowIndex === 0) return null
-
-    var aboveCell = rackTable.components[(rowIndex - 1) * rackTable.columns + columnIndex]
-
-    return aboveCell
-  }
-
-  get belowCell() {
-    var rackTable = this.parent as any
-    var index = rackTable.components.indexOf(this)
-
-    var rowIndex = this.rowIndex
-    var columnIndex = this.columnIndex
-
-    if (rowIndex === rackTable.rows) return null
-
-    var belowCell = rackTable.components[(rowIndex + 1) * rackTable.columns + columnIndex]
-
-    return belowCell
-  }
-
-  get rowCells() {
-    var rackTable = this.parent as any
-    return rackTable.getCellsByRow(this.rowIndex)
-  }
-
-  get columnCells() {
-    var rackTable = this.parent as any
-    return rackTable.getCellsByColumn(this.columnIndex)
-  }
-
-  get aboveRowCells() {
-    var aboveCell = this.aboveCell
-    while (1) {
-      var aboveRowCells = aboveCell.notEmptyRowCells
-
-      if (aboveRowCells.length > 0) return aboveRowCells
-
-      aboveCell = aboveCell.aboveCell
-    }
-  }
-
-  get lastUnit() {
-    var rowCells = this.aboveRowCells
-
-    for (let i = rowCells.length - 1; i > 0; i--) {
-      var cell = rowCells[i]
-
-      var unit = cell.getState('unit')
-
-      if (unit) return Number(unit)
-    }
-
-    return 0
-  }
-
-  get firstUnit() {
-    var rowCells = this.aboveRowCells
-
-    for (let i = 0; i < rowCells.length; i++) {
-      var cell = rowCells[i]
-
-      var unit = cell.getState('unit')
-
-      if (unit) return Number(unit)
-    }
-
-    return 0
-  }
-
-  get notEmptyRowCells() {
-    return this.rowCells.filter((c: Component) => {
-      return !c.getState('isEmpty')
-    })
-  }
-
-  get emptyRowCells() {
-    return this.rowCells.filter((c: Component) => {
-      return c.getState('isEmpty')
-    })
-  }
-
-  get isAisle() {
-    return this.notEmptyRowCells.length === 0
-  }
-
-  onchange(after: Properties, before: Properties) {
-    if (hasAnyProperty(after, 'isEmpty')) {
-      // FIXME
-      delete this.model.unit
-      delete this.model.section
-    }
-  }
-
-  onmouseenter() {
-    this.trigger('deco')
-  }
-
-  onmouseleave() {
-    this.trigger('decoreset')
-  }
-
-  contains(x: number, y: number) {
-    var contains = super.contains(x, y)
-    if (!contains) {
-      this._focused = false
-      this.invalidate()
-    }
-
-    return contains
-  }
-}
-
-;['border'].forEach(getter => Component.memoize(RackTableCell.prototype, getter, false))
-
-Component.register('rack-table-cell', RackTableCell)