LCOV - code coverage report
Current view: top level - packages/layer-editor/src/vue - useLayerEditorSession.ts Coverage Total Hit
Test: ComfyUI E2E Coverage Lines: 39.6 % 550 218
Test Date: 2026-11-17 04:17:53

            Line data    Source code
       1              : import type {
       2              :   CompactSize,
       3              :   Point2D,
       4              :   CompactRect as Rect,
       5              :   Point2D as Vec2
       6              : } from '@comfyorg/shared-frontend-utils/geometry'
       7              : import { clamp } from 'es-toolkit'
       8              : import { computed, reactive, ref } from 'vue'
       9              : 
      10              : import { BakeRasterCommand, snapshotRaster } from '#/commands/bakeContent'
      11              : import { PropCommand } from '#/commands/prop'
      12              : import { SetTransformCommand } from '#/commands/setTransform'
      13              : import type { Compositor } from '#/compositor'
      14              : import { filterTopmost, findNode } from '#/document'
      15              : import type { AlphaSampler } from '#/editor/pickOps'
      16              : import { pickLayerAt } from '#/editor/pickOps'
      17              : import { Dirty } from '#/history'
      18              : import type { FillSpec } from '#/fill'
      19              : import { fillKind, rasterKind } from '#/kinds/index'
      20              : import type { BlendFn } from '#/mode'
      21              : import { LAYER_MODES, defaultMode } from '#/mode'
      22              : import type { FillData, SceneNode, Transform } from '#/node'
      23              : import { placedBounds } from '#/render/bake'
      24              : import type { OutsideCanvasPreviewLayer } from '#/render/outsideCanvasPreview'
      25              : import { drawOutsideCanvasPreview } from '#/render/outsideCanvasPreview'
      26              : import { createSession } from '#/session'
      27              : import type { CanvasItem } from '#/tool'
      28              : import { canTransformNode } from '#/tools/transformTool'
      29              : import { hitHandle, unionBounds } from '#/tools/transformMath'
      30              : import { createPanZoom } from '#/viewport/panZoom'
      31              : 
      32              : export type LayerEditorPointerMode = 'pointer' | 'hand'
      33              : export type LayerEditorAlignOp =
      34              :   | 'left'
      35              :   | 'centerH'
      36              :   | 'right'
      37              :   | 'top'
      38              :   | 'centerV'
      39              :   | 'bottom'
      40              : 
      41              : export const CANVAS_SIZE_MIN = 64
      42            2 : export const CANVAS_SIZE_MAX = 8192
      43              : 
      44            2 : export const DEFAULT_BACKGROUND_COLOR = '#ffffff'
      45              : 
      46            2 : const HEX_COLOR_RE = /^#[0-9a-fA-F]{6}$/
      47              : 
      48              : export interface LayerEditorSessionOptions {
      49              :   createCompositor?: () => Compositor
      50              :   loadImage?: (url: string) => Promise<HTMLCanvasElement>
      51              :   alphaSampler?: AlphaSampler
      52              : }
      53              : 
      54              : export interface LayerEditorElements {
      55              :   viewport: HTMLElement
      56              :   container: HTMLElement
      57              :   main: HTMLCanvasElement
      58              :   overlay: HTMLCanvasElement
      59              : }
      60              : 
      61            4 : function loadImageElement(url: string): Promise<HTMLImageElement> {
      62            4 :   return new Promise((resolve, reject) => {
      63            4 :     const img = new Image()
      64            4 :     img.crossOrigin = 'anonymous'
      65            4 :     img.onload = () => resolve(img)
      66            4 :     img.onerror = () => reject(new Error(`failed to load image: ${url}`))
      67            4 :     img.src = url
      68              :   })
      69              : }
      70              : 
      71            4 : async function defaultLoadImage(url: string): Promise<HTMLCanvasElement> {
      72            4 :   const img = await loadImageElement(url)
      73            4 :   const canvas = document.createElement('canvas')
      74            4 :   canvas.width = img.naturalWidth || img.width
      75            4 :   canvas.height = img.naturalHeight || img.height
      76            4 :   canvas.getContext('2d')?.drawImage(img, 0, 0)
      77            4 :   return canvas
      78              : }
      79              : 
      80            2 : export function isTextEditingTarget(target: EventTarget | null): boolean {
      81            2 :   const el = target as HTMLElement | null
      82            2 :   const tag = el?.tagName
      83            2 :   return tag === 'INPUT' || tag === 'TEXTAREA' || Boolean(el?.isContentEditable)
      84              : }
      85              : 
      86            0 : function sameTransform(a: Transform, b: Transform): boolean {
      87            0 :   return (
      88              :     a.x === b.x &&
      89              :     a.y === b.y &&
      90              :     a.w === b.w &&
      91              :     a.h === b.h &&
      92              :     a.rotation === b.rotation
      93              :   )
      94              : }
      95              : 
      96            0 : function visualBounds(t: Transform): Rect {
      97            0 :   return t.rotation === 0 ? { x: t.x, y: t.y, w: t.w, h: t.h } : placedBounds(t)
      98              : }
      99              : 
     100            0 : function flipCanvasAxis(
     101              :   src: HTMLCanvasElement,
     102              :   axis: 'h' | 'v'
     103              : ): HTMLCanvasElement | null {
     104            0 :   const canvas = document.createElement('canvas')
     105            0 :   canvas.width = src.width
     106            0 :   canvas.height = src.height
     107            0 :   const ctx = canvas.getContext('2d')
     108            0 :   if (!ctx) return null
     109            0 :   if (axis === 'h') {
     110            0 :     ctx.translate(src.width, 0)
     111            0 :     ctx.scale(-1, 1)
     112              :   } else {
     113            0 :     ctx.translate(0, src.height)
     114            0 :     ctx.scale(1, -1)
     115              :   }
     116            0 :   ctx.drawImage(src, 0, 0)
     117            0 :   return canvas
     118              : }
     119              : 
     120              : export type LayerEditorSession = ReturnType<typeof useLayerEditorSession>
     121              : 
     122            2 : export function useLayerEditorSession(opts: LayerEditorSessionOptions = {}) {
     123            2 :   const loadImage = opts.loadImage ?? defaultLoadImage
     124            2 :   const version = ref(0)
     125            2 :   const activeNodeId = ref<string | null>(null)
     126            2 :   const glOk = ref(true)
     127            2 :   const zoomRatio = ref(1)
     128            2 :   const spaceDown = ref(false)
     129            2 :   const hoverCursor = ref('default')
     130            2 :   const pointerMode = ref<LayerEditorPointerMode>('pointer')
     131            2 :   const panning = ref(false)
     132              : 
     133            2 :   const flipParity = reactive(new Map<string, { h: boolean; v: boolean }>())
     134            2 :   const inputOrderIds: string[] = []
     135              : 
     136            2 :   const session = createSession({
     137              :     createCompositor: opts.createCompositor,
     138              :     onChange
     139              :   })
     140            2 :   const { editor, compositor } = session
     141            2 :   glOk.value = session.glOk
     142            2 :   const content = editor.content
     143              : 
     144            2 :   let mainCanvas: HTMLCanvasElement | null = null
     145            2 :   let overlayCanvas: HTMLCanvasElement | null = null
     146            2 :   let viewportEl: HTMLElement | null = null
     147            2 :   let containerEl: HTMLElement | null = null
     148            2 :   const panZoom = createPanZoom(() =>
     149              :     viewportEl && containerEl
     150              :       ? { viewport: viewportEl, container: containerEl }
     151              :       : null
     152              :   )
     153            2 :   panZoom.onChange(() => {
     154            6 :     zoomRatio.value = panZoom.zoom()
     155              :   })
     156              : 
     157            2 :   const layers = computed<SceneNode[]>(() => {
     158            9 :     void version.value
     159            9 :     return [...editor.document().root.children]
     160              :   })
     161            2 :   const backgroundLayer = computed<FillData | null>(() => {
     162            9 :     const first = layers.value[0]
     163            9 :     return first.kind === 'fill' ? { ...first } : null
     164              :   })
     165            2 :   const imageLayers = computed<SceneNode[]>(() =>
     166              :     layers.value.filter((n) => n.kind !== 'fill')
     167              :   )
     168            2 :   const activeNode = computed<SceneNode | null>(() => {
     169            9 :     void version.value
     170            9 :     const node = activeNodeId.value ? engineNode(activeNodeId.value) : null
     171            9 :     return node ? { ...node } : null
     172              :   })
     173            2 :   const selectedNodeIds = computed<string[]>(() => {
     174            9 :     void version.value
     175            9 :     return editor.selectedNodeIds()
     176              :   })
     177            2 :   const canUndo = computed(() => version.value >= 0 && editor.history.canUndo())
     178            2 :   const canRedo = computed(() => version.value >= 0 && editor.history.canRedo())
     179            2 :   const selectedContext = computed<'background' | 'layer'>(() => {
     180            9 :     void version.value
     181            9 :     const node = activeNodeId.value ? engineNode(activeNodeId.value) : null
     182            9 :     return node && node.kind !== 'fill' ? 'layer' : 'background'
     183              :   })
     184            2 :   const canvasSize = computed<CompactSize>(() => {
     185            9 :     void version.value
     186            9 :     const doc = editor.document()
     187            9 :     return { w: doc.width, h: doc.height }
     188              :   })
     189              : 
     190           18 :   function engineNode(id: string): SceneNode | null {
     191           18 :     return findNode(editor.document().root, id)?.node ?? null
     192              :   }
     193              : 
     194            0 :   function backgroundNode(): FillData | null {
     195            0 :     const first = editor.document().root.children[0]
     196            0 :     return first.kind === 'fill' ? first : null
     197              :   }
     198              : 
     199           11 :   function onChange(): void {
     200           11 :     version.value += 1
     201           11 :     activeNodeId.value = editor.activeNodeId()
     202           11 :     requestRender()
     203              :   }
     204              : 
     205           11 :   function present(): void {
     206           11 :     if (!mainCanvas) return
     207           11 :     const { width, height } = editor.document()
     208           11 :     const resized = mainCanvas.width !== width || mainCanvas.height !== height
     209           11 :     if (resized) {
     210            4 :       mainCanvas.width = width
     211            4 :       mainCanvas.height = height
     212              :     }
     213           11 :     const ctx = mainCanvas.getContext('2d')
     214           11 :     if (!ctx) return
     215           11 :     if (!glOk.value) {
     216            0 :       ctx.clearRect(0, 0, width, height)
     217            0 :       return
     218              :     }
     219           11 :     editor.setZoom(Math.max(0.01, panZoom.zoom()))
     220           11 :     const dmg = editor.takePresentDamage()
     221              :     const clean = !dmg.full && !dmg.rect
     222           11 :     if (clean && !resized) return
     223           11 :     if (dmg.rect && !dmg.full && !resized) {
     224            0 :       const img = compositor.readback(dmg.rect)
     225            0 :       ctx.putImageData(
     226              :         img,
     227              :         Math.max(0, Math.floor(dmg.rect.x)),
     228              :         Math.max(0, Math.floor(dmg.rect.y))
     229              :       )
     230            0 :       return
     231              :     }
     232            9 :     ctx.clearRect(0, 0, width, height)
     233            9 :     editor.render()
     234            9 :     ctx.putImageData(compositor.readback(), 0, 0)
     235              :   }
     236              : 
     237           77 :   function drawItem(
     238              :     ctx: CanvasRenderingContext2D,
     239              :     item: CanvasItem,
     240              :     hs: number
     241              :   ): void {
     242           77 :     switch (item.type) {
     243              :       case 'handle':
     244           63 :         ctx.beginPath()
     245           63 :         if (item.shape === 'circle')
     246            7 :           ctx.arc(item.pos.x, item.pos.y, hs, 0, Math.PI * 2)
     247           56 :         else ctx.rect(item.pos.x - hs, item.pos.y - hs, hs * 2, hs * 2)
     248           63 :         ctx.fill()
     249           63 :         ctx.stroke()
     250           63 :         break
     251              :       case 'line':
     252            7 :         ctx.beginPath()
     253            7 :         ctx.moveTo(item.a.x, item.a.y)
     254            7 :         ctx.lineTo(item.b.x, item.b.y)
     255            7 :         ctx.stroke()
     256            7 :         break
     257              :       case 'polyline':
     258            7 :         ctx.beginPath()
     259            7 :         item.points.forEach((p, i) =>
     260              :           i ? ctx.lineTo(p.x, p.y) : ctx.moveTo(p.x, p.y)
     261              :         )
     262            7 :         if (item.closed) ctx.closePath()
     263            7 :         if (item.ants) {
     264            0 :           ctx.save()
     265            0 :           ctx.strokeStyle = '#000000'
     266            0 :           ctx.stroke()
     267            0 :           ctx.strokeStyle = '#ffffff'
     268            0 :           ctx.setLineDash([hs, hs])
     269            0 :           ctx.stroke()
     270            0 :           ctx.restore()
     271              :         } else {
     272            7 :           ctx.stroke()
     273              :         }
     274            7 :         break
     275              :       case 'arc':
     276            0 :         ctx.beginPath()
     277            0 :         ctx.arc(item.center.x, item.center.y, item.radius, 0, Math.PI * 2)
     278            0 :         ctx.stroke()
     279            0 :         break
     280              :       case 'rect':
     281            0 :         if (item.ants) {
     282            0 :           ctx.save()
     283            0 :           ctx.strokeStyle = '#000000'
     284            0 :           ctx.strokeRect(item.rect.x, item.rect.y, item.rect.w, item.rect.h)
     285            0 :           ctx.strokeStyle = '#ffffff'
     286            0 :           ctx.setLineDash([hs, hs])
     287            0 :           ctx.strokeRect(item.rect.x, item.rect.y, item.rect.w, item.rect.h)
     288            0 :           ctx.restore()
     289              :         } else {
     290            0 :           ctx.strokeRect(item.rect.x, item.rect.y, item.rect.w, item.rect.h)
     291              :         }
     292            0 :         break
     293              :       case 'preview':
     294            0 :         ctx.drawImage(
     295              :           item.canvas,
     296              :           item.rect.x,
     297              :           item.rect.y,
     298              :           item.rect.w,
     299              :           item.rect.h
     300              :         )
     301              :         break
     302              :     }
     303              :   }
     304              : 
     305           11 :   function selectedOutsideCanvasPreviewLayers(): OutsideCanvasPreviewLayer[] {
     306           11 :     const selectedIds = new Set(editor.selectedNodeIds())
     307           11 :     const previewLayers: OutsideCanvasPreviewLayer[] = []
     308           11 :     for (const node of editor.document().root.children) {
     309           23 :       if (!selectedIds.has(node.id) || node.kind !== 'raster' || !node.visible)
     310           16 :         continue
     311           23 :       const bitmap = content.get(node.contentId)?.canvas
     312           23 :       if (bitmap)
     313            7 :         previewLayers.push({
     314              :           bitmap,
     315              :           opacity: node.opacity,
     316              :           transform: node.transform
     317              :         })
     318              :     }
     319           11 :     return previewLayers
     320              :   }
     321              : 
     322           11 :   function drawOverlayCanvas(): void {
     323           11 :     if (!overlayCanvas || !viewportEl || !containerEl) return
     324           11 :     const dpr = window.devicePixelRatio || 1
     325           11 :     const bw = Math.max(1, Math.round(viewportEl.clientWidth * dpr))
     326           11 :     const bh = Math.max(1, Math.round(viewportEl.clientHeight * dpr))
     327           11 :     if (overlayCanvas.width !== bw) overlayCanvas.width = bw
     328           11 :     if (overlayCanvas.height !== bh) overlayCanvas.height = bh
     329           11 :     editor.buildOverlay()
     330           11 :     const ctx = overlayCanvas.getContext('2d')
     331           11 :     if (!ctx) return
     332           11 :     ctx.setTransform(1, 0, 0, 1, 0, 0)
     333           11 :     ctx.clearRect(0, 0, bw, bh)
     334           11 :     const z = Math.max(0.01, panZoom.zoom())
     335           11 :     ctx.setTransform(
     336              :       z * dpr,
     337              :       0,
     338              :       0,
     339              :       z * dpr,
     340              :       containerEl.offsetLeft * dpr,
     341              :       containerEl.offsetTop * dpr
     342              :     )
     343           11 :     const { width, height } = editor.document()
     344           11 :     drawOutsideCanvasPreview(
     345              :       ctx,
     346              :       { w: width, h: height },
     347              :       selectedOutsideCanvasPreviewLayers()
     348              :     )
     349           11 :     ctx.lineWidth = 1 / z
     350           11 :     ctx.strokeStyle = '#3b82f6'
     351           11 :     ctx.fillStyle = '#ffffff'
     352           11 :     const hs = 4 / z
     353           77 :     for (const item of editor.overlay.items) drawItem(ctx, item, hs)
     354              :   }
     355              : 
     356            2 :   let disposed = false
     357            2 :   let rafId: number | null = null
     358           19 :   function requestRender(): void {
     359           19 :     if (disposed) return
     360           19 :     if (rafId == null)
     361           11 :       rafId = requestAnimationFrame(() => {
     362           11 :         rafId = null
     363           11 :         present()
     364           11 :         drawOverlayCanvas()
     365              :       })
     366              :   }
     367            2 :   let overlayRafId: number | null = null
     368            0 :   function requestOverlayRender(): void {
     369            0 :     if (disposed || rafId != null || overlayRafId != null) return
     370            0 :     overlayRafId = requestAnimationFrame(() => {
     371            0 :       overlayRafId = null
     372            0 :       drawOverlayCanvas()
     373              :     })
     374              :   }
     375              : 
     376            2 :   editor.setTool('transform')
     377              : 
     378            2 :   function setElements(els: LayerEditorElements): void {
     379            2 :     viewportEl = els.viewport
     380            2 :     containerEl = els.container
     381            2 :     mainCanvas = els.main
     382            2 :     overlayCanvas = els.overlay
     383            2 :     fitView()
     384              :   }
     385              : 
     386            6 :   function fitView(): void {
     387            6 :     panZoom.fit(editor.document().width, editor.document().height)
     388            6 :     requestRender()
     389              :   }
     390              : 
     391            0 :   function setZoom(ratio: number): void {
     392            0 :     panZoom.setZoom(ratio)
     393            0 :     requestRender()
     394              :   }
     395              : 
     396            2 :   function addBackgroundLayer(): void {
     397            2 :     editor.addNode(
     398              :       fillKind.create({
     399              :         name: 'Background',
     400              :         fill: { type: 'solid', color: DEFAULT_BACKGROUND_COLOR },
     401              :         opacity: 1,
     402              :         visible: false,
     403              :         locks: { content: true, position: true, visibility: false }
     404              :       }),
     405              :       0
     406              :     )
     407              :   }
     408              : 
     409            2 :   async function loadImages(urls: string[], names: string[]): Promise<number> {
     410            2 :     flipParity.clear()
     411            2 :     inputOrderIds.length = 0
     412            2 :     let failed = 0
     413            2 :     let docWidth = 0
     414            2 :     let docHeight = 0
     415            2 :     for (const [i, url] of urls.entries()) {
     416            4 :       let canvas: HTMLCanvasElement
     417            4 :       try {
     418            4 :         canvas = await loadImage(url)
     419              :       } catch (err) {
     420            0 :         console.warn('[LayerEditor] failed to load image', url, err)
     421            0 :         failed += 1
     422            0 :         continue
     423              :       }
     424            4 :       if (disposed) return failed
     425            4 :       docWidth = Math.max(docWidth, canvas.width)
     426            4 :       docHeight = Math.max(docHeight, canvas.height)
     427            4 :       const contentId = content.register(canvas, { uploadedUrl: url })
     428            4 :       const layer = rasterKind.create({
     429              :         name: names[i],
     430              :         contentId,
     431              :         url,
     432              :         naturalWidth: canvas.width,
     433              :         naturalHeight: canvas.height,
     434              :         transform: {
     435              :           x: 0,
     436              :           y: 0,
     437              :           w: canvas.width,
     438              :           h: canvas.height,
     439              :           rotation: 0
     440              :         }
     441              :       })
     442            4 :       editor.addNode(layer)
     443            4 :       inputOrderIds.push(layer.id)
     444              :     }
     445            2 :     if (docWidth > 0 && docHeight > 0) {
     446            2 :       const width = Math.min(docWidth, CANVAS_SIZE_MAX)
     447            2 :       const height = Math.min(docHeight, CANVAS_SIZE_MAX)
     448            2 :       const doc = editor.document()
     449            2 :       doc.width = width
     450            2 :       doc.height = height
     451            2 :       if (glOk.value) compositor.resize(width, height)
     452              :     }
     453            2 :     editor.history.clear()
     454            2 :     fitView()
     455            2 :     requestRender()
     456            2 :     return failed
     457              :   }
     458              : 
     459            0 :   function editProp<T>(
     460              :     label: string,
     461              :     dirty: number,
     462              :     get: () => T,
     463              :     set: (v: T) => void,
     464              :     value: T,
     465              :     mergeKey?: string
     466              :   ): void {
     467            0 :     const before = get()
     468            0 :     if (before === value) return
     469            0 :     set(value)
     470            0 :     editor.history.push(
     471              :       new PropCommand(label, dirty, get, set, before, value, mergeKey)
     472              :     )
     473            0 :     editor.invalidate()
     474              :   }
     475              : 
     476            0 :   function selectionTargets(id: string): string[] {
     477            0 :     const sel = editor.selectedNodeIds()
     478            0 :     return sel.length > 1 && sel.includes(id) ? sel : [id]
     479              :   }
     480              : 
     481            0 :   function batch(
     482              :     label: string,
     483              :     ids: string[],
     484              :     apply: (id: string) => void
     485              :   ): void {
     486            0 :     if (ids.length > 1) editor.history.beginGroup(label)
     487            0 :     for (const tid of ids) apply(tid)
     488            0 :     if (ids.length > 1) editor.history.endGroup()
     489              :   }
     490              : 
     491            0 :   function setOpacity(id: string, v: number): void {
     492            0 :     batch('Opacity', selectionTargets(id), (tid) => {
     493            0 :       const n = engineNode(tid)
     494            0 :       if (!n) return
     495            0 :       editProp(
     496              :         'Opacity',
     497              :         Dirty.META,
     498              :         () => n.opacity,
     499              :         (x) => (n.opacity = x),
     500              :         clamp(v, 0, 1),
     501              :         `opacity:${tid}`
     502              :       )
     503              :     })
     504              :   }
     505              : 
     506            0 :   function setBlendMode(id: string, v: BlendFn): void {
     507            0 :     batch('Blend', selectionTargets(id), (tid) => {
     508            0 :       const n = engineNode(tid)
     509            0 :       if (!n) return
     510            0 :       editProp(
     511              :         'Blend',
     512              :         Dirty.DRAWABLE,
     513              :         () => n.mode,
     514              :         (m) => (n.mode = m),
     515              :         defaultMode(Object.hasOwn(LAYER_MODES, v) ? v : 'normal'),
     516              :         `blend:${tid}`
     517              :       )
     518              :     })
     519              :   }
     520              : 
     521            0 :   function toggleVisible(id: string): void {
     522            0 :     const n = engineNode(id)
     523            0 :     if (!n) return
     524            0 :     editProp(
     525              :       'Visibility',
     526              :       Dirty.META,
     527              :       () => n.visible,
     528              :       (x) => (n.visible = x),
     529              :       !n.visible
     530              :     )
     531              :   }
     532              : 
     533            0 :   function renameLayer(id: string, name: string): void {
     534            0 :     const n = engineNode(id)
     535            0 :     if (!n) return
     536            0 :     editProp(
     537              :       'Rename',
     538              :       Dirty.META,
     539              :       () => n.name,
     540              :       (x) => (n.name = x),
     541              :       name.trim() || n.name
     542              :     )
     543              :   }
     544              : 
     545            0 :   function inputLayerIds(): string[] {
     546            0 :     return [...inputOrderIds]
     547              :   }
     548              : 
     549            0 :   function setLayerOrder(ids: string[]): void {
     550            0 :     const offset = backgroundLayer.value ? 1 : 0
     551            0 :     ids.forEach((id, index) => {
     552            0 :       editor.moveNodeTo(id, undefined, offset + index)
     553              :     })
     554              :   }
     555              : 
     556            0 :   function moveLayerTo(id: string, toIndex: number): void {
     557            0 :     const bg = backgroundLayer.value
     558            0 :     if (bg && (id === bg.id || toIndex < 1)) return
     559            0 :     editor.moveNodeTo(id, undefined, toIndex)
     560              :   }
     561              : 
     562            1 :   function moveLayer(id: string, dir: 1 | -1): void {
     563            1 :     const bg = backgroundLayer.value
     564            1 :     if (bg) {
     565            1 :       if (id === bg.id) return
     566            1 :       const index = editor
     567              :         .document()
     568              :         .root.children.findIndex((n) => n.id === id)
     569            1 :       if (dir === -1 && index !== -1 && index <= 1) return
     570              :     }
     571            1 :     editor.moveNode(id, dir)
     572              :   }
     573              : 
     574            2 :   function setActiveNode(id: string | null): void {
     575            2 :     editor.setActiveNode(id)
     576              :   }
     577              : 
     578            0 :   function setSelectedNodes(ids: string[]): void {
     579            0 :     editor.setSelectedNodes(ids)
     580              :   }
     581              : 
     582            0 :   function selectBackground(): void {
     583            0 :     const bg = backgroundLayer.value
     584            0 :     editor.setSelectedNodes(bg ? [bg.id] : [])
     585              :   }
     586              : 
     587            0 :   function setBackgroundColor(hex: string): void {
     588            0 :     const bg = backgroundNode()
     589            0 :     if (!bg || !HEX_COLOR_RE.test(hex)) return
     590            0 :     const color = hex.toLowerCase()
     591            0 :     if (bg.fill.type === 'solid' && bg.fill.color === color) return
     592            0 :     editProp<FillSpec>(
     593              :       'Background Color',
     594              :       Dirty.DRAWABLE,
     595              :       () => bg.fill,
     596              :       (v) => (bg.fill = v),
     597              :       { type: 'solid', color },
     598              :       `bg-color:${bg.id}`
     599              :     )
     600              :   }
     601              : 
     602            0 :   function setBackgroundOpacity(v: number): void {
     603            0 :     const bg = backgroundNode()
     604            0 :     if (!bg) return
     605            0 :     editProp(
     606              :       'Background Opacity',
     607              :       Dirty.META,
     608              :       () => bg.opacity,
     609              :       (x) => (bg.opacity = x),
     610              :       clamp(v, 0, 1),
     611              :       `bg-opacity:${bg.id}`
     612              :     )
     613              :   }
     614              : 
     615            0 :   function setBackgroundVisible(visible: boolean): void {
     616            0 :     const bg = backgroundNode()
     617            0 :     if (!bg) return
     618            0 :     editProp(
     619              :       'Background Visibility',
     620              :       Dirty.META,
     621              :       () => bg.visible,
     622              :       (x) => (bg.visible = x),
     623              :       visible
     624              :     )
     625              :   }
     626              : 
     627            0 :   function setPointerMode(mode: LayerEditorPointerMode): void {
     628            0 :     pointerMode.value = mode
     629              :   }
     630              : 
     631            0 :   function shiftLayers(nodes: SceneNode[], dx: number, dy: number): void {
     632            0 :     if (dx === 0 && dy === 0) return
     633            0 :     for (const n of nodes) {
     634            0 :       if (n.kind === 'fill') continue
     635            0 :       n.transform = {
     636              :         ...n.transform,
     637              :         x: n.transform.x + dx,
     638              :         y: n.transform.y + dy
     639              :       }
     640            0 :       if (n.kind === 'group') shiftLayers(n.children, dx, dy)
     641              :     }
     642              :   }
     643              : 
     644            0 :   function setCanvasSize(w: number, h: number): void {
     645            0 :     const doc = editor.document()
     646            0 :     const width = clamp(Math.round(w), CANVAS_SIZE_MIN, CANVAS_SIZE_MAX)
     647            0 :     const height = clamp(Math.round(h), CANVAS_SIZE_MIN, CANVAS_SIZE_MAX)
     648            0 :     const before = { w: doc.width, h: doc.height }
     649            0 :     if (before.w === width && before.h === height) return
     650            0 :     const apply = (v: CompactSize): void => {
     651            0 :       const dx = Math.trunc((v.w - doc.width) / 2)
     652            0 :       const dy = Math.trunc((v.h - doc.height) / 2)
     653            0 :       doc.width = v.w
     654            0 :       doc.height = v.h
     655            0 :       if (glOk.value) compositor.resize(v.w, v.h)
     656            0 :       shiftLayers(doc.root.children, dx, dy)
     657            0 :       panZoom.setArtboardSize(v.w, v.h)
     658            0 :       panZoom.panBy(-dx * panZoom.zoom(), -dy * panZoom.zoom())
     659              :     }
     660            0 :     apply({ w: width, h: height })
     661            0 :     editor.history.push(
     662              :       new PropCommand(
     663              :         'Canvas Size',
     664              :         Dirty.STRUCTURE,
     665              :         () => ({ w: doc.width, h: doc.height }),
     666              :         apply,
     667              :         before,
     668              :         { w: width, h: height }
     669              :       )
     670              :     )
     671            0 :     editor.invalidate()
     672              :   }
     673              : 
     674            0 :   function pushLayerTransform(
     675              :     label: string,
     676              :     id: string,
     677              :     patch: Partial<Transform>
     678              :   ): void {
     679            0 :     const n = engineNode(id)
     680            0 :     if (!n || n.locks.position) return
     681            0 :     const before = { ...n.transform }
     682            0 :     const after = { ...before, ...patch }
     683            0 :     if (sameTransform(before, after)) return
     684            0 :     n.transform = after
     685            0 :     editor.history.push(new SetTransformCommand(label, n, before, after))
     686            0 :     editor.invalidate()
     687              :   }
     688              : 
     689            0 :   function setLayerPosition(id: string, x?: number, y?: number): void {
     690            0 :     const patch: Partial<Transform> = {}
     691            0 :     if (x !== undefined && Number.isFinite(x)) patch.x = x
     692            0 :     if (y !== undefined && Number.isFinite(y)) patch.y = y
     693            0 :     pushLayerTransform('Position', id, patch)
     694              :   }
     695              : 
     696            0 :   function setLayerDimensions(id: string, w?: number, h?: number): void {
     697            0 :     const patch: Partial<Transform> = {}
     698            0 :     if (w !== undefined && Number.isFinite(w)) patch.w = Math.max(1, w)
     699            0 :     if (h !== undefined && Number.isFinite(h)) patch.h = Math.max(1, h)
     700            0 :     pushLayerTransform('Dimensions', id, patch)
     701              :   }
     702              : 
     703            0 :   function setLayerRotationDeg(id: string, deg: number): void {
     704            0 :     if (!Number.isFinite(deg)) return
     705            0 :     pushLayerTransform('Rotation', id, { rotation: (deg * Math.PI) / 180 })
     706              :   }
     707              : 
     708            0 :   function alignLayer(id: string, op: LayerEditorAlignOp): void {
     709            0 :     const doc = editor.document()
     710            0 :     batch('Align', selectionTargets(id), (tid) => {
     711            0 :       const n = engineNode(tid)
     712            0 :       if (!n || n.locks.position) return
     713            0 :       const b = visualBounds(n.transform)
     714            0 :       switch (op) {
     715              :         case 'left':
     716            0 :           pushLayerTransform('Align', tid, { x: n.transform.x - b.x })
     717            0 :           break
     718              :         case 'centerH':
     719            0 :           pushLayerTransform('Align', tid, {
     720              :             x: n.transform.x + ((doc.width - b.w) / 2 - b.x)
     721              :           })
     722            0 :           break
     723              :         case 'right':
     724            0 :           pushLayerTransform('Align', tid, {
     725              :             x: n.transform.x + (doc.width - b.w - b.x)
     726              :           })
     727            0 :           break
     728              :         case 'top':
     729            0 :           pushLayerTransform('Align', tid, { y: n.transform.y - b.y })
     730            0 :           break
     731              :         case 'centerV':
     732            0 :           pushLayerTransform('Align', tid, {
     733              :             y: n.transform.y + ((doc.height - b.h) / 2 - b.y)
     734              :           })
     735            0 :           break
     736              :         case 'bottom':
     737            0 :           pushLayerTransform('Align', tid, {
     738              :             y: n.transform.y + (doc.height - b.h - b.y)
     739              :           })
     740              :           break
     741              :       }
     742              :     })
     743              :   }
     744              : 
     745            0 :   function flipLayer(id: string, axis: 'h' | 'v'): void {
     746            0 :     const n = engineNode(id)
     747            0 :     if (!n || n.kind !== 'raster' || n.locks.content) return
     748            0 :     const entry = content.get(n.contentId)
     749            0 :     if (!entry) return
     750            0 :     const flipped = flipCanvasAxis(entry.canvas, axis)
     751            0 :     if (!flipped) return
     752            0 :     const before = snapshotRaster(n)
     753            0 :     n.contentId = content.register(flipped)
     754            0 :     n.url = undefined
     755            0 :     if (n.mask) {
     756            0 :       const maskEntry = content.get(n.mask.contentId)
     757            0 :       const flippedMask = maskEntry
     758              :         ? flipCanvasAxis(maskEntry.canvas, axis)
     759              :         : null
     760            0 :       if (flippedMask) {
     761            0 :         n.mask = {
     762              :           ...n.mask,
     763              :           contentId: content.register(flippedMask),
     764              :           url: undefined
     765              :         }
     766              :       }
     767              :     }
     768            0 :     const parityBefore = layerFlips(id)
     769            0 :     const parityAfter =
     770              :       axis === 'h'
     771              :         ? { ...parityBefore, h: !parityBefore.h }
     772              :         : { ...parityBefore, v: !parityBefore.v }
     773            0 :     const setParity = (p: { h: boolean; v: boolean }): void => {
     774            0 :       flipParity.set(id, p)
     775              :     }
     776            0 :     setParity(parityAfter)
     777            0 :     editor.history.beginGroup('Flip Layer')
     778            0 :     editor.history.push(
     779              :       new BakeRasterCommand('Flip Layer', n, before, snapshotRaster(n), content)
     780              :     )
     781            0 :     editor.history.push(
     782              :       new PropCommand(
     783              :         'Flip Layer',
     784              :         Dirty.META,
     785              :         () => layerFlips(id),
     786              :         setParity,
     787              :         parityBefore,
     788              :         parityAfter
     789              :       )
     790              :     )
     791            0 :     editor.history.endGroup()
     792            0 :     editor.invalidate()
     793              :   }
     794              : 
     795            0 :   function layerFlips(id: string): { h: boolean; v: boolean } {
     796            0 :     return flipParity.get(id) ?? { h: false, v: false }
     797              :   }
     798              : 
     799            1 :   function undo(): void {
     800            1 :     editor.undo()
     801              :   }
     802              : 
     803            1 :   function redo(): void {
     804            1 :     editor.redo()
     805              :   }
     806              : 
     807            0 :   function artboardPt(e: PointerEvent): Point2D {
     808            0 :     return panZoom.screenToArtboard(e.clientX, e.clientY)
     809              :   }
     810              : 
     811            2 :   let panLast = { x: 0, y: 0 }
     812            2 :   let toolActive = false
     813            2 :   let pendingMoves: PointerEvent[] = []
     814            2 :   let moveRaf: number | null = null
     815              : 
     816            0 :   function capturePointer(zone: HTMLElement, e: PointerEvent): void {
     817            0 :     try {
     818            0 :       zone.setPointerCapture(e.pointerId)
     819              :     } catch {
     820              :       void 0
     821              :     }
     822              :   }
     823              : 
     824            0 :   function selectedTransformTargets(): SceneNode[] {
     825            0 :     const root = editor.document().root
     826            0 :     return filterTopmost(root, editor.selectedNodeIds())
     827              :       .map((id) => findNode(root, id)?.node ?? null)
     828              :       .filter((n): n is SceneNode => canTransformNode(n))
     829              :   }
     830              : 
     831            0 :   function selectionGizmo(): Transform | null {
     832            0 :     const targets = selectedTransformTargets()
     833            0 :     if (!targets.length) return null
     834            0 :     return targets.length === 1
     835              :       ? { ...targets[0].transform }
     836              :       : unionBounds(targets.map((n) => n.transform))
     837              :   }
     838              : 
     839            0 :   function resolvePointerTarget(e: PointerEvent, pt: Vec2): boolean {
     840            0 :     if (editor.floating()) return true
     841            0 :     const additive = e.shiftKey || e.ctrlKey || e.metaKey
     842            0 :     if (!additive) {
     843            0 :       const gizmo = selectionGizmo()
     844            0 :       const tol = 8 / Math.max(1e-3, panZoom.zoom())
     845            0 :       if (gizmo && hitHandle(gizmo, pt, tol)) return true
     846              :     }
     847            0 :     const picked = pickLayerAt(
     848              :       editor.document().root.children,
     849              :       pt,
     850              :       content,
     851              :       opts.alphaSampler
     852              :     )
     853            0 :     if (!picked) {
     854            0 :       if (!additive) editor.setSelectedNodes([])
     855            0 :       return false
     856              :     }
     857            0 :     const sel = editor.selectedNodeIds()
     858            0 :     if (additive) {
     859            0 :       editor.setSelectedNodes(
     860              :         sel.includes(picked.id)
     861              :           ? sel.filter((sid) => sid !== picked.id)
     862              :           : [...sel, picked.id]
     863              :       )
     864            0 :     } else if (!sel.includes(picked.id)) {
     865            0 :       editor.setSelectedNodes([picked.id])
     866              :     }
     867            0 :     return true
     868              :   }
     869              : 
     870            0 :   function onPointerDown(e: PointerEvent): void {
     871            0 :     const zone = viewportEl
     872            0 :     if (!zone) return
     873            0 :     zone.focus()
     874            0 :     pendingMoves = []
     875            0 :     if (
     876              :       e.button === 1 ||
     877              :       e.button === 2 ||
     878              :       (e.button === 0 && (spaceDown.value || pointerMode.value === 'hand'))
     879              :     ) {
     880            0 :       panning.value = true
     881            0 :       panLast = { x: e.offsetX, y: e.offsetY }
     882            0 :       capturePointer(zone, e)
     883            0 :       return
     884              :     }
     885            0 :     if (e.button !== 0) return
     886            0 :     if (!resolvePointerTarget(e, artboardPt(e))) return
     887            0 :     editor.pointerDown(e, artboardPt(e))
     888            0 :     toolActive = true
     889            0 :     capturePointer(zone, e)
     890              :   }
     891              : 
     892            0 :   function flushMove(): void {
     893            0 :     moveRaf = null
     894            0 :     const events = pendingMoves
     895            0 :     pendingMoves = []
     896            0 :     const e = events.at(-1)
     897            0 :     if (!e) return
     898            0 :     if (panning.value) {
     899            0 :       panZoom.panBy(e.offsetX - panLast.x, e.offsetY - panLast.y)
     900            0 :       panLast = { x: e.offsetX, y: e.offsetY }
     901            0 :       requestOverlayRender()
     902            0 :       return
     903              :     }
     904            0 :     if (toolActive) {
     905            0 :       editor.pointerMove(e, artboardPt(e))
     906              :     } else {
     907            0 :       hoverCursor.value = editor.cursorAt(artboardPt(e))
     908              :     }
     909              :   }
     910              : 
     911            0 :   function onPointerMove(e: PointerEvent): void {
     912            0 :     pendingMoves.push(e)
     913            0 :     if (moveRaf == null) moveRaf = requestAnimationFrame(flushMove)
     914              :   }
     915              : 
     916            0 :   function endToolGesture(e: PointerEvent): void {
     917            0 :     editor.pointerUp(e, artboardPt(e))
     918            0 :     editor.transformApply()
     919            0 :     toolActive = false
     920              :   }
     921              : 
     922            0 :   function onPointerUp(e: PointerEvent): void {
     923            0 :     if (moveRaf != null) {
     924            0 :       cancelAnimationFrame(moveRaf)
     925            0 :       flushMove()
     926              :     }
     927            0 :     if (panning.value) {
     928            0 :       panning.value = false
     929            0 :     } else if (toolActive) {
     930            0 :       endToolGesture(e)
     931              :     }
     932            0 :     try {
     933            0 :       viewportEl?.releasePointerCapture(e.pointerId)
     934              :     } catch {
     935              :       void 0
     936              :     }
     937              :   }
     938              : 
     939            2 :   function onPointerLeave(e: PointerEvent): void {
     940            2 :     if (toolActive) endToolGesture(e)
     941              :   }
     942              : 
     943            0 :   function onWheel(e: WheelEvent): void {
     944            0 :     panZoom.handleWheel(e)
     945            0 :     requestRender()
     946              :   }
     947              : 
     948            2 :   const viewportCursor = computed(() => {
     949            2 :     if (panning.value) return 'grabbing'
     950            2 :     if (spaceDown.value || pointerMode.value === 'hand') return 'grab'
     951            2 :     return hoverCursor.value
     952              :   })
     953              : 
     954            0 :   function onKeyDown(e: KeyboardEvent): void {
     955            0 :     if (isTextEditingTarget(e.target)) return
     956            0 :     const ctrl = e.ctrlKey || e.metaKey
     957            0 :     if (editor.floating()) {
     958            0 :       if (e.key === 'Enter') {
     959            0 :         e.preventDefault()
     960            0 :         editor.anchorFloating()
     961            0 :         return
     962              :       }
     963              :     }
     964            0 :     if (e.key === 'Enter') {
     965            0 :       e.preventDefault()
     966            0 :       editor.transformApply()
     967            0 :       return
     968              :     }
     969            0 :     if (e.code === 'Space') {
     970            0 :       spaceDown.value = true
     971            0 :       e.preventDefault()
     972            0 :       return
     973              :     }
     974            0 :     if (ctrl && e.code === 'KeyZ') {
     975            0 :       e.preventDefault()
     976            0 :       if (e.shiftKey) redo()
     977            0 :       else undo()
     978            0 :       return
     979              :     }
     980            0 :     if (ctrl && e.code === 'KeyY') {
     981            0 :       e.preventDefault()
     982            0 :       redo()
     983            0 :       return
     984              :     }
     985            0 :     if (ctrl && e.code === 'KeyA') {
     986            0 :       e.preventDefault()
     987            0 :       editor.selectAll()
     988            0 :       return
     989              :     }
     990            0 :     if (ctrl && e.code === 'KeyD') {
     991            0 :       e.preventDefault()
     992            0 :       editor.selectNone()
     993              :     }
     994              :   }
     995              : 
     996            0 :   function onKeyUp(e: KeyboardEvent): void {
     997            0 :     if (e.code === 'Space') spaceDown.value = false
     998              :   }
     999              : 
    1000            0 :   function dispose(): void {
    1001            0 :     disposed = true
    1002            0 :     if (rafId != null) cancelAnimationFrame(rafId)
    1003            0 :     if (overlayRafId != null) cancelAnimationFrame(overlayRafId)
    1004            0 :     if (moveRaf != null) cancelAnimationFrame(moveRaf)
    1005            0 :     rafId = null
    1006            0 :     overlayRafId = null
    1007            0 :     moveRaf = null
    1008            0 :     session.dispose()
    1009              :   }
    1010              : 
    1011            2 :   addBackgroundLayer()
    1012            2 :   editor.history.clear()
    1013              : 
    1014            2 :   return {
    1015              :     editor,
    1016              :     content,
    1017              :     compositor,
    1018              :     panZoom,
    1019              :     version,
    1020              :     glOk,
    1021              :     zoomRatio,
    1022              :     layers,
    1023              :     backgroundLayer,
    1024              :     imageLayers,
    1025              :     activeNodeId,
    1026              :     activeNode,
    1027              :     selectedNodeIds,
    1028              :     selectedContext,
    1029              :     canvasSize,
    1030              :     canUndo,
    1031              :     canRedo,
    1032              :     pointerMode,
    1033              :     viewportCursor,
    1034              :     setElements,
    1035              :     fitView,
    1036              :     setZoom,
    1037              :     requestRender,
    1038              :     loadImages,
    1039              :     setOpacity,
    1040              :     setBlendMode,
    1041              :     toggleVisible,
    1042              :     renameLayer,
    1043              :     moveLayer,
    1044              :     moveLayerTo,
    1045              :     setLayerOrder,
    1046              :     inputLayerIds,
    1047              :     setActiveNode,
    1048              :     setSelectedNodes,
    1049              :     selectBackground,
    1050              :     setBackgroundColor,
    1051              :     setBackgroundOpacity,
    1052              :     setBackgroundVisible,
    1053              :     setPointerMode,
    1054              :     setCanvasSize,
    1055              :     setLayerPosition,
    1056              :     setLayerDimensions,
    1057              :     setLayerRotationDeg,
    1058              :     alignLayer,
    1059              :     flipLayer,
    1060              :     layerFlips,
    1061              :     undo,
    1062              :     redo,
    1063              :     onPointerDown,
    1064              :     onPointerMove,
    1065              :     onPointerUp,
    1066              :     onPointerLeave,
    1067              :     onWheel,
    1068              :     onKeyDown,
    1069              :     onKeyUp,
    1070              :     dispose
    1071              :   }
    1072              : }
        

Generated by: LCOV version 2.0-1