LCOV - code coverage report
Current view: top level - src/renderer/extensions/maskEditor/composables - useMaskEditorLoader.ts Coverage Total Hit
Test: ComfyUI E2E Coverage Lines: 75.0 % 112 84
Test Date: 2026-11-17 04:17:53

            Line data    Source code
       1              : import { IMAGE_WIDGET } from '@/renderer/extensions/maskEditor/composables/imageWidgetAdapter'
       2              : import { getNodeWidgetValue } from '@/core/graph/widgets/nodeWidgetValues'
       3              : import { useMaskEditorDataStore } from '@/renderer/extensions/maskEditor/stores/maskEditorDataStore'
       4              : import type {
       5              :   ImageRef,
       6              :   LoadedImageLayer
       7              : } from '@/renderer/extensions/maskEditor/stores/maskEditorDataStore'
       8              : import type { LGraphNode } from '@/lib/litegraph/src/litegraph'
       9              : import { useNodeOutputStore } from '@/stores/nodeOutputStore'
      10              : import { isCloud } from '@/platform/distribution/types'
      11              : import { api } from '@/scripts/api'
      12              : import { useApp } from '@/scripts/appInstance'
      13              : import { fullResolutionSrc } from '@/utils/hdrFormatUtil'
      14              : import {
      15              :   extractWidgetStringValue,
      16              :   parseImageWidgetValue
      17              : } from '@/utils/imageUtil'
      18              : 
      19              : import { imageLayerFilenamesIfApplicable } from './layerFilenames'
      20              : 
      21              : interface MaskLayersResponse {
      22              :   painted_masked?: string
      23              :   painted?: string
      24              :   paint?: string
      25              :   mask?: string
      26              : }
      27              : 
      28            2 : function toRef(filename: string, subfolder: string): ImageRef {
      29            2 :   return {
      30              :     filename,
      31              :     subfolder,
      32              :     type: 'input'
      33              :   }
      34              : }
      35              : 
      36           31 : function mkFileUrl(props: { ref: ImageRef; preview?: boolean }): string {
      37           31 :   const params = new URLSearchParams()
      38           31 :   params.set('filename', props.ref.filename)
      39           31 :   if (props.ref.subfolder) {
      40            0 :     params.set('subfolder', props.ref.subfolder)
      41              :   }
      42           31 :   if (props.ref.type) {
      43           31 :     params.set('type', props.ref.type)
      44              :   }
      45              : 
      46           31 :   const pathPlusQueryParams = api.apiURL(
      47              :     '/view?' +
      48              :       params.toString() +
      49              :       useApp().getPreviewFormatParam() +
      50              :       useApp().getRandParam()
      51              :   )
      52           31 :   const imageElement = new Image()
      53           31 :   imageElement.crossOrigin = 'anonymous'
      54           31 :   imageElement.src = pathPlusQueryParams
      55           31 :   return imageElement.src
      56              : }
      57              : 
      58           30 : export function useMaskEditorLoader() {
      59           30 :   const dataStore = useMaskEditorDataStore()
      60           30 :   const nodeOutputStore = useNodeOutputStore()
      61              : 
      62           30 :   const loadFromNode = async (
      63              :     node: LGraphNode,
      64              :     signal?: AbortSignal
      65              :   ): Promise<void> => {
      66           30 :     if (signal?.aborted) return
      67           30 :     dataStore.setLoading(true)
      68              : 
      69           30 :     try {
      70           30 :       validateNode(node)
      71              : 
      72           30 :       let nodeImageUrl = getNodeImageUrl(node)
      73              : 
      74           30 :       let nodeImageRef = parseImageRef(nodeImageUrl)
      75              : 
      76           30 :       const widgetFilename = extractWidgetStringValue(
      77              :         getNodeWidgetValue(node, IMAGE_WIDGET)
      78              :       )
      79              : 
      80           30 :       if (widgetFilename && !widgetFilename.startsWith('$')) {
      81           29 :         const parsed = parseImageWidgetValue(widgetFilename)
      82           29 :         nodeImageRef = {
      83              :           filename: parsed.filename,
      84              :           type: parsed.type || 'input',
      85              :           subfolder: parsed.subfolder || undefined
      86              :         }
      87           29 :         nodeImageUrl = mkFileUrl({ ref: nodeImageRef })
      88              :       }
      89              : 
      90           30 :       const fileToQuery = widgetFilename || nodeImageRef.filename
      91              : 
      92              :       let maskLayersFromApi: MaskLayersResponse | undefined
      93              :       if (isCloud) {
      94              :         try {
      95              :           const response = await api.fetchApi(
      96              :             `/files/mask-layers?filename=${fileToQuery}`
      97              :           )
      98              :           if (response.ok) {
      99              :             maskLayersFromApi = await response.json()
     100              :           }
     101              :         } catch {
     102              :           maskLayersFromApi = undefined
     103              :         }
     104              :       }
     105              : 
     106           30 :       let imageLayerFilenames = imageLayerFilenamesIfApplicable(
     107              :         nodeImageRef.filename
     108              :       )
     109              : 
     110              :       if (maskLayersFromApi) {
     111              :         const baseFile =
     112              :           maskLayersFromApi.painted_masked || maskLayersFromApi.painted
     113              : 
     114              :         if (baseFile) {
     115              :           imageLayerFilenames = {
     116              :             maskedImage: baseFile,
     117              :             paint: maskLayersFromApi.paint || '',
     118              :             paintedImage: maskLayersFromApi.painted || '',
     119              :             paintedMaskedImage: maskLayersFromApi.painted_masked || baseFile
     120              :           }
     121              :         }
     122              :       }
     123              : 
     124           30 :       const layerSubfolder = maskLayersFromApi
     125              :         ? 'clipspace'
     126              :         : (nodeImageRef.subfolder ?? '')
     127              : 
     128           30 :       const layeredBaseUrl = imageLayerFilenames?.maskedImage
     129              :         ? mkFileUrl({
     130              :             ref: toRef(imageLayerFilenames.maskedImage, layerSubfolder)
     131              :           })
     132              :         : undefined
     133           30 :       const baseImageUrl = layeredBaseUrl ?? nodeImageUrl
     134              : 
     135           30 :       let paintLayerUrl: string | null = null
     136              :       if (maskLayersFromApi?.paint) {
     137              :         paintLayerUrl = mkFileUrl({
     138              :           ref: toRef(maskLayersFromApi.paint, layerSubfolder)
     139              :         })
     140           30 :       } else if (imageLayerFilenames?.paint) {
     141            1 :         paintLayerUrl = mkFileUrl({
     142              :           ref: toRef(imageLayerFilenames.paint, layerSubfolder)
     143              :         })
     144              :       }
     145              : 
     146           30 :       const loadLayers = (baseUrl: string, paintUrl: string | null) =>
     147              :         Promise.all([
     148              :           loadImageLayer(baseUrl, 'rgb'),
     149              :           loadImageLayer(baseUrl, 'a'),
     150              :           paintUrl ? loadImageLayer(paintUrl) : Promise.resolve(undefined)
     151              :         ])
     152              : 
     153           30 :       const loadInputData = async () => {
     154           30 :         try {
     155           30 :           const [baseLayer, maskLayer, paintLayer] = await loadLayers(
     156              :             baseImageUrl,
     157              :             paintLayerUrl
     158              :           )
     159           30 :           return {
     160              :             baseLayer,
     161              :             maskLayer,
     162              :             paintLayer,
     163              :             sourceRef: layeredBaseUrl
     164              :               ? parseImageRef(baseImageUrl)
     165              :               : nodeImageRef
     166              :           }
     167              :         } catch (error) {
     168            0 :           if (!layeredBaseUrl) throw error
     169            0 :           console.warn(
     170              :             '[MaskEditorLoader] Failed to load editor layer files, falling back to the node image',
     171              :             error
     172              :           )
     173            0 :           const [baseLayer, maskLayer] = await loadLayers(nodeImageUrl, null)
     174            0 :           return {
     175              :             baseLayer,
     176              :             maskLayer,
     177              :             paintLayer: undefined,
     178              :             sourceRef: nodeImageRef
     179              :           }
     180              :         }
     181              :       }
     182              : 
     183           30 :       const inputData = await loadInputData()
     184           30 :       if (signal?.aborted) return
     185           29 :       dataStore.inputData = { ...inputData, nodeId: node.id }
     186           29 :       dataStore.sourceNode = node
     187           29 :       dataStore.setLoading(false)
     188              :     } catch (error) {
     189            0 :       if (signal?.aborted) return
     190            0 :       const errorMessage =
     191              :         error instanceof Error ? error.message : 'Failed to load from node'
     192            0 :       console.error('[MaskEditorLoader]', errorMessage, error)
     193            0 :       dataStore.setLoading(false, errorMessage)
     194            0 :       throw error
     195              :     }
     196              :   }
     197              : 
     198           30 :   function validateNode(node: LGraphNode): void {
     199              :     const hasImages = node.imgs?.length || node.previewMediaType === 'image'
     200           30 :     if (!hasImages) {
     201            0 :       throw new Error('Node has no images')
     202              :     }
     203              :   }
     204              : 
     205           30 :   function getNodeImageUrl(node: LGraphNode): string {
     206           30 :     const nodeImage = node.images?.[0]
     207           30 :     if (nodeImage?.filename) {
     208           30 :       const params = new URLSearchParams({
     209              :         filename: nodeImage.filename,
     210              :         type: nodeImage.type || 'output',
     211              :         subfolder: nodeImage.subfolder || ''
     212              :       })
     213           30 :       return api.apiURL(`/view?${params.toString()}`)
     214              :     }
     215              : 
     216            0 :     const outputs = nodeOutputStore.getNodeOutputs(node)
     217           30 :     if (outputs?.images?.[0]) {
     218            0 :       const img = outputs.images[0]
     219            0 :       if (!img.filename) {
     220            0 :         throw new Error('nodeOutputStore image missing filename')
     221              :       }
     222              : 
     223            0 :       const params = new URLSearchParams()
     224            0 :       params.set('filename', img.filename)
     225            0 :       params.set('type', img.type || 'output')
     226            0 :       params.set('subfolder', img.subfolder || '')
     227            0 :       return api.apiURL(`/view?${params.toString()}`)
     228              :     }
     229              : 
     230           30 :     if (node.imgs?.length) {
     231            0 :       const index = node.imageIndex ?? 0
     232            0 :       const imgSrc = fullResolutionSrc(node.imgs[index])
     233              : 
     234            0 :       if (imgSrc && !imgSrc.startsWith('data:')) {
     235            0 :         return imgSrc
     236              :       }
     237              :     }
     238              : 
     239            0 :     throw new Error('Unable to get image URL from node')
     240              :   }
     241              : 
     242           31 :   function parseImageRef(url: string): ImageRef {
     243           31 :     try {
     244           31 :       const urlObj = new URL(url)
     245           31 :       const filename = urlObj.searchParams.get('filename')
     246              : 
     247           31 :       if (!filename) {
     248            0 :         throw new Error('Image URL missing filename parameter')
     249              :       }
     250              : 
     251           31 :       return {
     252              :         filename,
     253              :         subfolder: urlObj.searchParams.get('subfolder') || undefined,
     254              :         type: urlObj.searchParams.get('type') || undefined
     255              :       }
     256              :     } catch (error) {
     257           30 :       try {
     258           30 :         const urlObj = new URL(url, window.location.origin)
     259           30 :         const filename = urlObj.searchParams.get('filename')
     260              : 
     261           30 :         if (!filename) {
     262            0 :           throw new Error('Image URL missing filename parameter', {
     263              :             cause: error
     264              :           })
     265              :         }
     266              : 
     267           30 :         return {
     268              :           filename,
     269              :           subfolder: urlObj.searchParams.get('subfolder') || undefined,
     270              :           type: urlObj.searchParams.get('type') || undefined
     271              :         }
     272              :       } catch (e) {
     273            0 :         throw new Error(`Invalid image URL: ${url}`, { cause: e })
     274              :       }
     275              :     }
     276              :   }
     277              : 
     278           61 :   async function loadImageLayer(
     279              :     url: string,
     280              :     channel?: 'rgb' | 'a'
     281              :   ): Promise<LoadedImageLayer> {
     282           61 :     let urlObj: URL
     283           61 :     try {
     284           61 :       urlObj = new URL(url)
     285              :     } catch {
     286            2 :       urlObj = new URL(url, window.location.origin)
     287              :     }
     288              : 
     289           61 :     if (channel) {
     290           60 :       urlObj.searchParams.delete('channel')
     291           60 :       urlObj.searchParams.set('channel', channel)
     292              :     }
     293              : 
     294           61 :     const finalUrl = urlObj.toString()
     295              :     const image = await loadImage(finalUrl)
     296              : 
     297           61 :     return { image, url: finalUrl }
     298              :   }
     299              : 
     300           61 :   function loadImage(url: string): Promise<HTMLImageElement> {
     301           61 :     return new Promise((resolve, reject) => {
     302           61 :       const img = new Image()
     303           61 :       img.crossOrigin = 'anonymous'
     304              : 
     305           61 :       img.onload = () => resolve(img)
     306           61 :       img.onerror = () => reject(new Error(`Failed to load image: ${url}`))
     307              : 
     308           61 :       img.src = url
     309              :     })
     310              :   }
     311              : 
     312           30 :   return {
     313              :     loadFromNode
     314              :   }
     315              : }
        

Generated by: LCOV version 2.0-1