466 lines
15 KiB
TypeScript
466 lines
15 KiB
TypeScript
import { defineStore } from 'pinia'
|
|
import { reactive, ref } from 'vue'
|
|
|
|
import type { UUID } from '@/utils/uuid'
|
|
import { parseNodeId } from '@/types/nodeId'
|
|
import type { NodeId, SerializedNodeId } from '@/types/nodeId'
|
|
import { isWidgetId, parseWidgetId } from '@/types/widgetId'
|
|
import type { WidgetId } from '@/types/widgetId'
|
|
import type { WidgetValue } from '@/types/simplifiedWidget'
|
|
import type { WidgetState, WidgetStateInit } from '@/types/widgetState'
|
|
import type { RemoteMutationContext } from '@/types/graphMutationContext'
|
|
import type { IWidgetOptions } from '@/lib/litegraph/src/types/widgets'
|
|
|
|
export interface WidgetRenderState {
|
|
advanced?: boolean
|
|
hasLayoutSize?: boolean
|
|
isDOMWidget?: boolean
|
|
tooltip?: string
|
|
}
|
|
|
|
interface WidgetRestorationState {
|
|
positional: readonly WidgetValue[]
|
|
named?: Readonly<Record<string, WidgetValue>>
|
|
restoreNamed: boolean
|
|
}
|
|
|
|
function setNodeScoped<T>(
|
|
graphMap: Map<UUID, Map<NodeId, T>>,
|
|
graphId: UUID,
|
|
nodeId: NodeId,
|
|
value: T
|
|
): void {
|
|
let nodeMap = graphMap.get(graphId)
|
|
if (!nodeMap) {
|
|
nodeMap = new Map()
|
|
graphMap.set(graphId, nodeMap)
|
|
}
|
|
nodeMap.set(nodeId, value)
|
|
}
|
|
|
|
function clearNodeScoped<T>(
|
|
graphMap: Map<UUID, Map<NodeId, T>>,
|
|
graphId: UUID,
|
|
nodeId: NodeId
|
|
): void {
|
|
const nodeMap = graphMap.get(graphId)
|
|
if (!nodeMap) return
|
|
nodeMap.delete(nodeId)
|
|
if (nodeMap.size === 0) graphMap.delete(graphId)
|
|
}
|
|
|
|
export function stripGraphPrefix(scopedId: SerializedNodeId): NodeId | null {
|
|
return parseNodeId(String(scopedId).replace(/^(.*:)+/, ''))
|
|
}
|
|
|
|
export const useWidgetValueStore = defineStore('widgetValue', () => {
|
|
const graphWidgetStates = ref(new Map<UUID, Map<WidgetId, WidgetState>>())
|
|
const graphWidgetRenderStates = ref(
|
|
new Map<UUID, Map<WidgetId, WidgetRenderState>>()
|
|
)
|
|
const graphNodeWidgetOrders = ref(new Map<UUID, Map<NodeId, WidgetId[]>>())
|
|
const graphWidgetRestorations = new Map<
|
|
UUID,
|
|
Map<NodeId, WidgetRestorationState>
|
|
>()
|
|
|
|
function setNodeWidgetRestoration(
|
|
graphId: UUID,
|
|
nodeId: NodeId,
|
|
restoration: WidgetRestorationState
|
|
): void {
|
|
setNodeScoped(graphWidgetRestorations, graphId, nodeId, restoration)
|
|
}
|
|
|
|
function getRestoredWidgetValue(
|
|
graphId: UUID,
|
|
nodeId: NodeId,
|
|
name: string,
|
|
positionalIndex: number
|
|
): { value: WidgetValue } | undefined {
|
|
const restoration = graphWidgetRestorations.get(graphId)?.get(nodeId)
|
|
if (!restoration) return
|
|
if (restoration.restoreNamed && restoration.named) {
|
|
return Object.hasOwn(restoration.named, name)
|
|
? { value: restoration.named[name] }
|
|
: undefined
|
|
}
|
|
return positionalIndex < restoration.positional.length
|
|
? { value: restoration.positional[positionalIndex] }
|
|
: undefined
|
|
}
|
|
|
|
function clearNodeWidgetRestoration(graphId: UUID, nodeId: NodeId): void {
|
|
clearNodeScoped(graphWidgetRestorations, graphId, nodeId)
|
|
}
|
|
|
|
function getGraphWidgetStates(graphId: UUID): Map<WidgetId, WidgetState> {
|
|
const widgetStates = graphWidgetStates.value.get(graphId)
|
|
if (widgetStates) return widgetStates
|
|
|
|
const nextWidgetStates = reactive(new Map<WidgetId, WidgetState>())
|
|
graphWidgetStates.value.set(graphId, nextWidgetStates)
|
|
return nextWidgetStates
|
|
}
|
|
|
|
function getGraphWidgetRenderStates(
|
|
graphId: UUID
|
|
): Map<WidgetId, WidgetRenderState> {
|
|
const widgetRenderStates = graphWidgetRenderStates.value.get(graphId)
|
|
if (widgetRenderStates) return widgetRenderStates
|
|
|
|
const nextWidgetRenderStates = reactive(
|
|
new Map<WidgetId, WidgetRenderState>()
|
|
)
|
|
graphWidgetRenderStates.value.set(graphId, nextWidgetRenderStates)
|
|
return nextWidgetRenderStates
|
|
}
|
|
|
|
function getGraphNodeWidgetOrders(graphId: UUID): Map<NodeId, WidgetId[]> {
|
|
const widgetOrders = graphNodeWidgetOrders.value.get(graphId)
|
|
if (widgetOrders) return widgetOrders
|
|
|
|
const nextWidgetOrders = reactive(new Map<NodeId, WidgetId[]>())
|
|
graphNodeWidgetOrders.value.set(graphId, nextWidgetOrders)
|
|
return nextWidgetOrders
|
|
}
|
|
|
|
function getNodeWidgetOrder(graphId: UUID, nodeId: NodeId): WidgetId[] {
|
|
const graphOrders = getGraphNodeWidgetOrders(graphId)
|
|
const order = graphOrders.get(nodeId)
|
|
if (order) return order
|
|
|
|
const nextOrder = reactive<WidgetId[]>([])
|
|
graphOrders.set(nodeId, nextOrder)
|
|
return nextOrder
|
|
}
|
|
|
|
function appendNodeWidgetOrder(widgetId: WidgetId): void {
|
|
const { graphId, nodeId } = parseWidgetId(widgetId)
|
|
const order = getNodeWidgetOrder(graphId, nodeId)
|
|
if (!order.includes(widgetId)) order.push(widgetId)
|
|
}
|
|
|
|
function removeNodeWidgetOrder(widgetId: WidgetId): void {
|
|
const { graphId, nodeId } = parseWidgetId(widgetId)
|
|
const graphOrders = graphNodeWidgetOrders.value.get(graphId)
|
|
if (!graphOrders) return
|
|
const order = graphOrders.get(nodeId)
|
|
if (!order) return
|
|
|
|
const index = order.indexOf(widgetId)
|
|
if (index !== -1) order.splice(index, 1)
|
|
if (order.length === 0) graphOrders.delete(nodeId)
|
|
}
|
|
|
|
/**
|
|
* @returns The existing state for the same widget type, replacement state
|
|
* for a different type, or `undefined` for an invalid widget ID.
|
|
*/
|
|
function registerWidget<
|
|
TValue extends WidgetValue = WidgetValue,
|
|
TType extends string = string,
|
|
TOptions extends IWidgetOptions = IWidgetOptions
|
|
>(
|
|
widgetId: WidgetId,
|
|
init: WidgetStateInit<TValue, TType, TOptions>,
|
|
renderState: WidgetRenderState = {},
|
|
_context?: RemoteMutationContext
|
|
): WidgetState<TValue, TType, TOptions> | undefined {
|
|
if (!isWidgetId(widgetId)) {
|
|
console.warn(
|
|
'widgetValueStore.registerWidget: ignoring un-keyable widget id',
|
|
widgetId
|
|
)
|
|
return undefined
|
|
}
|
|
|
|
const existing = getWidget(widgetId)
|
|
const { graphId, nodeId, name: storageName } = parseWidgetId(widgetId)
|
|
if (existing && existing.type !== init.type) {
|
|
getGraphWidgetRenderStates(graphId).delete(widgetId)
|
|
}
|
|
registerWidgetRenderState(widgetId, renderState)
|
|
// WidgetId is `graphId:nodeId:name`. A node replacement can reuse the same
|
|
// numeric nodeId, so a stale entry from the previous occupant may survive in
|
|
// the store under the same key. The type check distinguishes a live
|
|
// re-registration (same widget, keep its value) from a recycled key (new
|
|
// widget type at an old address, overwrite). Without it a text widget
|
|
// rendered as the prior int type until the next full reload (#13073, #13773).
|
|
if (existing && existing.type === init.type) {
|
|
const value = existing.value
|
|
Object.assign(existing, init, {
|
|
name: init.name ?? storageName,
|
|
nodeId,
|
|
value,
|
|
y: init.y ?? existing.y
|
|
})
|
|
appendNodeWidgetOrder(widgetId)
|
|
return existing as WidgetState<TValue, TType, TOptions>
|
|
}
|
|
|
|
const state: WidgetState<TValue, TType, TOptions> = {
|
|
...init,
|
|
nodeId,
|
|
name: init.name ?? storageName,
|
|
y: init.y ?? 0
|
|
}
|
|
const widgetStates = getGraphWidgetStates(graphId)
|
|
widgetStates.set(widgetId, state)
|
|
appendNodeWidgetOrder(widgetId)
|
|
return widgetStates.get(widgetId) as WidgetState<TValue, TType, TOptions>
|
|
}
|
|
|
|
function registerWidgetRenderState(
|
|
widgetId: WidgetId,
|
|
init: WidgetRenderState
|
|
): WidgetRenderState {
|
|
const { graphId } = parseWidgetId(widgetId)
|
|
const widgetRenderStates = getGraphWidgetRenderStates(graphId)
|
|
const existing = widgetRenderStates.get(widgetId)
|
|
if (existing) {
|
|
Object.assign(existing, init)
|
|
return existing
|
|
}
|
|
|
|
const state: WidgetRenderState = { ...init }
|
|
widgetRenderStates.set(widgetId, state)
|
|
return widgetRenderStates.get(widgetId) as WidgetRenderState
|
|
}
|
|
|
|
function getWidget(widgetId: WidgetId): WidgetState | undefined {
|
|
if (!isWidgetId(widgetId)) return undefined
|
|
|
|
const { graphId } = parseWidgetId(widgetId)
|
|
return graphWidgetStates.value.get(graphId)?.get(widgetId)
|
|
}
|
|
|
|
function getWidgetRenderState(
|
|
widgetId: WidgetId
|
|
): WidgetRenderState | undefined {
|
|
if (!isWidgetId(widgetId)) return undefined
|
|
|
|
const { graphId } = parseWidgetId(widgetId)
|
|
return graphWidgetRenderStates.value.get(graphId)?.get(widgetId)
|
|
}
|
|
|
|
function setValue(
|
|
widgetId: WidgetId,
|
|
value: WidgetState['value'],
|
|
_context?: RemoteMutationContext
|
|
): boolean {
|
|
const state = getWidget(widgetId)
|
|
if (!state) return false
|
|
state.value = value
|
|
return true
|
|
}
|
|
|
|
function setLabel(widgetId: WidgetId, label: string): boolean {
|
|
const state = getWidget(widgetId)
|
|
if (!state) return false
|
|
state.label = label
|
|
return true
|
|
}
|
|
|
|
function updateOptions(
|
|
widgetId: WidgetId,
|
|
options: Partial<WidgetState['options']>
|
|
): boolean {
|
|
const state = getWidget(widgetId)
|
|
if (!state) return false
|
|
state.options = { ...state.options, ...options }
|
|
return true
|
|
}
|
|
|
|
function deleteWidget(widgetId: WidgetId): boolean {
|
|
if (!isWidgetId(widgetId)) return false
|
|
|
|
const { graphId } = parseWidgetId(widgetId)
|
|
graphWidgetRenderStates.value.get(graphId)?.delete(widgetId)
|
|
removeNodeWidgetOrder(widgetId)
|
|
return graphWidgetStates.value.get(graphId)?.delete(widgetId) ?? false
|
|
}
|
|
|
|
function renameWidget(
|
|
oldId: WidgetId,
|
|
newId: WidgetId
|
|
): WidgetState | undefined {
|
|
if (!isWidgetId(oldId) || !isWidgetId(newId)) return undefined
|
|
if (oldId === newId) return getWidget(oldId)
|
|
|
|
const previous = parseWidgetId(oldId)
|
|
const next = parseWidgetId(newId)
|
|
if (previous.graphId !== next.graphId) return undefined
|
|
if (previous.nodeId !== next.nodeId) return undefined
|
|
|
|
const { graphId, nodeId, name } = next
|
|
const widgetStates = getGraphWidgetStates(graphId)
|
|
const state = widgetStates.get(oldId)
|
|
if (!state) return undefined
|
|
if (widgetStates.has(newId)) return undefined
|
|
|
|
const renderStates = getGraphWidgetRenderStates(graphId)
|
|
const renderState = renderStates.get(oldId)
|
|
const order = getNodeWidgetOrder(graphId, nodeId)
|
|
const index = order.indexOf(oldId)
|
|
|
|
widgetStates.delete(oldId)
|
|
renderStates.delete(oldId)
|
|
if (index !== -1) order.splice(index, 1)
|
|
|
|
state.name = name
|
|
widgetStates.set(newId, state)
|
|
if (renderState) renderStates.set(newId, renderState)
|
|
if (index !== -1) order.splice(index, 0, newId)
|
|
else if (!order.includes(newId)) order.push(newId)
|
|
|
|
return widgetStates.get(newId)
|
|
}
|
|
|
|
function getNodeWidgets(graphId: UUID, localNodeId: NodeId): WidgetState[] {
|
|
return getNodeWidgetIds(graphId, localNodeId).flatMap((id) => {
|
|
const state = getWidget(id)
|
|
return state ? [state] : []
|
|
})
|
|
}
|
|
|
|
/**
|
|
* Merges a requested widget order against the ids already tracked for the
|
|
* node: the request is filtered to tracked ids, then any tracked id the
|
|
* request omitted is appended. Tracked ids are never dropped here — only
|
|
* {@link removeNodeWidgetOrder} removes an id from the order.
|
|
*/
|
|
function reconcileNodeWidgetOrder(
|
|
graphId: UUID,
|
|
localNodeId: NodeId,
|
|
orderedWidgetIds: readonly WidgetId[]
|
|
): WidgetId[] {
|
|
const currentOrder = getNodeWidgetIds(graphId, localNodeId)
|
|
const currentIds = new Set(currentOrder)
|
|
const nextOrder = orderedWidgetIds.filter((id) => currentIds.has(id))
|
|
const nextIds = new Set(nextOrder)
|
|
return [...nextOrder, ...currentOrder.filter((id) => !nextIds.has(id))]
|
|
}
|
|
|
|
function getNodeWidgetIds(graphId: UUID, localNodeId: NodeId): WidgetId[] {
|
|
return [
|
|
...(graphNodeWidgetOrders.value.get(graphId)?.get(localNodeId) ?? [])
|
|
]
|
|
}
|
|
|
|
function setNodeWidgetOrder(
|
|
graphId: UUID,
|
|
localNodeId: NodeId,
|
|
orderedWidgetIds: readonly WidgetId[]
|
|
): void {
|
|
const nextOrder = reconcileNodeWidgetOrder(
|
|
graphId,
|
|
localNodeId,
|
|
orderedWidgetIds
|
|
)
|
|
const order = getNodeWidgetOrder(graphId, localNodeId)
|
|
order.splice(0, order.length, ...nextOrder)
|
|
}
|
|
|
|
function replaceNodeWidgetOrder(
|
|
graphId: UUID,
|
|
localNodeId: NodeId,
|
|
orderedWidgetIds: readonly WidgetId[]
|
|
): void {
|
|
const widgetStates = getGraphWidgetStates(graphId)
|
|
const nextOrder = orderedWidgetIds.filter(
|
|
(id) => widgetStates.get(id)?.nodeId === localNodeId
|
|
)
|
|
const graphOrders = getGraphNodeWidgetOrders(graphId)
|
|
const order = graphOrders.get(localNodeId)
|
|
|
|
if (nextOrder.length === 0) {
|
|
graphOrders.delete(localNodeId)
|
|
} else if (order) {
|
|
order.splice(0, order.length, ...nextOrder)
|
|
} else {
|
|
graphOrders.set(localNodeId, reactive([...nextOrder]))
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Releases the widget ids tracked for a node, from the store's own record
|
|
* rather than the node's live widget list — the two diverge once a node drops
|
|
* widgets without unregistering them. `discardValues` also drops the widget
|
|
* states; retaining them lets a node that comes back keep what the user set.
|
|
*/
|
|
function releaseNodeWidgets(
|
|
graphId: UUID,
|
|
localNodeId: NodeId,
|
|
{ discardValues }: { discardValues: boolean }
|
|
): void {
|
|
const graphOrders = graphNodeWidgetOrders.value.get(graphId)
|
|
if (!graphOrders) return
|
|
|
|
const order = graphOrders.get(localNodeId)
|
|
if (!order) return
|
|
|
|
if (discardValues) {
|
|
for (const widgetId of order) {
|
|
graphWidgetStates.value.get(graphId)?.delete(widgetId)
|
|
graphWidgetRenderStates.value.get(graphId)?.delete(widgetId)
|
|
}
|
|
}
|
|
graphOrders.delete(localNodeId)
|
|
}
|
|
|
|
function clearNode(
|
|
graphId: UUID,
|
|
nodeId: NodeId,
|
|
_context?: RemoteMutationContext
|
|
): void {
|
|
graphWidgetRestorations.get(graphId)?.delete(nodeId)
|
|
const widgetStates = graphWidgetStates.value.get(graphId)
|
|
const widgetRenderStates = graphWidgetRenderStates.value.get(graphId)
|
|
if (widgetStates) {
|
|
for (const [id, state] of widgetStates) {
|
|
if (state.nodeId !== nodeId) continue
|
|
widgetStates.delete(id)
|
|
widgetRenderStates?.delete(id)
|
|
}
|
|
if (widgetStates.size === 0) graphWidgetStates.value.delete(graphId)
|
|
}
|
|
if (widgetRenderStates?.size === 0) {
|
|
graphWidgetRenderStates.value.delete(graphId)
|
|
}
|
|
|
|
const widgetOrders = graphNodeWidgetOrders.value.get(graphId)
|
|
widgetOrders?.delete(nodeId)
|
|
if (widgetOrders?.size === 0) graphNodeWidgetOrders.value.delete(graphId)
|
|
}
|
|
|
|
function clearGraph(graphId: UUID): void {
|
|
graphWidgetStates.value.delete(graphId)
|
|
graphWidgetRenderStates.value.delete(graphId)
|
|
graphNodeWidgetOrders.value.delete(graphId)
|
|
graphWidgetRestorations.delete(graphId)
|
|
}
|
|
|
|
return {
|
|
registerWidget,
|
|
setNodeWidgetRestoration,
|
|
clearNodeWidgetRestoration,
|
|
getRestoredWidgetValue,
|
|
getWidget,
|
|
getWidgetRenderState,
|
|
setValue,
|
|
setLabel,
|
|
updateOptions,
|
|
deleteWidget,
|
|
renameWidget,
|
|
getNodeWidgets,
|
|
getNodeWidgetIds,
|
|
setNodeWidgetOrder,
|
|
replaceNodeWidgetOrder,
|
|
removeNodeWidgetOrder,
|
|
releaseNodeWidgets,
|
|
clearNode,
|
|
clearGraph
|
|
}
|
|
})
|