LCOV - code coverage report
Current view: top level - src/platform/keybindings - presetService.ts Coverage Total Hit
Test: ComfyUI E2E Coverage Lines: 82.4 % 102 84
Test Date: 2026-11-17 04:17:53

            Line data    Source code
       1              : import { toRaw } from 'vue'
       2              : import { fromZodError } from 'zod-validation-error'
       3              : 
       4              : import { downloadBlob } from '@/base/common/downloadUtil'
       5              : import { useErrorHandling } from '@/composables/useErrorHandling'
       6              : import { t } from '@/i18n'
       7              : import UnsavedChangesContent from '@/platform/keybindings/components/UnsavedChangesContent.vue'
       8              : import UnsavedChangesHeader from '@/platform/keybindings/components/UnsavedChangesHeader.vue'
       9              : import { useSettingStore } from '@/platform/settings/settingStore'
      10              : import { useToast } from '@/components/ui/toast/toastStore'
      11              : import { api } from '@/scripts/api'
      12              : import { uploadFile } from '@/scripts/utils'
      13              : import { useDialogService } from '@/services/dialogService'
      14              : import { useDialogStore } from '@/stores/dialogStore'
      15              : 
      16              : import { KeybindingImpl } from '@comfyorg/keybindings/keybinding'
      17              : import { useKeybindingService } from './keybindingService'
      18              : import { useKeybindingStore } from '@comfyorg/keybindings/keybindingStore'
      19              : import type { KeybindingPreset } from '@comfyorg/keybindings/types'
      20              : import { zKeybindingPreset } from '@comfyorg/keybindings/types'
      21              : 
      22           38 : const PRESETS_DIR = 'keybindings'
      23              : 
      24           11 : function presetFilePath(name: string): string {
      25           11 :   const trimmed = name.trim()
      26           11 :   if (
      27              :     !trimmed ||
      28              :     trimmed === 'default' ||
      29              :     trimmed.toLowerCase().endsWith('.json') ||
      30              :     trimmed.includes('/') ||
      31              :     trimmed.includes('\\') ||
      32              :     trimmed.includes('..') ||
      33              :     trimmed.startsWith('.')
      34              :   ) {
      35            0 :     throw new Error(t('g.keybindingPresets.invalidPresetName'))
      36              :   }
      37           11 :   return `${PRESETS_DIR}/${trimmed}.json`
      38              : }
      39              : 
      40            6 : function buildPresetFromStore(
      41              :   name: string,
      42              :   keybindingStore: ReturnType<typeof useKeybindingStore>
      43              : ): KeybindingPreset {
      44              :   const newBindings = toRaw(keybindingStore.getUserKeybindingValues())
      45              :   const unsetBindings = toRaw(keybindingStore.getUserUnsetKeybindingValues())
      46            6 :   return { name, newBindings, unsetBindings }
      47              : }
      48              : 
      49           78 : export function useKeybindingPresetService() {
      50           78 :   const keybindingStore = useKeybindingStore()
      51           78 :   const keybindingService = useKeybindingService()
      52           78 :   const settingStore = useSettingStore()
      53           78 :   const dialogService = useDialogService()
      54           78 :   const dialogStore = useDialogStore()
      55           78 :   const toast = useToast()
      56           78 :   const { wrapWithErrorHandlingAsync } = useErrorHandling()
      57              : 
      58            2 :   async function switchToDefaultPreset({ resetBindings = true } = {}) {
      59            2 :     if (resetBindings) keybindingStore.resetAllKeybindings()
      60            2 :     keybindingStore.currentPresetName = 'default'
      61            2 :     keybindingStore.savedPresetData = null
      62            2 :     await keybindingService.persistUserKeybindings()
      63            2 :     await settingStore.set('Comfy.Keybinding.CurrentPreset', 'default')
      64              :   }
      65              : 
      66           78 :   const UNSAVED_DIALOG_KEY = 'unsaved-keybinding-changes'
      67              : 
      68            0 :   function showUnsavedChangesDialog(
      69              :     presetName: string
      70              :   ): Promise<boolean | null> {
      71            0 :     return new Promise((resolve) => {
      72            0 :       dialogService.showSmallLayoutDialog({
      73              :         key: UNSAVED_DIALOG_KEY,
      74              :         headerComponent: UnsavedChangesHeader,
      75              :         headerProps: { presetName },
      76              :         component: UnsavedChangesContent,
      77              :         props: {
      78              :           onResult: (result: boolean | null) => {
      79            0 :             resolve(result)
      80            0 :             dialogStore.closeDialog({ key: UNSAVED_DIALOG_KEY })
      81              :           }
      82              :         },
      83              :         dialogComponentProps: {
      84              :           onClose: () => resolve(null)
      85              :         }
      86              :       })
      87              :     })
      88              :   }
      89              : 
      90           47 :   async function listPresets(): Promise<string[]> {
      91              :     const files = await api.listUserDataFullInfo(PRESETS_DIR)
      92           47 :     return files
      93              :       .map((f) => f.path.replace(/\.json$/, ''))
      94              :       .filter((name) => name.length > 0)
      95              :   }
      96              : 
      97            5 :   async function loadPreset(name: string): Promise<KeybindingPreset> {
      98            5 :     const resp = await api.getUserData(presetFilePath(name))
      99            5 :     if (!resp.ok) {
     100            0 :       throw new Error(t('g.keybindingPresets.loadPresetFailed', { name }))
     101              :     }
     102            5 :     const data = await resp.json()
     103            5 :     const result = zKeybindingPreset.safeParse(data)
     104            5 :     if (!result.success) {
     105            0 :       throw new Error(
     106              :         t('g.keybindingPresets.invalidPresetFile') +
     107              :           ': ' +
     108              :           fromZodError(result.error).message
     109              :       )
     110              :     }
     111            5 :     return { ...result.data, name }
     112              :   }
     113              : 
     114            4 :   function applyPreset(preset: KeybindingPreset) {
     115            4 :     keybindingStore.resetAllKeybindings()
     116            4 :     for (const binding of preset.unsetBindings) {
     117            4 :       keybindingStore.addUserUnsetKeybinding(new KeybindingImpl(binding))
     118              :     }
     119            4 :     for (const binding of preset.newBindings) {
     120            4 :       keybindingStore.addUserKeybinding(new KeybindingImpl(binding))
     121              :     }
     122              :     // Snapshot savedPresetData from the store's actual state after applying,
     123              :     // because addUserKeybinding may auto-unset conflicting defaults beyond
     124              :     // what the raw preset specifies.
     125            4 :     keybindingStore.savedPresetData = buildPresetFromStore(
     126              :       preset.name,
     127              :       keybindingStore
     128              :     )
     129            4 :     keybindingStore.currentPresetName = preset.name
     130              :   }
     131              : 
     132            1 :   async function savePreset(name: string) {
     133            1 :     const preset = buildPresetFromStore(name, keybindingStore)
     134            1 :     await api.storeUserData(presetFilePath(name), JSON.stringify(preset), {
     135              :       overwrite: true,
     136              :       stringify: false
     137              :     })
     138            1 :     keybindingStore.savedPresetData = preset
     139            1 :     keybindingStore.currentPresetName = name
     140            1 :     await keybindingService.persistUserKeybindings()
     141            1 :     await settingStore.set('Comfy.Keybinding.CurrentPreset', name)
     142            1 :     toast.success(t('g.keybindingPresets.presetSaved', { name }), {
     143              :       duration: 3000
     144              :     })
     145              :   }
     146              : 
     147            1 :   async function deletePreset(name: string) {
     148              :     const confirmed = await dialogService.confirm({
     149              :       title: t('g.keybindingPresets.deletePresetTitle'),
     150              :       message: t('g.keybindingPresets.deletePresetWarning'),
     151              :       type: 'delete'
     152              :     })
     153            1 :     if (!confirmed) return
     154              : 
     155              :     const resp = await api.deleteUserData(presetFilePath(name))
     156            1 :     if (!resp.ok) {
     157            0 :       throw new Error(t('g.keybindingPresets.deletePresetFailed', { name }))
     158              :     }
     159              : 
     160            1 :     if (keybindingStore.currentPresetName === name) {
     161            1 :       await switchToDefaultPreset()
     162              :     }
     163              : 
     164            1 :     toast.info(t('g.keybindingPresets.presetDeleted', { name }), {
     165              :       duration: 3000
     166              :     })
     167              :   }
     168              : 
     169            1 :   function exportPreset() {
     170            1 :     const preset = buildPresetFromStore(
     171              :       keybindingStore.currentPresetName,
     172              :       keybindingStore
     173              :     )
     174            1 :     downloadBlob(
     175              :       `${preset.name}.json`,
     176              :       new Blob([JSON.stringify(preset, null, 2)], {
     177              :         type: 'application/json'
     178              :       })
     179              :     )
     180              :   }
     181              : 
     182            4 :   async function importPreset() {
     183              :     const file = await uploadFile('application/json')
     184            4 :     const text = await file.text()
     185            4 :     let data: unknown
     186            4 :     try {
     187            4 :       data = JSON.parse(text)
     188              :     } catch {
     189            0 :       throw new Error(t('g.keybindingPresets.invalidPresetFile'))
     190              :     }
     191            4 :     const result = zKeybindingPreset.safeParse(data)
     192            4 :     if (!result.success) {
     193            0 :       throw new Error(
     194              :         t('g.keybindingPresets.invalidPresetFile') +
     195              :           ': ' +
     196              :           fromZodError(result.error).message
     197              :       )
     198              :     }
     199            4 :     const preset = result.data
     200              : 
     201              :     // Save the imported preset file to storage
     202            4 :     await api.storeUserData(
     203              :       presetFilePath(preset.name),
     204              :       JSON.stringify(preset),
     205              :       { overwrite: true, stringify: false }
     206              :     )
     207              : 
     208              :     // Switch to the imported preset (handles dirty check)
     209            4 :     await switchPreset(preset.name)
     210              : 
     211            4 :     toast.success(t('g.keybindingPresets.presetImported'), { duration: 3000 })
     212              :   }
     213              : 
     214            1 :   async function promptAndSaveNewPreset(): Promise<boolean> {
     215            1 :     const name = await dialogService.prompt({
     216              :       title: t('g.keybindingPresets.saveAsNewPreset'),
     217              :       message: t('g.keybindingPresets.presetNamePrompt'),
     218              :       defaultValue: ''
     219              :     })
     220            1 :     if (!name) return false
     221            1 :     const trimmedName = name.trim()
     222            1 :     if (!trimmedName) return false
     223              :     const existingPresets = await listPresets()
     224            1 :     if (existingPresets.includes(trimmedName)) {
     225              :       const overwrite = await dialogService.confirm({
     226              :         title: t('g.keybindingPresets.overwritePresetTitle'),
     227              :         message: t('g.keybindingPresets.overwritePresetMessage', {
     228              :           name: trimmedName
     229              :         }),
     230              :         type: 'overwrite'
     231              :       })
     232            0 :       if (!overwrite) return false
     233              :     }
     234            1 :     await savePreset(trimmedName)
     235            1 :     return true
     236              :   }
     237              : 
     238            5 :   async function switchPreset(targetName: string) {
     239            5 :     if (keybindingStore.isCurrentPresetModified) {
     240              :       const displayName =
     241              :         keybindingStore.currentPresetName === 'default'
     242              :           ? t('g.keybindingPresets.default')
     243              :           : keybindingStore.currentPresetName
     244            0 :       const result = await showUnsavedChangesDialog(displayName)
     245              : 
     246            0 :       if (result === null) return
     247            0 :       if (result) {
     248            0 :         if (keybindingStore.currentPresetName !== 'default') {
     249            0 :           await savePreset(keybindingStore.currentPresetName)
     250              :         } else {
     251              :           const saved = await promptAndSaveNewPreset()
     252            0 :           if (!saved) return
     253              :         }
     254              :       }
     255              :     }
     256              : 
     257            5 :     if (targetName === 'default') {
     258            1 :       await switchToDefaultPreset()
     259            1 :       return
     260              :     }
     261              : 
     262              :     const preset = await loadPreset(targetName)
     263            4 :     applyPreset(preset)
     264            4 :     await keybindingService.persistUserKeybindings()
     265            4 :     await settingStore.set('Comfy.Keybinding.CurrentPreset', targetName)
     266              :   }
     267              : 
     268           78 :   return {
     269              :     listPresets: wrapWithErrorHandlingAsync(listPresets),
     270              :     loadPreset: wrapWithErrorHandlingAsync(loadPreset),
     271              :     savePreset: wrapWithErrorHandlingAsync(savePreset),
     272              :     deletePreset: wrapWithErrorHandlingAsync(deletePreset),
     273              :     exportPreset,
     274              :     importPreset: wrapWithErrorHandlingAsync(importPreset),
     275              :     switchPreset: wrapWithErrorHandlingAsync(switchPreset),
     276              :     switchToDefaultPreset: wrapWithErrorHandlingAsync(switchToDefaultPreset),
     277              :     promptAndSaveNewPreset: wrapWithErrorHandlingAsync(promptAndSaveNewPreset),
     278              :     applyPreset
     279              :   }
     280              : }
        

Generated by: LCOV version 2.0-1