@operato/image-marker 8.0.0-alpha.29 → 8.0.0-alpha.37

package/src/base-image-marker.ts

@@ -1,7 +1,15 @@
-import { LitElement, css, html, svg, nothing } from 'lit'
+import { LitElement, css, html, svg, nothing, PropertyValues } from 'lit'
 import { property, state, query } from 'lit/decorators.js'
+import { debounce } from 'lodash-es'
 
-import { Shape } from './types'
+import {
+  GestureEventDoubleTap,
+  GestureEventDrag,
+  GestureEventPinch,
+  GestureHelper
+} from '@operato/utils/gesture-helper.js'
+import { ImageProvider, Shape } from './types'
+import { DefaultImageProvider } from './default-image-provider'
 
 export class BaseImageMarker extends LitElement {
   static styles = [
@@ -22,6 +30,7 @@ export class BaseImageMarker extends LitElement {
         cursor: pointer;
         width: 100%;
         height: 100%;
+        touch-action: none;
       }
     `
   ]
@@ -29,217 +38,152 @@ export class BaseImageMarker extends LitElement {
   @property({ type: String }) imageUrl: string = ''
   @property({ type: Array }) shapes: Shape[] = []
 
+  @state() protected currentImage?: string
   @state() protected viewBox = '0 0 800 600'
   @state() protected zoomLevel = 1
+  @state() private imageProvider?: ImageProvider = new DefaultImageProvider()
 
+  protected debouncedUpdateImage = debounce(this.updateImage.bind(this), 300)
   protected zoomFactor = 0.1
   protected zoomThreshold = 0.05
-  protected isPanning = false
-  protected panStart = { x: 0, y: 0 }
-  protected panInitiated = false
-  protected panThreshold = 20
 
-  protected initialViewBox = '0 0 800 600'
-  private initialPinchDistance: number | null = null
-  private initialZoomLevel: number = 1
-  private lastTouchEnd: number = 0
+  protected initialViewBox: string | null = null
 
   @query('svg') protected svg!: SVGSVGElement
 
-  protected onImageLoad(event: Event) {
-    const img = new Image()
-    img.onload = () => {
-      const width = img.naturalWidth
-      const height = img.naturalHeight
-      this.viewBox = `0 0 ${width} ${height}`
-      this.initialViewBox = `0 0 ${width} ${height}`
-    }
-    img.src = this.imageUrl
-  }
-
-  protected onSvgWheel(event: WheelEvent) {
-    event.preventDefault()
-
-    const { offsetX, offsetY, deltaY } = event
-    const scale = deltaY > 0 ? 1 - this.zoomFactor : 1 + this.zoomFactor
-    if (Math.abs(scale - 1) > this.zoomThreshold) {
-      this.zoomLevel *= scale
-
-      const [vbX, vbY, vbWidth, vbHeight] = this.viewBox.split(' ').map(Number)
-      const mouseX = vbX + (offsetX / this.svg.clientWidth) * vbWidth
-      const mouseY = vbY + (offsetY / this.svg.clientHeight) * vbHeight
-
-      const newVbWidth = vbWidth / scale
-      const newVbHeight = vbHeight / scale
-
-      const newVbX = mouseX - (offsetX / this.svg.clientWidth) * newVbWidth
-      const newVbY = mouseY - (offsetY / this.svg.clientHeight) * newVbHeight
+  private gestureHelper: GestureHelper | null = null
 
-      this.viewBox = `${newVbX} ${newVbY} ${newVbWidth} ${newVbHeight}`
-    }
+  connectedCallback(): void {
+    super.connectedCallback()
+    requestAnimationFrame(() => {
+      this.gestureHelper = new GestureHelper(this.svg)
+    })
   }
 
-  protected onSvgMouseDown(event: MouseEvent) {
-    event.preventDefault()
-
-    this.startPanning(event)
+  disconnectedCallback(): void {
+    super.disconnectedCallback()
 
-    this.svg.addEventListener('mousemove', this.onPanMouseMove)
-    this.svg.addEventListener('mouseup', this.onPanMouseUp)
+    this.gestureHelper?.dispose()
+    this.gestureHelper = null
   }
 
-  protected isDoubleTouch(event: TouchEvent) {
-    const currentTime = new Date().getTime()
-    const tapLength = currentTime - this.lastTouchEnd
-
-    const result = tapLength < 300 && event.touches.length == 1
-    this.lastTouchEnd = currentTime
-
-    return result
-  }
-
-  protected onSvgTouchStart = (event: TouchEvent) => {
-    event.preventDefault()
-
-    if (this.isDoubleTouch(event)) {
-      this.resetZoom()
-    }
-
-    if (event.touches.length === 1) {
-      this.startPanning(event)
-    } else if (event.touches.length === 2) {
-      this.startPinchZooming(event)
+  protected updated(changes: PropertyValues): void {
+    if (changes.has('imageUrl') || changes.has('imageProvider')) {
+      this.initialViewBox = null
+      this.updateImage()
     }
   }
 
-  protected startPinchZooming(event: TouchEvent) {
-    const touch1 = event.touches[0]
-    const touch2 = event.touches[1]
-
-    const dx = touch2.clientX - touch1.clientX
-    const dy = touch2.clientY - touch1.clientY
-
-    this.initialPinchDistance = Math.sqrt(dx * dx + dy * dy)
-    this.initialZoomLevel = this.zoomLevel
-
-    this.svg.addEventListener('touchmove', this.onZoomTouchMove)
-    this.svg.addEventListener('touchend', this.onZoomTouchEnd)
+  public setImageProvider(provider: ImageProvider) {
+    this.imageProvider = provider
   }
 
-  protected onZoomTouchMove = (event: TouchEvent) => {
-    event.preventDefault()
+  protected onImageLoad(event: Event) {
+    const img = new Image()
 
-    if (event.touches.length === 2 && this.initialPinchDistance) {
-      const touch1 = event.touches[0]
-      const touch2 = event.touches[1]
-      const dx = touch2.clientX - touch1.clientX
-      const dy = touch2.clientY - touch1.clientY
-      const currentPinchDistance = Math.sqrt(dx * dx + dy * dy)
+    img.onload = () => {
+      const [vbX, vbY, vbWidth, vbHeight] = this.viewBox.split(' ').map(Number)
 
-      const scaleFactor = currentPinchDistance / this.initialPinchDistance
+      if (!this.initialViewBox) {
+        const width = img.naturalWidth
+        const height = img.naturalHeight
 
-      // 줌 threshold 확인 후 줌 적용
-      if (Math.abs(scaleFactor - 1) > this.zoomThreshold) {
-        this.zoomLevel = this.initialZoomLevel * scaleFactor
-        this.applyZoom()
+        this.initialViewBox = `0 0 ${width} ${height}`
+        this.viewBox = this.initialViewBox
+      } else {
+        this.viewBox = `${vbX} ${vbY} ${vbWidth} ${vbHeight}`
       }
     }
+
+    img.src = this.currentImage!
   }
 
-  protected onZoomTouchEnd = (event: TouchEvent) => {
-    event.preventDefault()
+  protected async updateImage() {
+    if (!this.imageProvider) {
+      throw new Error('ImageProvider is not set')
+    }
 
-    if (event.touches.length < 2) {
-      this.initialPinchDistance = null
+    const options = {
+      id: this.imageUrl, // 이미지 ID는 imageUrl 속성을 사용
+      scale: this.zoomLevel, // scale은 zoomLevel 속성을 사용
+      offsetX: 0, // offsetX는 0으로 설정
+      offsetY: 0, // offsetY는 0으로 설정
+      currentImage: this.currentImage // 기존 이미지 객체 전달
     }
 
-    this.svg.removeEventListener('touchmove', this.onZoomTouchMove)
-    this.svg.removeEventListener('touchend', this.onZoomTouchEnd)
+    this.currentImage = await this.imageProvider.getImage(options)
   }
 
-  protected applyZoom() {
-    const [vbX, vbY, vbWidth, vbHeight] = this.viewBox.split(' ').map(Number)
-    const initialViewBoxNumbers = this.initialViewBox.split(' ').map(Number)
-    const newVbWidth = initialViewBoxNumbers[2] / this.zoomLevel
-    const newVbHeight = initialViewBoxNumbers[3] / this.zoomLevel
-    const newVbX = vbX + (vbWidth - newVbWidth) / 2
-    const newVbY = vbY + (vbHeight - newVbHeight) / 2
+  protected onSvgWheel(event: WheelEvent) {
+    event.preventDefault()
 
-    this.viewBox = `${newVbX} ${newVbY} ${newVbWidth} ${newVbHeight}`
-  }
+    const { offsetX, offsetY, deltaY } = event
+    const scale = deltaY > 0 ? 1 - this.zoomFactor : 1 + this.zoomFactor
 
-  protected onSvgDoubleClick() {
-    this.resetZoom()
+    this.zoom(scale, offsetX, offsetY)
   }
 
-  protected resetZoom() {
-    this.viewBox = this.initialViewBox
-    this.zoomLevel = 1
-  }
+  protected onSvgPinch(e: GestureEventPinch) {
+    e.stopPropagation()
 
-  protected startPanning(event: MouseEvent | TouchEvent) {
-    const { x, y } = this.getPointFromEvent(event)
+    const { scale, centerX, centerY } = e.detail
 
-    this.isPanning = true
-    this.panStart = { x, y }
-    this.panInitiated = false // 팬 동작이 아직 시작되지 않았음을 나타냄
-    this.svg.classList.add('dragging')
+    console.log('pinch', e.detail)
 
-    if ('touches' in event) {
-      this.svg.addEventListener('touchmove', this.onPanMouseMove)
-      this.svg.addEventListener('touchend', this.onPanMouseUp)
-    } else {
-      this.svg.addEventListener('mousemove', this.onPanMouseMove)
-      this.svg.addEventListener('mouseup', this.onPanMouseUp)
-    }
+    this.zoom(scale, centerX, centerY)
   }
 
-  protected onPanMouseMove = (event: MouseEvent | TouchEvent) => {
-    if (!this.isPanning) {
-      return
-    }
-    event.preventDefault()
-
-    const { x, y } = this.getPointFromEvent(event)
+  protected onSvgDoubleTap(e: GestureEventDoubleTap) {
+    e.stopPropagation()
 
-    const dx = x - this.panStart.x
-    const dy = y - this.panStart.y
-
-    if (!this.panInitiated && Math.sqrt(dx * dx + dy * dy) < this.panThreshold) {
-      return
-    }
+    this.reset()
+  }
 
-    this.panInitiated = true
+  protected onSvgDrag(e: GestureEventDrag) {
+    const { deltaX, deltaY } = e.detail
+    console.log('drag', e.detail)
 
     const [vbX, vbY, vbWidth, vbHeight] = this.viewBox.split(' ').map(Number)
+
     const scaleX = vbWidth / this.svg.clientWidth
     const scaleY = vbHeight / this.svg.clientHeight
     const scale = Math.max(scaleX, scaleY)
 
-    const newVbX = vbX - dx * scale
-    const newVbY = vbY - dy * scale
+    const newVbX = vbX - deltaX * scale
+    const newVbY = vbY - deltaY * scale
 
     this.viewBox = `${newVbX} ${newVbY} ${vbWidth} ${vbHeight}`
-    this.panStart = { x, y }
+
+    this.debouncedUpdateImage()
   }
 
-  protected onPanMouseUp = (event: MouseEvent | TouchEvent) => {
-    event.preventDefault()
+  zoom(scale: number, offsetX: number, offsetY: number) {
+    if (Math.abs(scale) > this.zoomThreshold) {
+      this.zoomLevel *= scale
 
-    const svg = this.svg
+      const [vbX, vbY, vbWidth, vbHeight] = this.viewBox.split(' ').map(Number)
+      const mouseX = vbX + (offsetX / this.svg.clientWidth) * vbWidth
+      const mouseY = vbY + (offsetY / this.svg.clientHeight) * vbHeight
 
-    this.isPanning = false
-    svg.classList.remove('dragging')
+      const newVbWidth = vbWidth / scale
+      const newVbHeight = vbHeight / scale
 
-    if ('touches' in event) {
-      svg.removeEventListener('touchmove', this.onPanMouseMove)
-      svg.removeEventListener('touchend', this.onPanMouseUp)
-    } else {
-      svg.removeEventListener('mousemove', this.onPanMouseMove)
-      svg.removeEventListener('mouseup', this.onPanMouseUp)
+      const newVbX = mouseX - (offsetX / this.svg.clientWidth) * newVbWidth
+      const newVbY = mouseY - (offsetY / this.svg.clientHeight) * newVbHeight
+
+      this.viewBox = `${newVbX} ${newVbY} ${newVbWidth} ${newVbHeight}`
+
+      this.debouncedUpdateImage()
     }
   }
 
+  protected reset() {
+    this.viewBox = this.initialViewBox!
+    this.zoomLevel = 1
+
+    this.debouncedUpdateImage()
+  }
+
   protected renderShape(shape: Shape) {
     const commonAttrs = {
       stroke: 'red',
@@ -269,16 +213,17 @@ export class BaseImageMarker extends LitElement {
     }
   }
 
-  protected getPointFromEvent(event: MouseEvent | TouchEvent) {
-    if ('touches' in event) {
+  protected getPointFromEvent(event: MouseEvent | PointerEvent | GestureEventDrag) {
+    if ('clientX' in event) {
       return {
-        x: event.touches[0].clientX,
-        y: event.touches[0].clientY
+        x: event.clientX,
+        y: event.clientY
       }
     } else {
+      const { clientX, clientY } = event.detail
       return {
-        x: event.clientX,
-        y: event.clientY
+        x: clientX,
+        y: clientY
       }
     }
   }

package/src/default-image-provider.ts

@@ -0,0 +1,7 @@
+import { ImageOptions, ImageProvider } from './types'
+
+export class DefaultImageProvider implements ImageProvider {
+  async getImage(options: ImageOptions): Promise<string> {
+    return options.id
+  }
+}

package/src/ox-image-marker-view.ts

@@ -10,12 +10,12 @@ export class OxImageMarkerView extends BaseImageMarker {
       <div class="container">
         <svg
           @wheel=${this.onSvgWheel}
-          @mousedown=${this.onSvgMouseDown}
-          @touchstart=${this.onSvgTouchStart}
-          @dblclick=${this.onSvgDoubleClick}
+          @doubletap=${this.onSvgDoubleTap}
+          @pinch=${this.onSvgPinch}
+          @drag=${this.onSvgDrag}
           viewBox=${this.viewBox}
         >
-          <image href=${this.imageUrl} @load=${this.onImageLoad}></image>
+          <image href=${this.currentImage} @load=${this.onImageLoad}></image>
           ${this.shapes.map(shape => this.renderShape(shape))}
         </svg>
       </div>