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