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 : }
|