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

258 lines
6.5 KiB
TypeScript

import type {
ExportedSubgraph,
ISerialisedGraph,
ISerialisedNode,
SerialisableGraph
} from './types/serialisation'
type JsonValue = null | boolean | number | string | JsonValue[] | JsonObject
type JsonObject = { [key: string]: JsonValue }
type ExtensionPayload = Record<string, JsonValue>
interface ExtensionState {
legacy: ExtensionPayload
namespaced: ExtensionPayload
}
const payloads = new WeakMap<object, ExtensionState>()
function safeCloneExtensionValue(value: unknown): JsonValue | undefined {
let clonedValue: unknown
try {
clonedValue = structuredClone(value)
} catch (error) {
if (!(error instanceof Error) || error.name !== 'DataCloneError')
throw error
try {
clonedValue = JSON.parse(JSON.stringify(value))
} catch {
return
}
}
return isJsonValue(clonedValue) ? clonedValue : undefined
}
function readClonedEntry(source: object, key: string): JsonValue | undefined {
try {
return safeCloneExtensionValue(Reflect.get(source, key))
} catch {
return undefined
}
}
const nodeCanonicalFields = {
title: true,
id: true,
type: true,
pos: true,
size: true,
flags: true,
order: true,
mode: true,
outputs: true,
inputs: true,
properties: true,
shape: true,
boxcolor: true,
color: true,
bgcolor: true,
showAdvanced: true,
widgets_values: true,
widgets_values_named: true
} satisfies Record<Exclude<keyof ISerialisedNode, 'extensions'>, true>
export const NODE_CANONICAL_FIELDS: ReadonlySet<string> = new Set(
Object.keys(nodeCanonicalFields)
)
type GraphCanonicalField = Exclude<
keyof (SerialisableGraph & ExportedSubgraph & ISerialisedGraph),
'extensions'
>
const graphCanonicalFields = {
id: true,
revision: true,
config: true,
subgraphs: true,
definitions: true,
version: true,
state: true,
last_node_id: true,
last_link_id: true,
groups: true,
nodes: true,
links: true,
floatingLinks: true,
reroutes: true,
extra: true,
name: true,
category: true,
description: true,
inputNode: true,
outputNode: true,
inputs: true,
outputs: true,
widgets: true
} satisfies Record<GraphCanonicalField, true>
export const GRAPH_CANONICAL_FIELDS: ReadonlySet<string> = new Set(
Object.keys(graphCanonicalFields)
)
const isJsonValue = (
value: unknown,
ancestors = new WeakSet<object>()
): value is JsonValue => {
if (value === null || typeof value === 'string' || typeof value === 'boolean')
return true
if (typeof value === 'number') return Number.isFinite(value)
if (typeof value !== 'object') return false
if (ancestors.has(value)) return false
const prototype = Object.getPrototypeOf(value)
if (
!Array.isArray(value) &&
prototype !== Object.prototype &&
prototype !== null
)
return false
ancestors.add(value)
const isJson = Object.values(value).every((entry) =>
isJsonValue(entry, ancestors)
)
ancestors.delete(value)
return isJson
}
const isSafeExtensionKey = (key: string): boolean => key !== '__proto__'
const readPayload = (value: unknown): ExtensionPayload => {
if (value === undefined) return {}
if (value === null || typeof value !== 'object' || Array.isArray(value)) {
console.warn('LiteGraph: ignoring non-serializable extension payload')
return {}
}
let keys: string[]
try {
keys = Object.keys(value)
} catch {
console.warn('LiteGraph: ignoring non-serializable extension payload')
return {}
}
const payload: ExtensionPayload = {}
for (const key of keys) {
if (!isSafeExtensionKey(key)) continue
const clonedEntry = readClonedEntry(value, key)
if (clonedEntry !== undefined) {
payload[key] = clonedEntry
} else {
console.warn('LiteGraph: ignoring non-serializable extension payload')
}
}
return payload
}
function readNamespacedPayload(source: object): ExtensionPayload {
try {
return readPayload(Reflect.get(source, 'extensions'))
} catch {
console.warn('LiteGraph: ignoring non-serializable extension payload')
return {}
}
}
function readExtensionFields(
source: object,
canonicalFields: ReadonlySet<string>
): ExtensionPayload {
const payload: ExtensionPayload = {}
for (const key of Object.keys(source)) {
if (
!isSafeExtensionKey(key) ||
canonicalFields.has(key) ||
key === 'extensions'
) {
continue
}
const clonedValue = readClonedEntry(source, key)
if (clonedValue !== undefined) {
payload[key] = clonedValue
} else {
console.warn('LiteGraph: ignoring non-serializable extension payload')
}
}
return payload
}
export const hydrateExtensionPayload = (
owner: object,
data: object,
canonicalFields: ReadonlySet<string>
): void => {
const previous = payloads.get(owner)
for (const key of Object.keys(previous?.legacy ?? {}))
Reflect.deleteProperty(owner, key)
const namespaced = readNamespacedPayload(data)
const legacyFields = readExtensionFields(data, canonicalFields)
Object.assign(owner, structuredClone(legacyFields))
for (const key of Object.keys(legacyFields)) delete namespaced[key]
payloads.set(owner, { legacy: legacyFields, namespaced })
}
export const runExtensionSerializeHook = <T extends object>(
owner: object,
canonical: T,
canonicalFields: ReadonlySet<string>,
hook?: (data: T) => unknown
): T => {
const state = payloads.get(owner) ?? { legacy: {}, namespaced: {} }
if (
!hook &&
Object.keys(state.legacy).length === 0 &&
Object.keys(state.namespaced).length === 0
)
return canonical
const view = canonical
Object.assign(view, structuredClone(state.legacy), {
extensions: structuredClone({ ...state.namespaced, ...state.legacy })
})
hook?.(view)
for (const key of canonicalFields) {
if (Object.hasOwn(view, key)) {
Reflect.set(canonical, key, Reflect.get(view, key))
} else {
Reflect.deleteProperty(canonical, key)
}
}
const namespaced = readNamespacedPayload(view)
const legacy = readExtensionFields(view, canonicalFields)
for (const key of Object.keys(legacy)) delete namespaced[key]
payloads.set(owner, { legacy, namespaced })
const extensions = { ...namespaced, ...legacy }
if (Object.keys(extensions).length)
return Object.assign(canonical, {
extensions: structuredClone(extensions)
})
Reflect.deleteProperty(canonical, 'extensions')
return canonical
}
export const extensionConfigureView = <T extends object>(
owner: object,
canonical: T
): T =>
Object.assign(
{ ...canonical },
structuredClone(payloads.get(owner)?.namespaced),
structuredClone(payloads.get(owner)?.legacy)
)