Files
aigc-home/docs/hel-892/h3-reference/frontend__src__scripts__valueControl.ts
T
2026-10-30 06:47:51 +08:00

159 lines
4.2 KiB
TypeScript

import { isComboWidget } from '@/lib/litegraph/src/litegraph'
import type { IBaseWidget } from '@/lib/litegraph/src/types/widgets'
import { IS_CONTROL_WIDGET } from './controlWidgetMarker'
type ValueControlMode =
| 'fixed'
| 'increment'
| 'increment-wrap'
| 'decrement'
| 'randomize'
export function nextValueForLinkedTarget(params: {
target: IBaseWidget
linkedWidgets: IBaseWidget[] | undefined
nodeId: unknown
}): IBaseWidget['value'] | undefined {
const linked = params.linkedWidgets
if (!linked) return undefined
const controlWidget = linked.find(isValueControlWidget)
if (!controlWidget) return undefined
const comboFilter = linked.find(
(w) => w !== controlWidget && w.type === 'string'
)
const filterValue =
typeof comboFilter?.value === 'string' ? comboFilter.value : undefined
const mode = controlWidget.value as ValueControlMode
return computeNextControlledValue(params.target, mode, {
comboFilter: filterValue,
nodeId: params.nodeId
})
}
const SAFE_INTEGER_MAX = 1125899906842624
const SAFE_INTEGER_MIN = -1125899906842624
export function isValueControlWidget(widget: IBaseWidget): boolean {
return (
(widget as Record<symbol, unknown>)[IS_CONTROL_WIDGET] === true &&
typeof widget.beforeQueued === 'function' &&
typeof widget.afterQueued === 'function'
)
}
function buildComboFilter(
filter: string | undefined,
nodeId?: unknown
): ((item: string) => boolean) | undefined {
if (!filter) return undefined
if (filter.startsWith('/') && filter.endsWith('/')) {
try {
const regex = new RegExp(filter.substring(1, filter.length - 1))
return (item: string) => regex.test(item)
} catch (error) {
console.error(
'Error constructing RegExp filter for node ' + String(nodeId),
filter,
error
)
}
}
const lower = filter.toLocaleLowerCase()
return (item: string) => item.toLocaleLowerCase().includes(lower)
}
export function computeNextControlledValue(
target: IBaseWidget,
mode: ValueControlMode,
options: { comboFilter?: string; nodeId?: unknown } = {}
): IBaseWidget['value'] | undefined {
if (mode === 'fixed') return undefined
if (isComboWidget(target)) {
return computeNextComboValue(target, mode, options)
}
return computeNextNumberValue(target, mode)
}
function computeNextComboValue(
target: IBaseWidget,
mode: ValueControlMode,
{ comboFilter, nodeId }: { comboFilter?: string; nodeId?: unknown }
): IBaseWidget['value'] | undefined {
const rawValues = target.options.values
if (!Array.isArray(rawValues)) return undefined
const allValues = rawValues.filter(
(value): value is string => typeof value === 'string'
)
const check = buildComboFilter(comboFilter, nodeId)
const values = check ? allValues.filter(check) : allValues
if (!values.length) {
if (allValues.length) {
console.warn(
'Filter for node ' + String(nodeId) + ' has filtered out all items',
comboFilter
)
}
return undefined
}
let currentIndex = values.indexOf(target.value as string)
const length = values.length
switch (mode) {
case 'increment':
currentIndex += 1
break
case 'increment-wrap':
currentIndex += 1
if (currentIndex >= length) currentIndex = 0
break
case 'decrement':
currentIndex -= 1
break
case 'randomize':
currentIndex = Math.floor(Math.random() * length)
break
}
currentIndex = Math.max(0, Math.min(length - 1, currentIndex))
return values[currentIndex]
}
function computeNextNumberValue(
target: IBaseWidget,
mode: ValueControlMode
): number | undefined {
if (typeof target.value !== 'number') return undefined
const { min: rawMin = 0, max: rawMax = 1, step2 = 1 } = target.options
const max = Math.min(SAFE_INTEGER_MAX, rawMax)
const min = Math.max(SAFE_INTEGER_MIN, rawMin)
const range = (max - min) / step2
let next = target.value
switch (mode) {
case 'increment':
case 'increment-wrap':
next += step2
break
case 'decrement':
next -= step2
break
case 'randomize':
next = Math.floor(Math.random() * range) * step2 + min
break
}
return Math.min(Math.max(next, min), max)
}