LCOV - code coverage report
Current view: top level - src/platform/assets/composables - useAssetBrowser.ts Coverage Total Hit
Test: ComfyUI E2E Coverage Lines: 59.7 % 62 37
Test Date: 2026-11-17 04:17:53

            Line data    Source code
       1              : import { computed, ref } from 'vue'
       2              : import type { Ref } from 'vue'
       3              : import { useFuse } from '@vueuse/integrations/useFuse'
       4              : import type { UseFuseOptions } from '@vueuse/integrations/useFuse'
       5              : import { storeToRefs } from 'pinia'
       6              : 
       7              : import { t } from '@/i18n'
       8              : import type {
       9              :   AssetFilterState,
      10              :   OwnershipOption
      11              : } from '@/platform/assets/types/filterTypes'
      12              : import type {
      13              :   AssetItem,
      14              :   ModelBrowserAsset
      15              : } from '@/platform/assets/schemas/assetSchema'
      16              : import { useAssetFilterOptions } from '@/platform/assets/composables/useAssetFilterOptions'
      17              : import {
      18              :   filterByBaseModels,
      19              :   filterByCategory,
      20              :   filterByFileFormats,
      21              :   filterByOwnership
      22              : } from '@/platform/assets/utils/assetFilterUtils'
      23              : import {
      24              :   getAssetBaseModels,
      25              :   getAssetCategories,
      26              :   getAssetFilename,
      27              :   getAssetTypeBadges
      28              : } from '@/platform/assets/utils/assetMetadataUtils'
      29              : import { MODELS_TAG } from '@/platform/assets/services/assetService'
      30              : import { sortAssets } from '@/platform/assets/utils/assetSortUtils'
      31              : import { useFeatureFlags } from '@/composables/useFeatureFlags'
      32              : import { useAssetDownloadStore } from '@/stores/assetDownloadStore'
      33              : import type {
      34              :   NavGroupData,
      35              :   NavItemData
      36              : } from '@comfyorg/design-system/lib/navigation/types'
      37              : 
      38              : type NavId = 'all' | 'imported' | (string & {})
      39              : 
      40              : type AssetBadge = {
      41              :   label: string
      42              :   type: 'type' | 'base' | 'size'
      43              : }
      44              : 
      45              : export interface AssetDisplayItem extends ModelBrowserAsset {
      46              :   secondaryText: string
      47              :   badges: AssetBadge[]
      48              :   stats: {
      49              :     downloadCount?: string
      50              :     stars?: string
      51              :   }
      52              : }
      53              : 
      54         2355 : const displayItemCache = new WeakMap<
      55              :   AssetItem,
      56              :   { modelTypeMode: boolean; item: AssetDisplayItem }
      57              : >()
      58              : 
      59            0 : function buildDisplayItem(
      60              :   asset: ModelBrowserAsset,
      61              :   modelTypeMode: boolean
      62              : ): AssetDisplayItem {
      63            0 :   const badges: AssetBadge[] = []
      64              : 
      65            0 :   for (const typeBadge of getAssetTypeBadges(asset, modelTypeMode)) {
      66            0 :     badges.push({ label: typeBadge, type: 'type' })
      67              :   }
      68              : 
      69            0 :   for (const model of getAssetBaseModels(asset)) {
      70            0 :     badges.push({ label: model, type: 'base' })
      71              :   }
      72              : 
      73            0 :   return {
      74              :     ...asset,
      75              :     secondaryText: getAssetFilename(asset),
      76              :     badges,
      77              :     stats: {
      78              :       downloadCount: undefined,
      79              :       stars: undefined
      80              :     }
      81              :   }
      82              : }
      83              : 
      84            0 : function transformAssetForDisplay(
      85              :   asset: ModelBrowserAsset,
      86              :   modelTypeMode: boolean
      87              : ): AssetDisplayItem {
      88            0 :   const cached = displayItemCache.get(asset)
      89            0 :   if (cached && cached.modelTypeMode === modelTypeMode) return cached.item
      90            0 :   const item = buildDisplayItem(asset, modelTypeMode)
      91            0 :   displayItemCache.set(asset, { modelTypeMode, item })
      92            0 :   return item
      93              : }
      94              : 
      95              : /**
      96              :  * Asset Browser composable
      97              :  * Manages search, filtering, asset transformation and selection logic
      98              :  */
      99            1 : export function useAssetBrowser(
     100              :   assetsSource: Ref<ModelBrowserAsset[] | undefined> = ref<
     101              :     ModelBrowserAsset[] | undefined
     102              :   >([])
     103              : ) {
     104            1 :   const assets = computed<ModelBrowserAsset[]>(() => assetsSource.value ?? [])
     105            1 :   const assetDownloadStore = useAssetDownloadStore()
     106            1 :   const { sessionDownloadCount } = storeToRefs(assetDownloadStore)
     107            1 :   const { flags } = useFeatureFlags()
     108              : 
     109            1 :   const searchQuery = ref('')
     110            1 :   const selectedNavItem = ref<NavId>('all')
     111            1 :   const filters = ref<AssetFilterState>({
     112              :     sortBy: 'recent',
     113              :     fileFormats: [],
     114              :     baseModels: [],
     115              :     ownership: 'all'
     116              :   })
     117              : 
     118            1 :   const selectedOwnership = computed<OwnershipOption>(() => {
     119            2 :     if (typeCategories.value.length <= 1) return filters.value.ownership
     120            0 :     if (selectedNavItem.value === 'imported') return 'my-models'
     121            0 :     if (selectedNavItem.value === 'all') return 'all'
     122            0 :     return filters.value.ownership
     123              :   })
     124              : 
     125            1 :   const selectedCategory = computed(() => {
     126            1 :     if (
     127              :       selectedNavItem.value === 'all' ||
     128              :       selectedNavItem.value === 'imported'
     129              :     ) {
     130            1 :       return 'all'
     131              :     }
     132            0 :     return selectedNavItem.value
     133              :   })
     134              : 
     135            1 :   const typeCategories = computed<NavItemData[]>(() => {
     136            2 :     const modelTypeMode = flags.supportsModelTypeTags
     137            2 :     const categories = assets.value
     138              :       .filter((asset) => asset.tags.includes(MODELS_TAG))
     139              :       .flatMap((asset) => getAssetCategories(asset, modelTypeMode))
     140              : 
     141            2 :     return Array.from(new Set(categories))
     142              :       .sort()
     143              :       .map((category) => ({
     144              :         id: category,
     145              :         label: category.charAt(0).toUpperCase() + category.slice(1),
     146              :         icon: 'icon-[lucide--folder]'
     147              :       }))
     148              :   })
     149              : 
     150            1 :   const navItems = computed<(NavItemData | NavGroupData)[]>(() => {
     151            2 :     const quickFilters: NavItemData[] = [
     152              :       {
     153              :         id: 'all',
     154              :         label: t('assetBrowser.allModels'),
     155              :         icon: 'icon-[lucide--list]'
     156              :       },
     157              :       {
     158              :         id: 'imported',
     159              :         label: t('assetBrowser.imported'),
     160              :         icon: 'icon-[lucide--folder-input]',
     161              :         badge:
     162              :           sessionDownloadCount.value > 0
     163              :             ? sessionDownloadCount.value
     164              :             : undefined
     165              :       }
     166              :     ]
     167              : 
     168            2 :     if (typeCategories.value.length === 0) {
     169            2 :       return quickFilters
     170              :     }
     171              : 
     172            0 :     return [
     173              :       ...quickFilters,
     174              :       {
     175              :         title: t('assetBrowser.byType'),
     176              :         items: typeCategories.value,
     177              :         collapsible: false
     178              :       }
     179              :     ]
     180              :   })
     181              : 
     182            1 :   const isImportedSelected = computed(
     183              :     () => selectedNavItem.value === 'imported'
     184              :   )
     185              : 
     186            1 :   const contentTitle = computed(() => {
     187            0 :     if (selectedNavItem.value === 'all') {
     188            0 :       return t('assetBrowser.allModels')
     189              :     }
     190            0 :     if (selectedNavItem.value === 'imported') {
     191            0 :       return t('assetBrowser.imported')
     192              :     }
     193              : 
     194              :     const category = typeCategories.value.find(
     195              :       (cat) => cat.id === selectedNavItem.value
     196              :     )
     197            0 :     return category?.label || t('assetBrowser.assets')
     198              :   })
     199              : 
     200            1 :   const categoryFilteredAssets = computed(() => {
     201            2 :     return assets.value.filter(
     202              :       filterByCategory(selectedCategory.value, flags.supportsModelTypeTags)
     203              :     )
     204              :   })
     205              : 
     206            1 :   const { availableFileFormats, availableBaseModels } = useAssetFilterOptions(
     207              :     categoryFilteredAssets
     208              :   )
     209              : 
     210            1 :   const activeFileFormats = computed(() =>
     211              :     filters.value.fileFormats.filter((f) =>
     212              :       availableFileFormats.value.some((opt) => opt.value === f)
     213              :     )
     214              :   )
     215              : 
     216            1 :   const activeBaseModels = computed(() =>
     217              :     filters.value.baseModels.filter((m) =>
     218              :       availableBaseModels.value.some((opt) => opt.value === m)
     219              :     )
     220              :   )
     221              : 
     222              :   const fuseOptions: UseFuseOptions<AssetItem> = {
     223              :     fuseOptions: {
     224              :       keys: [
     225              :         { name: 'name', weight: 0.4 },
     226              :         { name: 'tags', weight: 0.3 },
     227              :         { name: 'user_metadata.name', weight: 0.4 },
     228              :         { name: 'user_metadata.additional_tags', weight: 0.3 },
     229              :         { name: 'user_metadata.trained_words', weight: 0.3 },
     230              :         { name: 'user_metadata.user_description', weight: 0.3 },
     231              :         { name: 'metadata.name', weight: 0.4 },
     232              :         { name: 'metadata.trained_words', weight: 0.3 }
     233              :       ],
     234              :       threshold: 0.4, // Higher threshold for typo tolerance (0.0 = exact, 1.0 = match all)
     235              :       ignoreLocation: true, // Search anywhere in the string, not just at the beginning
     236              :       includeScore: true
     237              :     },
     238              :     matchAllWhenSearchEmpty: true
     239              :   }
     240              : 
     241            1 :   const { results: fuseResults } = useFuse(
     242              :     searchQuery,
     243              :     categoryFilteredAssets,
     244              :     fuseOptions
     245              :   )
     246              : 
     247            1 :   const searchFiltered = computed(() =>
     248              :     fuseResults.value.map((result) => result.item)
     249              :   )
     250              : 
     251            1 :   const filteredAssets = computed(() => {
     252            2 :     const filtered = searchFiltered.value
     253              :       .filter(filterByFileFormats(activeFileFormats.value))
     254              :       .filter(filterByBaseModels(activeBaseModels.value))
     255              :       .filter(filterByOwnership(selectedOwnership.value))
     256              : 
     257            2 :     const sortedAssets = sortAssets(filtered, filters.value.sortBy)
     258              : 
     259            2 :     const modelTypeMode = flags.supportsModelTypeTags
     260            2 :     return sortedAssets.map((asset) =>
     261              :       transformAssetForDisplay(asset, modelTypeMode)
     262              :     )
     263              :   })
     264              : 
     265            0 :   function updateFilters(newFilters: AssetFilterState) {
     266            0 :     filters.value = { ...newFilters }
     267              :   }
     268              : 
     269            1 :   return {
     270              :     searchQuery,
     271              :     selectedNavItem,
     272              :     selectedCategory,
     273              :     navItems,
     274              :     contentTitle,
     275              :     categoryFilteredAssets,
     276              :     filteredAssets,
     277              :     isImportedSelected,
     278              :     updateFilters
     279              :   }
     280              : }
        

Generated by: LCOV version 2.0-1