LCOV - code coverage report
Current view: top level - src/renderer/extensions/vueNodes/widgets/composables - useWidgetSelectItems.ts Coverage Total Hit
Test: ComfyUI E2E Coverage Lines: 86.6 % 82 71
Test Date: 2026-11-17 04:17:53

            Line data    Source code
       1              : import { capitalize } from 'es-toolkit'
       2              : import { computed, toValue } from 'vue'
       3              : import type { MaybeRefOrGetter } from 'vue'
       4              : 
       5              : import { t } from '@/i18n'
       6              : import { appendCloudResParam } from '@/platform/distribution/cloudPreviewUtil'
       7              : import { useAssetFilterOptions } from '@/platform/assets/composables/useAssetFilterOptions'
       8              : import { useMissingMediaStore } from '@/platform/workflowErrors/missingMedia/missingMediaStore'
       9              : import { isGeneratedTempOutput } from '@/platform/assets/composables/media/assetMappers'
      10              : import {
      11              :   filterItemByBaseModels,
      12              :   filterItemByOwnership
      13              : } from '@/platform/assets/utils/assetFilterUtils'
      14              : import {
      15              :   getAssetBaseModels,
      16              :   getAssetDisplayName,
      17              :   getAssetFilename,
      18              :   getAssetUrlFilename,
      19              :   getOutputSubfolder
      20              : } from '@/platform/assets/utils/assetMetadataUtils'
      21              : import type {
      22              :   FilterOption,
      23              :   OwnershipOption
      24              : } from '@/platform/assets/types/filterTypes'
      25              : import type { FormDropdownItem } from '@/renderer/extensions/vueNodes/widgets/components/form/dropdown/types'
      26              : import type { useAssetWidgetData } from '@/renderer/extensions/vueNodes/widgets/composables/useAssetWidgetData'
      27              : import type { AssetItem } from '@/platform/assets/schemas/assetSchema'
      28              : import { useAssetsStore } from '@/stores/assetsStore'
      29              : import type { AssetKind } from '@/types/widgetTypes'
      30              : import {
      31              :   createAnnotatedPath,
      32              :   parseAnnotatedPath
      33              : } from '@/utils/createAnnotatedPath'
      34              : import { getMediaTypeFromFilename } from '@/utils/formatUtil'
      35              : import {
      36              :   hdrPreviewAssetUrl,
      37              :   isHdrImageFilename,
      38              :   isHdrImageUrl
      39              : } from '@/utils/hdrFormatUtil'
      40              : import { parseImageWidgetValue } from '@/utils/imageUtil'
      41              : import { pagedItems, WrappedList } from '@/utils/pagedList'
      42              : import type { MaybePaged } from '@/utils/pagedList'
      43              : 
      44           94 : function getDisplayLabel(value: string, getLabel?: (v: string) => string) {
      45           94 :   try {
      46           94 :     return getLabel?.(value) || value
      47              :   } catch (e) {
      48            0 :     console.warn('Failed to map value:', e)
      49            0 :     return value
      50              :   }
      51              : }
      52              : 
      53           94 : function getMediaUrl(
      54              :   filename: string,
      55              :   type: string,
      56              :   assetKind: AssetKind | undefined,
      57              :   subfolder?: string
      58              : ): string {
      59           94 :   if (!['image', 'video', 'audio'].includes(assetKind ?? '')) return ''
      60           78 :   const params = new URLSearchParams({ filename, type })
      61           78 :   if (subfolder) params.set('subfolder', subfolder)
      62           78 :   appendCloudResParam(params, filename)
      63           78 :   return `/api/view?${params}`
      64              : }
      65         1896 : function assetRoot(asset: AssetItem): 'input' | 'output' | 'temp' | undefined {
      66         1896 :   if (isGeneratedTempOutput(asset)) return 'temp'
      67         1456 :   for (const testTag of ['input', 'output', 'temp'] as const) {
      68         1410 :     if (asset.tags.includes(testTag)) return testTag
      69              :   }
      70              : }
      71              : 
      72           94 : function getAnnotatedValueMediaUrl(
      73              :   value: string,
      74              :   assetKind: AssetKind | undefined
      75              : ): string {
      76           94 :   const { filepath } = parseAnnotatedPath(value)
      77           94 :   if (
      78              :     /^[^\\/]:/.test(filepath) ||
      79              :     filepath
      80              :       .split(/[\\/]/)
      81              :       .some((part) => part === '' || part === '.' || part === '..')
      82              :   )
      83            0 :     return ''
      84           94 :   const { filename, subfolder, type } = parseImageWidgetValue(value)
      85           94 :   return getMediaUrl(filename, type, assetKind, subfolder)
      86              : }
      87              : 
      88              : export interface UseWidgetSelectItemsOptions {
      89              :   getOptionLabel: MaybeRefOrGetter<((value: string) => string) | undefined>
      90              :   modelValue: MaybeRefOrGetter<string | undefined>
      91              :   assetKind: MaybeRefOrGetter<AssetKind | undefined>
      92              :   assetData: ReturnType<typeof useAssetWidgetData> | null
      93              :   isAssetMode: MaybeRefOrGetter<boolean>
      94              :   filterSelected: MaybeRefOrGetter<string>
      95              :   ownershipSelected: MaybeRefOrGetter<OwnershipOption>
      96              :   baseModelSelected: MaybeRefOrGetter<Set<string>>
      97              : }
      98              : 
      99          197 : export function useWidgetSelectItems(options: UseWidgetSelectItemsOptions) {
     100          197 :   const { modelValue, assetData } = options
     101              : 
     102          197 :   const missingMediaStore = useMissingMediaStore()
     103          197 :   const missingMediaValues = computed<ReadonlySet<string>>(
     104              :     () =>
     105              :       new Set(
     106              :         missingMediaStore.missingMediaCandidates?.map((c) => c.name) ?? []
     107              :       )
     108              :   )
     109              : 
     110          197 :   const filterOptions = computed<FilterOption[]>(() => {
     111          197 :     if (toValue(options.isAssetMode)) {
     112            0 :       const categoryName = assetData?.category.value ?? 'All'
     113            0 :       return [{ name: capitalize(categoryName), value: 'all' }]
     114              :     }
     115          197 :     return [
     116              :       { name: t('g.all'), value: 'all' },
     117              :       { name: t('sideToolbar.labels.imported'), value: 'inputs' },
     118              :       { name: t('sideToolbar.labels.generated'), value: 'outputs' }
     119              :     ]
     120              :   })
     121              : 
     122          197 :   const { ownershipOptions, availableBaseModels } = useAssetFilterOptions(
     123              :     () => assetData?.assets.value ?? []
     124              :   )
     125              : 
     126          197 :   const baseModelOptions = computed<FilterOption[]>(() => {
     127          197 :     if (!toValue(options.isAssetMode) || !assetData) return []
     128            0 :     return availableBaseModels.value
     129              :   })
     130              : 
     131          197 :   const baseAssets = computed(() => {
     132          198 :     const assetsStore = useAssetsStore()
     133          198 :     switch (toValue(options.filterSelected)) {
     134              :       case 'inputs':
     135            0 :         return assetsStore.inputAssets
     136              :       case 'outputs':
     137            1 :         return assetsStore.flatOutputAssets
     138              :       default:
     139          197 :         return assetsStore.allAssets
     140              :     }
     141              :   })
     142              : 
     143          197 :   const missingValueItem = computed<FormDropdownItem | undefined>(() => {
     144          592 :     const currentValue = toValue(modelValue)
     145          592 :     if (!currentValue) return undefined
     146          560 :     const labelFn = toValue(options.getOptionLabel)
     147          560 :     const kind = toValue(options.assetKind)
     148              : 
     149          583 :     if (missingMediaValues.value.has(currentValue)) return undefined
     150          569 :     if (availableItems.value.some((item) => item.name === currentValue))
     151          430 :       return undefined
     152              : 
     153          592 :     return {
     154              :       id: `missing-${currentValue}`,
     155              :       preview_url:
     156              :         toValue(options.isAssetMode) && assetData
     157              :           ? ''
     158              :           : getAnnotatedValueMediaUrl(currentValue, kind),
     159              :       name: currentValue,
     160              :       label: getDisplayLabel(currentValue, labelFn)
     161              :     }
     162              :   })
     163              : 
     164         1896 :   function itemNameFor(asset: AssetItem): string {
     165         1896 :     if (toValue(options.isAssetMode))
     166            0 :       return asset.loader_path ?? getAssetFilename(asset)
     167         1896 :     const filenameForUrl = getAssetUrlFilename(asset)
     168         1896 :     const subfolder = getOutputSubfolder(asset)
     169         1896 :     const name = subfolder ? `${subfolder}/${filenameForUrl}` : filenameForUrl
     170         1896 :     return createAnnotatedPath(name, { rootFolder: assetRoot(asset) })
     171              :   }
     172              : 
     173         1896 :   function assetToForm(asset: AssetItem): FormDropdownItem {
     174         1896 :     const name = itemNameFor(asset)
     175         1896 :     const kind = toValue(options.assetKind)
     176         1896 :     return {
     177              :       id: asset.id,
     178              :       name,
     179              :       label: getAssetDisplayName(asset),
     180              :       preview_url:
     181              :         kind === 'mesh'
     182              :           ? ''
     183              :           : isHdrImageFilename(asset.name)
     184              :             ? asset.preview_id
     185              :               ? hdrPreviewAssetUrl(asset.preview_id)
     186              :               : ([asset.thumbnail_url, asset.preview_url].find(
     187              :                   (url) => url && !isHdrImageUrl(url)
     188              :                 ) ?? '')
     189              :             : asset.preview_url || getAnnotatedValueMediaUrl(name, kind),
     190              :       is_immutable: asset.is_immutable,
     191              :       base_models: getAssetBaseModels(asset)
     192              :     }
     193              :   }
     194          197 :   const assetItems = computed<FormDropdownItem[]>(() => {
     195            0 :     if (!toValue(options.isAssetMode) || !assetData) return []
     196            0 :     return assetData.assets.value.map(assetToForm)
     197              :   })
     198              : 
     199          197 :   const filteredAssetItems = computed<FormDropdownItem[]>(() =>
     200              :     filterItemByBaseModels(
     201              :       filterItemByOwnership(
     202              :         assetItems.value,
     203              :         toValue(options.ownershipSelected)
     204              :       ),
     205              :       toValue(options.baseModelSelected)
     206              :     )
     207              :   )
     208              : 
     209          197 :   const availableItems = computed<FormDropdownItem[]>(() => {
     210          480 :     if (toValue(options.isAssetMode) && assetData) {
     211            0 :       return filteredAssetItems.value.filter(
     212              :         (item) => !missingMediaValues.value.has(item.name)
     213              :       )
     214              :     }
     215          480 :     const targetKind = toValue(options.assetKind)
     216          480 :     const targetMediaType = targetKind === 'mesh' ? '3D' : targetKind
     217          480 :     const kindFilter = (asset: AssetItem) =>
     218              :       asset.metadata?.kind === targetKind ||
     219              :       (targetKind === 'image' && isHdrImageFilename(asset.name)) ||
     220              :       getMediaTypeFromFilename(asset.name) === targetMediaType
     221              : 
     222          480 :     return pagedItems(baseAssets.value)
     223              :       .filter(kindFilter)
     224              :       .map(assetToForm)
     225              :       .filter((item) => !missingMediaValues.value.has(item.name))
     226              :   })
     227              : 
     228          197 :   const dropdownItems = computed<MaybePaged<FormDropdownItem>>(() => {
     229          534 :     const missingItem = missingValueItem.value
     230          534 :     const mapped = missingItem
     231              :       ? [missingItem, ...availableItems.value]
     232              :       : availableItems.value
     233          534 :     if (toValue(options.isAssetMode) && assetData) return mapped
     234          534 :     const base = baseAssets.value
     235          534 :     return new WrappedList(base, () => mapped)
     236              :   })
     237              : 
     238              :   const selectedSet = computed<Set<string>>(() => {
     239          560 :     const currentValue = toValue(modelValue)
     240          560 :     if (currentValue === undefined) return new Set()
     241              : 
     242          559 :     const item = pagedItems(dropdownItems.value).find(
     243              :       (item) => item.name === currentValue
     244              :     )
     245          560 :     return item ? new Set([item.id]) : new Set()
     246              :   })
     247              : 
     248          197 :   return {
     249              :     dropdownItems,
     250              :     filterOptions,
     251              :     ownershipOptions,
     252              :     baseModelOptions,
     253              :     selectedSet
     254              :   }
     255              : }
        

Generated by: LCOV version 2.0-1