LCOV - code coverage report
Current view: top level - src/utils - eventUtils.ts Coverage Total Hit
Test: ComfyUI E2E Coverage Lines: 76.1 % 46 35
Test Date: 2026-11-17 04:17:53

            Line data    Source code
       1              : import type { MediaKind } from '@/platform/assets/schemas/mediaAssetSchema'
       2              : import { parseAssetInfo } from '@/platform/assets/schemas/mediaAssetSchema'
       3              : import { isHdrImageFilename } from '@/utils/hdrFormatUtil'
       4              : 
       5              : export interface DroppedAsset {
       6              :   name: string
       7              :   uri?: string
       8              :   ref?: string
       9              :   kind?: MediaKind
      10              :   previewUrl?: string
      11              :   mediaUrl?: string
      12              : }
      13              : 
      14            4 : export function getDroppedAsset(
      15              :   dataTransfer: DataTransfer
      16              : ): DroppedAsset | undefined {
      17            4 :   const asset = parseAssetInfo(dataTransfer)
      18            4 :   const name = asset?.display_name ?? asset?.filename
      19            4 :   const validTypes = ['text/uri-list', 'text/x-moz-url']
      20            4 :   const match = [...dataTransfer.types].find((type) =>
      21              :     validTypes.includes(type)
      22              :   )
      23            4 :   const uri = match && dataTransfer.getData(match).split('\n')[0]
      24            4 :   const ref = asset?.attachment_ref
      25              : 
      26            4 :   return uri || ref
      27              :     ? {
      28              :         name: name ?? ref ?? uri!,
      29              :         uri,
      30              :         ref,
      31              :         kind: asset?.media_kind,
      32              :         previewUrl: asset?.preview_url,
      33              :         mediaUrl: asset?.media_url
      34              :       }
      35              :     : undefined
      36              : }
      37              : 
      38            0 : function decodedBasename(pathname: string): string {
      39            0 :   const segment = pathname.split('/').pop() || ''
      40            0 :   try {
      41            0 :     return decodeURIComponent(segment)
      42              :   } catch {
      43            0 :     return segment
      44              :   }
      45              : }
      46              : 
      47            0 : function sourceFileName(
      48              :   { name, ref }: DroppedAsset,
      49              :   uri: string,
      50              :   responseUrl: string
      51              : ): string {
      52            0 :   const resolvedUrl = new URL(responseUrl || uri, 'http://localhost')
      53              :   const named = [
      54              :     resolvedUrl.searchParams.get('filename'),
      55              :     ref,
      56              :     decodedBasename(resolvedUrl.pathname),
      57              :     name
      58              :   ].find((candidate) => candidate && /\.[a-z0-9]{1,8}$/i.test(candidate))
      59            0 :   return named || name
      60              : }
      61              : 
      62              : interface FetchDroppedAssetOptions {
      63              :   signal?: AbortSignal
      64              :   nameFromSource?: boolean
      65              : }
      66              : 
      67            3 : export async function fetchDroppedAsset(
      68              :   asset: DroppedAsset,
      69              :   { signal, nameFromSource = false }: FetchDroppedAssetOptions = {}
      70              : ): Promise<File | undefined> {
      71            3 :   const { name, uri } = asset
      72            3 :   if (!uri) return undefined
      73            3 :   try {
      74            3 :     const response = await fetch(uri, { signal })
      75            3 :     if (!response.ok) return undefined
      76            3 :     const blob = await response.blob()
      77            3 :     const fileName = nameFromSource
      78              :       ? sourceFileName(asset, uri, response.url)
      79              :       : name
      80            3 :     return new File([blob], fileName, { type: blob.type })
      81              :   } catch {
      82            0 :     return undefined
      83              :   }
      84              : }
      85              : 
      86           39 : export async function extractFilesFromDragEvent(
      87              :   event: DragEvent
      88              : ): Promise<File[]> {
      89           39 :   if (!event.dataTransfer) return []
      90              : 
      91              :   // Dragging from Chrome->Firefox there is a file but its a bmp, so ignore that
      92           39 :   const files = Array.from(event.dataTransfer.files)
      93              :     .filter((file) => file.type !== 'image/bmp')
      94              :     .map(withHdrImageType)
      95              : 
      96           39 :   if (files.length > 0) return files
      97              : 
      98            4 :   const asset = getDroppedAsset(event.dataTransfer)
      99            4 :   if (!asset) return []
     100              : 
     101            3 :   const file = await fetchDroppedAsset(asset)
     102           39 :   return file ? [file] : []
     103              : }
     104              : 
     105           73 : export function withHdrImageType(file: File): File {
     106           73 :   if (file.type || !isHdrImageFilename(file.name)) return file
     107           73 :   const type = file.name.toLowerCase().endsWith('.hdr')
     108              :     ? 'image/vnd.radiance'
     109              :     : 'image/x-exr'
     110           73 :   return new File([file], file.name, { type, lastModified: file.lastModified })
     111              : }
     112              : 
     113           38 : export function hasImageType({ type }: File): boolean {
     114           38 :   return type.startsWith('image')
     115              : }
     116              : 
     117           38 : export function hasAudioType({ type }: File): boolean {
     118           38 :   return type.startsWith('audio')
     119              : }
     120              : 
     121           38 : export function hasVideoType({ type }: File): boolean {
     122           38 :   return type.startsWith('video')
     123              : }
     124              : 
     125            0 : export function isMediaFile(file: File): boolean {
     126            0 :   return hasImageType(file) || hasAudioType(file) || hasVideoType(file)
     127              : }
        

Generated by: LCOV version 2.0-1