LCOV - code coverage report
Current view: top level - packages/settings-core/src - settingStore.ts Coverage Total Hit
Test: ComfyUI E2E Coverage Lines: 86.9 % 153 133
Test Date: 2026-11-17 04:17:53

            Line data    Source code
       1              : import { retry } from 'es-toolkit'
       2              : import { cloneDeep } from 'es-toolkit/compat'
       3              : import { createEventHook, until, useAsyncState } from '@vueuse/core'
       4              : import { compare, valid } from 'semver'
       5              : import { ref } from 'vue'
       6              : import type { Ref } from 'vue'
       7              : 
       8              : import { CANVAS_NAVIGATION_PRESETS } from './canvasNavigation'
       9              : import type { SettingParams, Settings } from './types'
      10              : import { useTelemetry } from '@comfyorg/telemetry'
      11              : import type { SettingChangedMetadata } from '@comfyorg/telemetry/types'
      12              : 
      13         2356 : export const getSettingInfo = (setting: SettingParams) => {
      14          885 :   const parts = setting.category || setting.id.split('.')
      15          885 :   return {
      16              :     category: parts[0] ?? 'Other',
      17              :     subCategory: parts[1] ?? 'Other'
      18              :   }
      19              : }
      20              : 
      21              : interface SettingChange {
      22              :   id: string
      23              :   value: unknown
      24              :   oldValue: unknown
      25              : }
      26              : 
      27              : interface AppliedSetting<TValue> {
      28              :   previousValue: TValue
      29              :   newValue: TValue
      30              :   writeToken: number
      31              : }
      32              : 
      33              : type RevertibleSettingId =
      34              :   | 'Comfy.Extension.DisabledPacks'
      35              :   | 'Comfy.AgentPanel.OnboardedScopes'
      36              : 
      37              : type SettingWriteOutcome =
      38              :   | { status: 'saved' | 'unchanged' }
      39              :   | { status: 'refused'; statusCode: number; statusText: string }
      40              :   | { status: 'indeterminate'; statusCode: number; statusText: string }
      41              :   | { status: 'unconfirmed'; cause: unknown }
      42              : 
      43         2356 : const PRE_STORAGE_REFUSAL_STATUSES = new Set([
      44              :   400, 404, 405, 413, 414, 415, 422, 431
      45              : ])
      46              : 
      47      1039044 : function resolveDefaultValue<T>(value: T | (() => T)): T {
      48      1039044 :   return typeof value === 'function' ? (value as () => T)() : value
      49              : }
      50              : 
      51        34638 : function tryMigrateDeprecatedValue(
      52              :   setting: SettingParams | undefined,
      53              :   value: unknown
      54              : ) {
      55        34638 :   return setting?.migrateDeprecatedValue?.(value) ?? value
      56              : }
      57              : 
      58              : /**
      59              :  * Runs the handler, absorbing both a synchronous throw and a rejected promise.
      60              :  * `SettingParams.onChange` is extension-facing public API and its caller
      61              :  * persists the setting only after awaiting it, so letting a third-party
      62              :  * failure escape would discard the user's own change without saving it.
      63              :  *
      64              :  * Logged at `warn` for the same reason {@link ComfyApi.wrapListener} is: RUM
      65              :  * collects `console.error`, so reporting third-party faults there would just
      66              :  * relocate the noise this guard exists to remove.
      67              :  */
      68       361089 : async function callHandler(
      69              :   setting: SettingParams | undefined,
      70              :   newValue: unknown,
      71              :   oldValue: unknown
      72              : ) {
      73       361089 :   try {
      74       361089 :     await setting?.onChange?.(newValue, oldValue)
      75              :   } catch (error) {
      76            0 :     console.warn(`[settings] onChange handler for ${setting?.id} failed`, error)
      77              :   }
      78              : }
      79              : 
      80       361089 : async function onChange(
      81              :   setting: SettingParams | undefined,
      82              :   newValue: unknown,
      83              :   oldValue: unknown,
      84              :   notify: (change: SettingChange) => void
      85              : ) {
      86              :   // Started before notifying so extensions keep observing the change at the
      87              :   // same point, but awaited afterwards: a handler that cascades into other
      88              :   // settings must finish writing them before the caller writes this one, or
      89              :   // the two requests race in the backend's read-modify-write.
      90       361089 :   const handled = callHandler(setting, newValue, oldValue)
      91       361089 :   if (setting) {
      92       361088 :     notify({ id: setting.id, value: newValue, oldValue })
      93              :   }
      94       361089 :   await handled
      95              : }
      96              : 
      97              : /**
      98              :  * Migrations run inside the boot-critical settings loader, where a rejection
      99              :  * becomes `settingStore.error` and GraphCanvas rethrows it before any core
     100              :  * setting registers — turning a failed write into an app that will not start.
     101              :  * The migrated value is already in memory and the server still holds the
     102              :  * un-migrated state, so swallowing the failure leaves the next load to retry.
     103              :  */
     104           29 : async function persistMigration(write: () => Promise<unknown>) {
     105           29 :   try {
     106           29 :     await write()
     107              :   } catch (error) {
     108            0 :     console.warn(
     109              :       '[settings] Failed to persist migration; retrying on next load',
     110              :       error
     111              :     )
     112              :   }
     113              : }
     114              : 
     115          716 : function settingChangedEvent<K extends keyof Settings>(
     116              :   setting: SettingParams | undefined,
     117              :   key: K,
     118              :   applied: AppliedSetting<Settings[K]>
     119              : ): SettingChangedMetadata | undefined {
     120          716 :   if (!setting) return undefined
     121              : 
     122          716 :   const telemetry = setting.telemetry
     123          716 :   const isVisible = setting.type !== 'hidden'
     124              :   const trackChanges = telemetry?.trackChanges ?? isVisible
     125          716 :   if (!trackChanges) return undefined
     126              : 
     127              :   const includeValues = telemetry?.includeValues ?? isVisible
     128          716 :   return includeValues
     129              :     ? {
     130              :         setting_id: key,
     131              :         previous_value: applied.previousValue,
     132              :         new_value: applied.newValue
     133              :       }
     134              :     : { setting_id: key }
     135              : }
     136              : 
     137              : /** The backend calls the setting store persists through. */
     138              : export interface SettingPersistence {
     139              :   getSettings(options: { skipStatusRetry: boolean }): Promise<Partial<Settings>>
     140              :   storeSetting(
     141              :     id: keyof Settings,
     142              :     value: Settings[keyof Settings]
     143              :   ): Promise<Response>
     144              :   storeSettings(settings: Partial<Settings>): Promise<unknown>
     145              : }
     146              : 
     147              : /** The setting store's state and actions, persisting through the given port. */
     148         2355 : export function settingStoreSetup(persistence: SettingPersistence) {
     149         2355 :   const settingValues: Ref<Partial<Settings>> = ref({})
     150         2355 :   const settingsById = ref<Record<string, SettingParams>>({})
     151         2355 :   const latestWrite = new Map<keyof Settings, number>()
     152         2355 :   const settingChanged = createEventHook<SettingChange>()
     153              : 
     154         2355 :   const {
     155              :     isReady,
     156              :     isLoading,
     157              :     error,
     158              :     execute: loadSettingValues
     159              :   } = useAsyncState(
     160              :     async () => {
     161         2355 :       if (Object.keys(settingsById.value).length) {
     162            0 :         throw new Error(
     163              :           'Setting values must be loaded before any setting is registered.'
     164              :         )
     165              :       }
     166         2355 :       settingValues.value = await retry(
     167              :         () => persistence.getSettings({ skipStatusRetry: true }),
     168              :         {
     169              :           retries: 3,
     170              :           delay: (attempt) => Math.min(1000 * Math.pow(2, attempt), 8000)
     171              :         }
     172              :       )
     173         2355 :       await migrateZoomThresholdToFontSize()
     174         2355 :       await migrateCanvasNavigationOverrides()
     175              :     },
     176              :     undefined,
     177              :     { immediate: false }
     178              :   )
     179              : 
     180         2355 :   async function load(): Promise<void> {
     181         2355 :     if (isReady.value) return
     182              : 
     183         2355 :     if (isLoading.value) {
     184            0 :       await until(isLoading).toBe(false)
     185            0 :       return
     186              :     }
     187              : 
     188         2355 :     await loadSettingValues()
     189              :   }
     190              : 
     191              :   /**
     192              :    * Check if a setting's value exists, i.e. if the user has set it manually.
     193              :    * @param key - The key of the setting to check.
     194              :    * @returns Whether the setting exists.
     195              :    */
     196         4712 :   function exists(key: keyof Settings) {
     197         4712 :     return settingValues.value[key] !== undefined
     198              :   }
     199              : 
     200              :   /**
     201              :    * Apply a setting value in memory and fire onChange, without persisting it.
     202              :    * @returns The migrated value, or `undefined` when it was already current.
     203              :    */
     204          922 :   async function applySettingLocally<K extends keyof Settings>(
     205              :     key: K,
     206              :     value: Settings[K]
     207              :   ): Promise<AppliedSetting<Settings[K]> | undefined> {
     208          922 :     const clonedValue = cloneDeep(value)
     209          922 :     const newValue = tryMigrateDeprecatedValue(
     210              :       settingsById.value[key],
     211              :       clonedValue
     212              :     )
     213          922 :     const oldValue = get(key)
     214          922 :     if (newValue === oldValue) return undefined
     215              : 
     216          729 :     const typedNewValue = newValue as Settings[K]
     217          729 :     settingValues.value[key] = typedNewValue
     218          922 :     const writeToken = (latestWrite.get(key) ?? 0) + 1
     219          922 :     latestWrite.set(key, writeToken)
     220              : 
     221          922 :     await onChange(
     222              :       settingsById.value[key],
     223              :       newValue,
     224              :       oldValue,
     225              :       settingChanged.trigger
     226              :     )
     227              : 
     228          870 :     if (latestWrite.get(key) !== writeToken) return undefined
     229          729 :     return {
     230              :       previousValue: oldValue,
     231              :       newValue: typedNewValue,
     232              :       writeToken
     233              :     }
     234              :   }
     235              : 
     236            1 :   async function revertSettingLocally<K extends keyof Settings>(
     237              :     key: K,
     238              :     hadValue: boolean,
     239              :     applied: AppliedSetting<Settings[K]>
     240              :   ) {
     241            1 :     if (latestWrite.get(key) !== applied.writeToken) return
     242            1 :     if (hadValue) settingValues.value[key] = applied.previousValue
     243            1 :     else delete settingValues.value[key]
     244            1 :     await onChange(
     245              :       settingsById.value[key],
     246              :       applied.previousValue,
     247              :       applied.newValue,
     248              :       settingChanged.trigger
     249              :     )
     250              :   }
     251              : 
     252            2 :   async function setWithOutcome<K extends RevertibleSettingId>(
     253              :     key: K,
     254              :     value: Settings[K]
     255              :   ): Promise<SettingWriteOutcome> {
     256            2 :     const hadValue = exists(key)
     257            2 :     const applied = await applySettingLocally(key, value)
     258            2 :     if (applied === undefined) return { status: 'unchanged' }
     259              : 
     260            2 :     let response: Response
     261            2 :     try {
     262            2 :       response = await persistence.storeSetting(key, applied.newValue)
     263              :     } catch (cause) {
     264            0 :       return { status: 'unconfirmed', cause }
     265              :     }
     266              : 
     267            2 :     if (!response.ok) {
     268            2 :       const outcome = {
     269              :         status: PRE_STORAGE_REFUSAL_STATUSES.has(response.status)
     270              :           ? ('refused' as const)
     271              :           : ('indeterminate' as const),
     272              :         statusCode: response.status,
     273              :         statusText: response.statusText
     274              :       }
     275            2 :       if (outcome.status === 'refused') {
     276            1 :         await revertSettingLocally(key, hadValue, applied)
     277              :       }
     278            2 :       return outcome
     279              :     }
     280              : 
     281            0 :     const event = settingChangedEvent(settingsById.value[key], key, applied)
     282            0 :     if (event) useTelemetry()?.trackSettingChanged(event)
     283            0 :     return { status: 'saved' }
     284              :   }
     285              : 
     286              :   /**
     287              :    * Set a setting value.
     288              :    * @param key - The key of the setting to set.
     289              :    * @param value - The value to set.
     290              :    */
     291          875 :   async function set<K extends keyof Settings>(key: K, value: Settings[K]) {
     292          875 :     const applied = await applySettingLocally(key, value)
     293          875 :     if (applied === undefined) return
     294          682 :     await persistence.storeSetting(key, applied.newValue)
     295              : 
     296          671 :     const event = settingChangedEvent(settingsById.value[key], key, applied)
     297          846 :     if (event) useTelemetry()?.trackSettingChanged(event)
     298              :   }
     299              : 
     300              :   /**
     301              :    * Set multiple setting values in a single API call.
     302              :    * @param settings - A partial settings object with key-value pairs to set.
     303              :    */
     304           22 :   async function setMany(settings: Partial<Settings>) {
     305           22 :     const updatedSettings: Partial<Settings> = {}
     306           22 :     const telemetryEvents: SettingChangedMetadata[] = []
     307              : 
     308           22 :     for (const key of Object.keys(settings) as (keyof Settings)[]) {
     309           45 :       const applied = await applySettingLocally(key, settings[key])
     310           45 :       if (applied !== undefined) {
     311           45 :         Object.assign(updatedSettings, { [key]: applied.newValue })
     312           45 :         const event = settingChangedEvent(settingsById.value[key], key, applied)
     313           45 :         if (event) telemetryEvents.push(event)
     314              :       }
     315              :     }
     316              : 
     317           22 :     if (Object.keys(updatedSettings).length > 0) {
     318           22 :       await persistence.storeSettings(updatedSettings)
     319           22 :       const telemetry = useTelemetry()
     320           22 :       for (const event of telemetryEvents) {
     321            4 :         telemetry?.trackSettingChanged(event)
     322              :       }
     323              :     }
     324              :   }
     325              : 
     326              :   /**
     327              :    * Get a setting value.
     328              :    * @param key - The key of the setting to get.
     329              :    * @returns The value of the setting.
     330              :    */
     331      1386047 :   function get<K extends keyof Settings>(key: K): Settings[K] {
     332              :     // Clone the value when returning to prevent external mutations
     333      1386047 :     return cloneDeep(settingValues.value[key] ?? getDefaultValue(key)!)
     334              :   }
     335              : 
     336              :   /**
     337              :    * Gets the setting params, asserting the type that is intentionally left off
     338              :    * of {@link settingsById}.
     339              :    * @param key The key of the setting to get.
     340              :    * @returns The setting.
     341              :    */
     342      1170368 :   function getSettingById<K extends keyof Settings>(
     343              :     key: K
     344              :   ): SettingParams<Settings[K]> | undefined {
     345      1170368 :     return settingsById.value[key] as SettingParams<Settings[K]> | undefined
     346              :   }
     347              : 
     348              :   /**
     349              :    * Get the default value of a setting.
     350              :    * @param key - The key of the setting to get.
     351              :    * @returns The default value of the setting.
     352              :    */
     353      1170368 :   function getDefaultValue<K extends keyof Settings>(
     354              :     key: K
     355              :   ): Settings[K] | undefined {
     356              :     // Assertion: settingsById is not typed.
     357      1170368 :     const param = getSettingById(key)
     358              : 
     359      1170368 :     if (param === undefined) return
     360              : 
     361              :     const versionedDefault = getVersionedDefaultValue(key, param)
     362              : 
     363      1170368 :     return versionedDefault ?? resolveDefaultValue(param.defaultValue)
     364              :   }
     365              : 
     366      1039051 :   function getVersionedDefaultValue<
     367              :     K extends keyof Settings,
     368              :     TValue = Settings[K]
     369              :   >(key: K, param: SettingParams<TValue> | undefined): TValue | null {
     370              :     // get default versioned value, skipping if the key is 'Comfy.InstalledVersion' to prevent infinite loop
     371      1039051 :     const defaultsByInstallVersion = param?.defaultsByInstallVersion
     372      1039051 :     if (defaultsByInstallVersion && key !== 'Comfy.InstalledVersion') {
     373        13893 :       const installedVersion = get('Comfy.InstalledVersion')
     374              : 
     375        13893 :       if (installedVersion) {
     376           22 :         const sortedVersions = Object.keys(defaultsByInstallVersion).sort(
     377              :           (a, b) => compare(b, a)
     378              :         )
     379              : 
     380           22 :         for (const version of sortedVersions) {
     381              :           // Ensure the version is in a valid format before comparing
     382           22 :           if (!valid(version)) {
     383            0 :             continue
     384              :           }
     385              : 
     386           22 :           if (compare(installedVersion, version) >= 0) {
     387            7 :             const versionedDefault =
     388              :               defaultsByInstallVersion[
     389              :                 version as keyof typeof defaultsByInstallVersion
     390              :               ]
     391            7 :             if (versionedDefault !== undefined) {
     392            7 :               return typeof versionedDefault === 'function'
     393              :                 ? versionedDefault()
     394              :                 : versionedDefault
     395              :             }
     396              :           }
     397              :         }
     398              :       }
     399              :     }
     400              : 
     401      1039044 :     return null
     402              :   }
     403              : 
     404              :   /**
     405              :    * Register a setting.
     406              :    * @param setting - The setting to register.
     407              :    */
     408       360359 :   function addSetting(setting: SettingParams) {
     409       360359 :     if (setting.id in settingsById.value) {
     410              :       // Setting already registered - skip to allow component remounting
     411              :       // TODO: Add store reset methods to bootstrapStore and settingStore, then
     412              :       // replace window.location.reload() with router.push() in SidebarLogoutIcon.vue
     413            0 :       console.warn(`Setting already registered: ${setting.id}`)
     414            0 :       return
     415              :     }
     416              : 
     417       360359 :     settingsById.value[setting.id] = setting
     418              : 
     419       360359 :     if (settingValues.value[setting.id] !== undefined) {
     420        33716 :       Object.assign(settingValues.value, {
     421              :         [setting.id]: tryMigrateDeprecatedValue(
     422              :           setting,
     423              :           settingValues.value[setting.id]
     424              :         )
     425              :       })
     426              :     }
     427       360359 :     void onChange(setting, get(setting.id), undefined, settingChanged.trigger)
     428              :   }
     429              : 
     430              :   /**
     431              :    * A Navigation Mode preset stored before the Left Mouse Click Behavior and
     432              :    * Mouse Wheel Scroll settings shipped in 1.27.4 is the only record of that
     433              :    * choice. Materialise the overrides it implies before anything can read
     434              :    * their defaults, which describe a different preset and would otherwise
     435              :    * demote the stored mode to 'custom'.
     436              :    *
     437              :    * Runs from `load()` rather than the settings' own `onChange` so it is
     438              :    * awaited, and so it does not depend on the order `CORE_SETTINGS` happens
     439              :    * to register these three settings in.
     440              :    */
     441         2355 :   async function migrateCanvasNavigationOverrides() {
     442         2355 :     const storedMode = settingValues.value['Comfy.Canvas.NavigationMode']
     443         2355 :     const preset =
     444              :       typeof storedMode === 'string'
     445              :         ? CANVAS_NAVIGATION_PRESETS[storedMode]
     446              :         : undefined
     447         2355 :     if (!preset) return
     448              : 
     449           30 :     const unset: Partial<Settings> = {}
     450           30 :     for (const id of Object.keys(preset) as (keyof Settings)[]) {
     451           60 :       if (settingValues.value[id] === undefined) {
     452           57 :         Object.assign(unset, { [id]: preset[id] })
     453              :       }
     454              :     }
     455           30 :     if (!Object.keys(unset).length) return
     456              : 
     457           29 :     Object.assign(settingValues.value, unset)
     458           29 :     await persistMigration(() => persistence.storeSettings(unset))
     459              :   }
     460              : 
     461              :   /**
     462              :    * Migrate the old zoom threshold setting to the new font size setting.
     463              :    * Preserves the exact zoom threshold behavior by converting it to equivalent font size.
     464              :    */
     465         2355 :   async function migrateZoomThresholdToFontSize() {
     466         2355 :     const oldKey = 'LiteGraph.Canvas.LowQualityRenderingZoomThreshold'
     467         2355 :     const newKey = 'LiteGraph.Canvas.MinFontSizeForLOD'
     468              : 
     469              :     // Only migrate if old setting exists and new setting doesn't
     470         2355 :     if (
     471              :       settingValues.value[oldKey] !== undefined &&
     472              :       settingValues.value[newKey] === undefined
     473              :     ) {
     474            0 :       const oldValue = settingValues.value[oldKey]
     475              : 
     476              :       // Convert zoom threshold to equivalent font size to preserve exact behavior
     477              :       // The threshold formula is: threshold = font_size / (14 * sqrt(DPR))
     478              :       // For DPR=1: threshold = font_size / 14
     479              :       // Therefore: font_size = threshold * 14
     480              :       //
     481              :       // Examples:
     482              :       // - Old 0.6 threshold → 0.6 * 14 = 8.4px → rounds to 8px (preserves ~60% zoom threshold)
     483              :       // - Old 0.5 threshold → 0.5 * 14 = 7px (preserves 50% zoom threshold)
     484              :       // - Old 1.0 threshold → 1.0 * 14 = 14px (preserves 100% zoom threshold)
     485            0 :       const mappedFontSize = Math.round(oldValue * 14)
     486            0 :       const clampedFontSize = Math.max(1, Math.min(24, mappedFontSize))
     487              : 
     488              :       // Set the new value
     489            0 :       settingValues.value[newKey] = clampedFontSize
     490              : 
     491              :       // Remove the old setting to prevent confusion
     492            0 :       delete settingValues.value[oldKey]
     493              : 
     494              :       // Store the migrated setting
     495            0 :       await persistMigration(async () => {
     496            0 :         await persistence.storeSetting(newKey, clampedFontSize)
     497            0 :         await persistence.storeSetting(oldKey, undefined)
     498              :       })
     499              :     }
     500              :   }
     501              : 
     502         2355 :   return {
     503              :     settingValues,
     504              :     settingsById,
     505              :     isReady,
     506              :     isLoading,
     507              :     error,
     508              :     load,
     509              :     addSetting,
     510              :     applySettingLocally,
     511              :     set,
     512              :     setWithOutcome,
     513              :     setMany,
     514              :     get,
     515              :     exists,
     516              :     getDefaultValue,
     517              :     onSettingChanged: settingChanged.on
     518              :   }
     519              : }
        

Generated by: LCOV version 2.0-1