LCOV - code coverage report
Current view: top level - src/renderer/extensions/vueNodes/stores - imagePreviewStore.ts Coverage Total Hit
Test: ComfyUI E2E Coverage Lines: 83.3 % 60 50
Test Date: 2026-11-17 04:17:53

            Line data    Source code
       1              : import { defineStore } from 'pinia'
       2              : import { onScopeDispose } from 'vue'
       3              : 
       4              : import type {
       5              :   DownscaleRequest,
       6              :   DownscaleResponse
       7              : } from '@/renderer/extensions/vueNodes/utils/downscaleImageMessages'
       8              : 
       9              : type DisplayImage = {
      10              :   readonly source: string
      11              : } & Partial<NonNullable<DownscaleResponse['result']>>
      12              : 
      13         2355 : const MAX_CACHED_IMAGES = 128
      14              : 
      15         2355 : export const useImagePreviewStore = defineStore('imagePreview', () => {
      16          128 :   const poolSize = Math.min(4, Math.max(1, navigator.hardwareConcurrency >> 1))
      17          128 :   const cache = new Map<string, Promise<DisplayImage>>()
      18          128 :   const pending = new Map<
      19              :     number,
      20              :     (result: DownscaleResponse['result']) => void
      21              :   >()
      22          128 :   let workers: Worker[] | null | undefined
      23          128 :   let nextId = 0
      24              : 
      25          352 :   function canDownscaleImages(): boolean {
      26          352 :     return (
      27              :       typeof Worker === 'function' &&
      28              :       typeof createImageBitmap === 'function' &&
      29              :       typeof OffscreenCanvas === 'function'
      30              :     )
      31              :   }
      32              : 
      33          246 :   function workerPool(): Worker[] | undefined {
      34          246 :     if (workers !== undefined) return workers ?? undefined
      35          128 :     workers = []
      36          246 :     for (let i = 0; i < poolSize; i++) {
      37          256 :       try {
      38          256 :         const worker = new Worker(
      39              :           new URL('../utils/downscaleImage.worker.ts', import.meta.url),
      40              :           { type: 'module' }
      41              :         )
      42          256 :         workers.push(worker)
      43          256 :         worker.onmessage = (event: MessageEvent<DownscaleResponse>) => {
      44          233 :           pending.get(event.data.id)?.(event.data.result)
      45          233 :           pending.delete(event.data.id)
      46              :         }
      47          256 :         worker.onerror = abandonWorkers
      48              :       } catch {
      49            0 :         abandonWorkers()
      50            0 :         return undefined
      51              :       }
      52              :     }
      53          256 :     return workers
      54              :   }
      55              : 
      56            0 :   function abandonWorkers() {
      57            0 :     workers?.forEach((worker) => worker.terminate())
      58            0 :     workers = null
      59            0 :     for (const resolve of pending.values()) resolve(undefined)
      60            0 :     pending.clear()
      61              :   }
      62              : 
      63          246 :   async function requestDownscale(
      64              :     source: string,
      65              :     maxEdge: number
      66              :   ): Promise<DownscaleResponse['result']> {
      67          246 :     const id = nextId++
      68          246 :     const pool = workerPool()
      69          246 :     if (!pool) return undefined
      70          246 :     const request: DownscaleRequest = {
      71              :       id,
      72              :       source: new URL(source, location.href).href,
      73              :       maxEdge
      74              :     }
      75          246 :     return new Promise((resolve) => {
      76          246 :       pending.set(id, resolve)
      77          246 :       pool[id % pool.length].postMessage(request)
      78              :     })
      79              :   }
      80              : 
      81          352 :   async function getDisplayImage(
      82              :     source: string,
      83              :     maxEdge: number
      84              :   ): Promise<DisplayImage> {
      85          352 :     const original = { source }
      86          352 :     if (!canDownscaleImages() || source.startsWith('blob:')) return original
      87          352 :     const key = `${maxEdge}:${source}`
      88          352 :     const cached = cache.get(key)
      89          352 :     if (cached) {
      90          106 :       cache.delete(key)
      91          106 :       cache.set(key, cached)
      92          106 :       return cached
      93              :     }
      94          246 :     const entry = requestDownscale(source, maxEdge)
      95              :       .catch(() => undefined)
      96              :       .then((result) => {
      97          233 :         if (result) return { source, ...result }
      98           37 :         if (cache.get(key) === entry) cache.delete(key)
      99           37 :         return original
     100              :       })
     101          246 :     cache.set(key, entry)
     102          246 :     evictOldest()
     103          246 :     return entry
     104              :   }
     105              : 
     106          246 :   function evictOldest() {
     107          246 :     for (const key of cache.keys()) {
     108          246 :       if (cache.size <= MAX_CACHED_IMAGES) return
     109            0 :       cache.delete(key)
     110              :     }
     111              :   }
     112              : 
     113          128 :   onScopeDispose(() => {
     114            0 :     abandonWorkers()
     115            0 :     cache.clear()
     116              :   })
     117              : 
     118          128 :   return { getDisplayImage }
     119              : })
        

Generated by: LCOV version 2.0-1