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> restoreNamed: boolean } function setNodeScoped( graphMap: Map>, 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( graphMap: Map>, 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>()) const graphWidgetRenderStates = ref( new Map>() ) const graphNodeWidgetOrders = ref(new Map>()) const graphWidgetRestorations = new Map< UUID, Map >() 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 { const widgetStates = graphWidgetStates.value.get(graphId) if (widgetStates) return widgetStates const nextWidgetStates = reactive(new Map()) graphWidgetStates.value.set(graphId, nextWidgetStates) return nextWidgetStates } function getGraphWidgetRenderStates( graphId: UUID ): Map { const widgetRenderStates = graphWidgetRenderStates.value.get(graphId) if (widgetRenderStates) return widgetRenderStates const nextWidgetRenderStates = reactive( new Map() ) graphWidgetRenderStates.value.set(graphId, nextWidgetRenderStates) return nextWidgetRenderStates } function getGraphNodeWidgetOrders(graphId: UUID): Map { const widgetOrders = graphNodeWidgetOrders.value.get(graphId) if (widgetOrders) return widgetOrders const nextWidgetOrders = reactive(new Map()) 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([]) 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, renderState: WidgetRenderState = {}, _context?: RemoteMutationContext ): WidgetState | 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 } const state: WidgetState = { ...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 } 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 ): 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 } })