Improve float widget precision handling

src/renderer/extensions/vueNodes/widgets/composables/useFloatWidget.ts

@@ -25,6 +25,19 @@ function onFloatValueChange(this: INumericWidget, v: number) {
   }
 }
 
+function computePrecisionFromResolution(
+  resolution: number | undefined,
+  defaultPrecision: number
+): number {
+  if (!resolution || !Number.isFinite(resolution) || resolution <= 0) {
+    return defaultPrecision
+  }
+
+  const magnitude = Math.floor(Math.log10(resolution))
+  const precision = Math.max(0, -magnitude)
+  return precision
+}
+
 export const _for_testing = {
   onFloatValueChange
 }
@@ -49,10 +62,22 @@ export const useFloatWidget = () => {
           ? 'knob'
           : 'number'
 
-    const step = inputSpec.step ?? 0.5
+    const roundOption =
+      typeof inputSpec.round === 'number' ? inputSpec.round : undefined
+    const hasExplicitStep = typeof inputSpec.step === 'number'
+    const step = hasExplicitStep ? (inputSpec.step as number) : 0.5
+    const resolution = roundOption ?? (hasExplicitStep ? step : undefined)
+
+    const autoPrecision = computePrecisionFromResolution(resolution, 3)
+
+    const floatRoundingPrecision =
+      settingStore.get('Comfy.FloatRoundingPrecision')
     const precision =
-      settingStore.get('Comfy.FloatRoundingPrecision') ||
-      Math.max(0, -Math.floor(Math.log10(step)))
+      typeof floatRoundingPrecision === 'number' &&
+      floatRoundingPrecision > 0
+        ? floatRoundingPrecision
+        : autoPrecision
+
     const enableRounding = !settingStore.get('Comfy.DisableFloatRounding')
 
     /** Assertion {@link inputSpec.default} */

tests-ui/tests/renderer/extensions/vueNodes/widgets/composables/useFloatWidget.test.ts

@@ -1,14 +1,29 @@
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 
-import { _for_testing } from '@/renderer/extensions/vueNodes/widgets/composables/useFloatWidget'
+import {
+  _for_testing,
+  useFloatWidget
+} from '@/renderer/extensions/vueNodes/widgets/composables/useFloatWidget'
+import type { InputSpec } from '@/schemas/nodeDef/nodeDefSchemaV2'
+import type { LGraphNode } from '@/lib/litegraph/src/litegraph'
+
+let mockFloatRoundingPrecision = 0
 
 vi.mock('@/scripts/widgets', () => ({
-  addValueControlWidgets: vi.fn()
+  addValueControlWidgets: vi.fn(),
+  addValueControlWidget: vi.fn()
 }))
 
 vi.mock('@/platform/settings/settingStore', () => ({
   useSettingStore: () => ({
-    settings: {}
+    settings: {},
+    get: (key: string) => {
+      if (key === 'Comfy.FloatRoundingPrecision')
+        return mockFloatRoundingPrecision
+      if (key === 'Comfy.DisableFloatRounding') return false
+      if (key === 'Comfy.DisableSliders') return false
+      return undefined
+    }
   })
 }))
 
@@ -24,6 +39,7 @@ describe('useFloatWidget', () => {
         options: {},
         value: 0
       }
+      mockFloatRoundingPrecision = 0
     })
 
     it('should not round values when round option is not set', () => {
@@ -77,4 +93,80 @@ describe('useFloatWidget', () => {
       expect(widget.value).toBeCloseTo(3, 10)
     })
   })
+
+  describe('widget constructor precision', () => {
+    const buildNode = () => {
+      const widgets: any[] = []
+      const node: LGraphNode = {
+        addWidget: (
+          type: string,
+          name: string,
+          value: number,
+          callback: (v: number) => void,
+          options: any
+        ) => {
+          const widget = { type, name, value, callback, options }
+          widgets.push(widget)
+          return widget
+        }
+      } as unknown as LGraphNode
+
+      return { node, widgets }
+    }
+
+    it('uses auto precision derived from step when provided', () => {
+      const { node, widgets } = buildNode()
+      const widgetConstructor = useFloatWidget()
+
+      const inputSpec = {
+        type: 'FLOAT',
+        name: 'test-float',
+        step: 0.01,
+        min: 0,
+        max: 1
+      } as unknown as InputSpec
+
+      widgetConstructor(node, inputSpec)
+
+      expect(widgets).toHaveLength(1)
+      expect(widgets[0].options.precision).toBe(2)
+    })
+
+    it('falls back to default precision when step and round are not provided', () => {
+      const { node, widgets } = buildNode()
+      const widgetConstructor = useFloatWidget()
+
+      const inputSpec = {
+        type: 'FLOAT',
+        name: 'test-float',
+        min: 0,
+        max: 1
+      } as unknown as InputSpec
+
+      widgetConstructor(node, inputSpec)
+
+      expect(widgets).toHaveLength(1)
+      expect(widgets[0].options.precision).toBe(3)
+    })
+
+    it('respects user FloatRoundingPrecision setting when > 0', () => {
+      const { node, widgets } = buildNode()
+      const widgetConstructor = useFloatWidget()
+
+      mockFloatRoundingPrecision = 4
+
+      const inputSpec = {
+        type: 'FLOAT',
+        name: 'test-float',
+        step: 0.01,
+        min: 0,
+        max: 1
+      } as unknown as InputSpec
+
+      widgetConstructor(node, inputSpec)
+
+      expect(widgets).toHaveLength(1)
+      expect(widgets[0].options.precision).toBe(4)
+    })
+  })
 })