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