中文版 AI 姿势参考图库 · 1439 组 / 2878 张图片 / 完整汉化 · 零依赖静态画廊
import type { WorkflowParameterOverrides, WorkflowScalar } from '@/types/gallery'
export interface ParameterNode {
class_type: string
inputs: Record<string, unknown>
_meta?: { title?: string; studio?: { hiddenInputs?: string[]; controls?: Array<{ input: string; label?: string; description?: string; group?: string; options?: Array<WorkflowScalar | { value: WorkflowScalar; label: string }> }>; imageRole?: string; referenceCombinations?: string[][] } }
}
export type ParameterWorkflow = Record<string, ParameterNode>
export type ComfyObjectInfo = Record<string, { input?: { required?: Record<string, unknown>; optional?: Record<string, unknown>; hidden?: Record<string, unknown> }; output?: string[] }>
export interface WorkflowControl {
key: string; nodeId: string; input: string; label: string; description?: string; group?: string
type: 'boolean' | 'number' | 'string' | 'enum'; value: WorkflowScalar; recommended: boolean
options?: WorkflowScalar[]; optionLabels?: Record<string, string>; min?: number; max?: number; step?: number; integer?: boolean; multiline?: boolean
}
export function parseParameterWorkflow(json: string): ParameterWorkflow | null {
try {
const value = JSON.parse(json)
if (!value || typeof value !== 'object' || Array.isArray(value) || !Object.keys(value).length) return null
if (!Object.values(value).every((node: unknown) => node && typeof node === 'object' && 'class_type' in node && typeof node.class_type === 'string' && 'inputs' in node && node.inputs && typeof node.inputs === 'object' && !Array.isArray(node.inputs))) return null
return value
} catch { return null }
}
function canonical(value: unknown): string {
if (Array.isArray(value)) return `[${value.map(canonical).join(',')}]`
if (value && typeof value === 'object') return `{${Object.entries(value).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([key, item]) => `${JSON.stringify(key)}:${canonical(item)}`).join(',')}}`
return JSON.stringify(value) ?? ''
}
export function workflowIdentity(json: string): string {
const workflow = parseParameterWorkflow(json)
if (!workflow) return ''
const value = canonical(workflow)
let a = 2166136261, b = 5381
for (let i = 0; i < value.length; i++) { a = Math.imul(a ^ value.charCodeAt(i), 16777619); b = Math.imul(b, 33) ^ value.charCodeAt(i) }
return `${value.length}-${(a >>> 0).toString(16)}-${(b >>> 0).toString(16)}`
}
const scalar = (value: unknown): value is WorkflowScalar => typeof value === 'string' || typeof value === 'boolean' || (typeof value === 'number' && Number.isFinite(value))
export function getWorkflowControls(json: string, schemas: ComfyObjectInfo, excluded = new Set<string>()): WorkflowControl[] {
const workflow = parseParameterWorkflow(json)
if (!workflow) return []
const controls: WorkflowControl[] = []
for (const [nodeId, node] of Object.entries(workflow)) {
const schema = schemas[node.class_type]?.input
const declaredHidden = node._meta?.studio?.hiddenInputs
const hiddenInputs = Array.isArray(declaredHidden) && declaredHidden.every((input) => typeof input === 'string') ? new Set(declaredHidden) : new Set<string>()
for (const [input, value] of Object.entries(node.inputs)) {
if (!scalar(value) || hiddenInputs.has(input) || excluded.has(`${nodeId}.${input}`) || Object.hasOwn(schema?.hidden || {}, input)) continue
const definition = schema?.required?.[input] ?? schema?.optional?.[input]
if (!Array.isArray(definition)) continue
const [kind, rawSettings] = definition
const settings = rawSettings && typeof rawSettings === 'object' ? rawSettings as Record<string, unknown> : {}
if (settings.forceInput || settings.hidden || settings.socket || settings.image_upload) continue
const annotations = node._meta?.studio?.controls
const annotation = Array.isArray(annotations) ? annotations.find((control) => control && typeof control === 'object' && !Array.isArray(control) && typeof control.input === 'string' && control.input === input) : undefined
let type: WorkflowControl['type']
let options: WorkflowScalar[] | undefined
const schemaOptions = Array.isArray(kind) ? kind : kind === 'COMBO' && Array.isArray(settings.options) ? settings.options : undefined
if (schemaOptions && schemaOptions.every(scalar)) { type = 'enum'; options = schemaOptions; if (!options.some((option) => option === value)) continue }
else if (kind === 'BOOLEAN' && typeof value === 'boolean') type = 'boolean'
else if ((kind === 'INT' || kind === 'FLOAT') && typeof value === 'number') type = 'number'
else if (kind === 'STRING' && typeof value === 'string') type = 'string'
else continue
const optionLabels: Record<string, string> = {}
if (Array.isArray(annotation?.options)) {
const suggested = annotation.options.flatMap((option) => {
if (!scalar(option) && (!option || typeof option !== 'object' || Array.isArray(option) || typeof option.label !== 'string' || !scalar(option.value))) return []
const candidate = scalar(option) ? option : option.value
if (!scalar(candidate) || typeof candidate !== typeof value || (options && !options.includes(candidate))) return []
if (typeof candidate === 'number' && ((kind === 'INT' && !Number.isInteger(candidate)) || (typeof settings.min === 'number' && candidate < settings.min) || (typeof settings.max === 'number' && candidate > settings.max))) return []
if (!scalar(option) && typeof option?.label === 'string') optionLabels[JSON.stringify(candidate)] = option.label
return [candidate]
})
if (suggested.length && suggested.includes(value)) { options = suggested; type = 'enum' }
}
controls.push({ key: `${nodeId}.${input}`, nodeId, input, value, type, options, optionLabels,
label: typeof annotation?.label === 'string' ? annotation.label : `${node._meta?.title || node.class_type} · ${input}`,
description: typeof annotation?.description === 'string' ? annotation.description : undefined, group: typeof annotation?.group === 'string' ? annotation.group : undefined, recommended: Boolean(annotation),
min: typeof settings.min === 'number' ? settings.min : undefined,
max: typeof settings.max === 'number' ? settings.max : undefined,
step: typeof settings.step === 'number' ? settings.step : kind === 'INT' ? 1 : undefined,
integer: kind === 'INT', multiline: Boolean(settings.multiline),
})
}
}
return controls.sort((a, b) => Number(b.recommended) - Number(a.recommended))
}
export function validControlValue(control: WorkflowControl, value: unknown): value is WorkflowScalar {
if (!scalar(value) || typeof value !== typeof control.value) return false
if (control.options && !control.options.includes(value)) return false
if (typeof value === 'number' && ((control.integer && !Number.isInteger(value)) || (control.min !== undefined && value < control.min) || (control.max !== undefined && value > control.max))) return false
return true
}
export function applyWorkflowOverrides(json: string, saved?: WorkflowParameterOverrides, schemas?: ComfyObjectInfo): string {
const workflow = parseParameterWorkflow(json)
if (!workflow || !saved || !schemas || saved.workflowId !== workflowIdentity(json)) return json
const controls = new Map(getWorkflowControls(json, schemas).map((control) => [control.key, control]))
for (const [nodeId, fields] of Object.entries(saved.values || {})) {
const node = workflow[nodeId]
if (!node || !fields || typeof fields !== 'object') continue
for (const [input, value] of Object.entries(fields)) {
if (!Object.hasOwn(node.inputs, input) || !scalar(node.inputs[input]) || !scalar(value) || typeof node.inputs[input] !== typeof value) continue
const control = controls.get(`${nodeId}.${input}`)
if (!control || !validControlValue(control, value)) continue
node.inputs[input] = value
}
}
return JSON.stringify(workflow, null, 2)
}
export function getWorkflowImages(json: string, mappedNodeIds: string[], schemas?: ComfyObjectInfo) {
return Object.entries(parseParameterWorkflow(json) || {}).filter(([nodeId, node]) => {
if (mappedNodeIds.includes(nodeId) || typeof node.inputs.image !== 'string') return false
const definition = schemas?.[node.class_type]?.input?.required?.image ?? schemas?.[node.class_type]?.input?.optional?.image
return /^LoadImage(?:Goohai)?$/.test(node.class_type) || (schemas?.[node.class_type]?.output?.includes('IMAGE') && Array.isArray(definition) && Boolean((definition[1] as Record<string, unknown> | undefined)?.image_upload))
}).map(([nodeId, node]) => ({ nodeId, role: node._meta?.studio?.imageRole === 'character_sheet' ? 'character_sheet' as const : undefined, label: node._meta?.studio?.imageRole === 'character_sheet' ? '角色设定集' : typeof node._meta?.title === 'string' ? node._meta.title : `参考图 · ${nodeId}`, optional: node.class_type === 'LoadImageGoohai' })).sort((a, b) => Number(b.role === 'character_sheet') - Number(a.role === 'character_sheet'))
}
export function validateReferenceCombinations(json: string, uploadedNodeIds: string[]): string | null {
const workflow = parseParameterWorkflow(json) || {}
const declarations = Object.values(workflow).map((node) => node._meta?.studio?.referenceCombinations).filter((value): value is string[][] => Array.isArray(value) && value.length > 0 && value.every((row) => Array.isArray(row) && row.every((id) => typeof id === 'string')))
const selected = JSON.stringify([...new Set(uploadedNodeIds)].sort())
for (const combinations of declarations) {
if (combinations.some((combination) => JSON.stringify([...new Set(combination)].sort()) === selected)) continue
const label = (id: string) => workflow[id]?._meta?.studio?.imageRole === 'character_sheet' ? '角色设定集' : workflow[id]?._meta?.title || ('参考图 #' + id)
return '当前参考图组合不受此工作流支持,可用组合:' + combinations.map((combination) => combination.map(label).join('+')).join('、') + '。'
}
return null
}