Skip to content

AI-native design editor. Open-source Figma alternative.

refactor(scene-graph): share component property operations

Danila Poyarkov7bda8cc17a3e
diff --git a/packages/core/src/editor/components/properties.ts b/packages/core/src/editor/components/properties.ts
index af7301ab2..40c37e044 100644
--- a/packages/core/src/editor/components/properties.ts
+++ b/packages/core/src/editor/components/properties.ts
@@ -1,3 +1,9 @@
+import {
+ applyComponentPropertyValue,
+ componentPropertyDefinitions,
+ findComponentPropertyTarget,
+ resolveComponentPropertyValue
+} from '@open-pencil/scene-graph'
import type {
ComponentPropertyDefinition,
ComponentPropertyReferenceField,
@@ -13,57 +19,11 @@ interface PropertyTarget {
source: SceneNode
}
-function definitionOwners(ctx: Pick<EditorContext, 'graph'>, instance: SceneNode): SceneNode[] {
- if (!instance.componentId) return []
- const component = ctx.graph.getNode(instance.componentId)
- if (!component) return []
- const parent = component.parentId ? ctx.graph.getNode(component.parentId) : null
- return parent?.type === 'COMPONENT_SET' ? [parent, component] : [component]
-}
-
function definitionsForInstance(
ctx: Pick<EditorContext, 'graph'>,
instance: SceneNode
): ComponentPropertyDefinition[] {
- const byId = new Map<string, ComponentPropertyDefinition>()
- for (const owner of definitionOwners(ctx, instance)) {
- for (const definition of owner.componentPropertyDefinitions) {
- if (!byId.has(definition.id)) byId.set(definition.id, definition)
- }
- }
- return [...byId.values()]
-}
-
-function findPropertyPath(
- ctx: Pick<EditorContext, 'graph'>,
- sourceParent: SceneNode,
- propertyId: string,
- path: number[] = []
-): { path: number[]; field: ComponentPropertyReferenceField; source: SceneNode } | null {
- for (const [index, childId] of sourceParent.childIds.entries()) {
- const child = ctx.graph.getNode(childId)
- if (!child) continue
- const reference = child.componentPropertyReferences.find((ref) => ref.propertyId === propertyId)
- if (reference) return { path: [...path, index], field: reference.field, source: child }
- const nested = findPropertyPath(ctx, child, propertyId, [...path, index])
- if (nested) return nested
- }
- return null
-}
-
-function nodeAtPath(
- ctx: Pick<EditorContext, 'graph'>,
- root: SceneNode,
- path: number[]
-): SceneNode | null {
- let node = root
- for (const index of path) {
- const childId = node.childIds[index]
- const child = childId ? ctx.graph.getNode(childId) : undefined
- if (!child) return null
- node = child
- }
- return node
+ return componentPropertyDefinitions(ctx.graph, instance)
}
function propertyTarget(
@@ -71,28 +31,12 @@ function propertyTarget(
instance: SceneNode,
propertyId: string
): PropertyTarget | null {
- const component = instance.componentId ? ctx.graph.getNode(instance.componentId) : null
- if (!component) return null
- const match = findPropertyPath(ctx, component, propertyId)
- if (!match) return null
- const node = nodeAtPath(ctx, instance, match.path)
- return node ? { node, field: match.field, source: match.source } : null
+ const target = findComponentPropertyTarget(ctx.graph, instance, propertyId)
+ return target
}
function swapTargetId(ctx: Pick<EditorContext, 'graph'>, value: string): string | null {
- const direct = ctx.graph.getNode(value)
- if (direct?.type === 'COMPONENT') return direct.id
- for (const node of ctx.graph.getAllNodes()) {
- if (node.type !== 'COMPONENT') continue
- if (
- node.source.id === value ||
- node.componentKey === value ||
- node.sourceLibraryKey === value
- ) {
- return node.id
- }
- }
- return null
+ return resolveComponentPropertyValue(ctx.graph, value)?.id ?? null
}
function targetValue(target: PropertyTarget | null): string {
@@ -101,63 +45,13 @@ function targetValue(target: PropertyTarget | null): string {
if (target.field === 'VISIBLE') return String(target.node.visible)
return target.source.componentId ?? target.node.componentId ?? ''
}
-
-function propertyOverrides(
- ctx: Pick<EditorContext, 'graph'>,
- instance: SceneNode,
- target: PropertyTarget | null,
- value: string,
- swapComponentId: string | null
-): Record<string, unknown> {
- const overrides = { ...instance.overrides }
- if (target?.field === 'TEXT') overrides[`${target.node.id}:text`] = value
- else if (target?.field === 'VISIBLE') overrides[`${target.node.id}:visible`] = value === 'true'
- else if (target?.field === 'INSTANCE_SWAP') {
- overrides[`${target.node.id}:componentId`] = value
- overrides[`${target.node.id}:sourceComponentId`] = target.source.id
- const componentName = swapComponentId ? ctx.graph.getNode(swapComponentId)?.name : undefined
- if (componentName) overrides[`${target.node.id}:name`] = componentName
- }
- return overrides
-}
-
-function updatePropertyTarget(
- ctx: Pick<EditorContext, 'graph'>,
- target: PropertyTarget | null,
- value: string,
- swapComponentId: string | null
-): void {
- if (target?.field === 'TEXT' && target.node.type === 'TEXT') {
- ctx.graph.updateNode(target.node.id, { text: value })
- } else if (target?.field === 'VISIBLE') {
- ctx.graph.updateNode(target.node.id, { visible: value === 'true' })
- } else if (
- target?.field === 'INSTANCE_SWAP' &&
- target.node.type === 'INSTANCE' &&
- swapComponentId
- ) {
- ctx.graph.swapInstanceComponent(target.node.id, swapComponentId)
- }
-}
-
function applyPropertyValue(
ctx: Pick<EditorContext, 'graph'>,
instanceId: string,
definition: ComponentPropertyDefinition,
value: string
): void {
- const instance = ctx.graph.getNode(instanceId)
- if (instance?.type !== 'INSTANCE') return
- const target = propertyTarget(ctx, instance, definition.id)
- const swapComponentId = target?.field === 'INSTANCE_SWAP' ? swapTargetId(ctx, value) : null
- ctx.graph.updateNode(instance.id, {
- componentPropertyAssignments: {
- ...instance.componentPropertyAssignments,
- [definition.id]: value
- },
- overrides: propertyOverrides(ctx, instance, target, value, swapComponentId)
- })
- updatePropertyTarget(ctx, target, value, swapComponentId)
+ applyComponentPropertyValue(ctx.graph, instanceId, definition, value)
}
export function reapplyInstanceComponentProperties(
diff --git a/packages/scene-graph/src/component-properties.ts b/packages/scene-graph/src/component-properties.ts
new file mode 100644
index 000000000..e64f825d2
--- /dev/null
+++ b/packages/scene-graph/src/component-properties.ts
@@ -0,0 +1,167 @@
+import type { SceneGraph } from './index'
+import type {
+ ComponentPropertyDefinition,
+ ComponentPropertyReferenceField,
+ SceneNode
+} from './types'
+
+export interface ComponentPropertyTarget {
+ node: SceneNode
+ field: ComponentPropertyReferenceField
+ source: SceneNode
+}
+
+export function componentPropertyOwners(graph: SceneGraph, instance: SceneNode): SceneNode[] {
+ if (instance.type !== 'INSTANCE' || !instance.componentId) return []
+ const component = graph.getNode(instance.componentId)
+ if (!component) return []
+ const parent = component.parentId ? graph.getNode(component.parentId) : null
+ return parent?.type === 'COMPONENT_SET' ? [parent, component] : [component]
+}
+
+export function componentPropertyDefinitions(
+ graph: SceneGraph,
+ instance: SceneNode
+): ComponentPropertyDefinition[] {
+ const definitions = new Map<string, ComponentPropertyDefinition>()
+ for (const owner of componentPropertyOwners(graph, instance)) {
+ for (const definition of owner.componentPropertyDefinitions) {
+ if (!definitions.has(definition.id)) definitions.set(definition.id, definition)
+ }
+ }
+ return [...definitions.values()]
+}
+
+export function resolveComponentPropertyValue(graph: SceneGraph, value: string): SceneNode | null {
+ const direct = graph.getNode(value)
+ if (direct?.type === 'COMPONENT') return direct
+ if (direct?.type === 'COMPONENT_SET') {
+ const componentId = direct.childIds.find((id) => graph.getNode(id)?.type === 'COMPONENT')
+ return componentId ? (graph.getNode(componentId) ?? null) : null
+ }
+ return (
+ [...graph.getAllNodes()].find(
+ (node) =>
+ node.type === 'COMPONENT' &&
+ (node.componentKey === value || node.sourceLibraryKey === value || node.source.id === value)
+ ) ?? null
+ )
+}
+
+export function findComponentPropertyTarget(
+ graph: SceneGraph,
+ instance: SceneNode,
+ propertyId: string
+): ComponentPropertyTarget | null {
+ return findComponentPropertyTargets(graph, instance, propertyId)[0] ?? null
+}
+
+export function findComponentPropertyTargets(
+ graph: SceneGraph,
+ instance: SceneNode,
+ propertyId: string
+): ComponentPropertyTarget[] {
+ if (instance.type !== 'INSTANCE' || !instance.componentId) return []
+ const component = graph.getNode(instance.componentId)
+ if (!component) return []
+ const targets: ComponentPropertyTarget[] = []
+ const visit = (sourceParent: SceneNode, instanceParent: SceneNode): void => {
+ for (const [index, childId] of sourceParent.childIds.entries()) {
+ const source = graph.getNode(childId)
+ const targetId = instanceParent.childIds[index]
+ const target = targetId ? graph.getNode(targetId) : undefined
+ if (!source || !target) continue
+ const reference = source.componentPropertyReferences.find(
+ (candidate) => candidate.propertyId === propertyId
+ )
+ if (reference) targets.push({ node: target, field: reference.field, source })
+ visit(source, target)
+ }
+ }
+ visit(component, instance)
+ return targets
+}
+
+export function applyComponentPropertyValue(
+ graph: SceneGraph,
+ instanceId: string,
+ definition: ComponentPropertyDefinition,
+ value: string
+): SceneNode | null {
+ const instance = graph.getNode(instanceId)
+ if (instance?.type !== 'INSTANCE') return null
+ const targets = findComponentPropertyTargets(graph, instance, definition.id)
+ const target =
+ definition.type === 'INSTANCE_SWAP' ? resolveComponentPropertyValue(graph, value) : null
+ if (definition.type === 'INSTANCE_SWAP' && !target) return null
+ const overrides = { ...instance.overrides }
+ if (definition.type === 'TEXT') {
+ for (const item of targets) {
+ if (item.field === 'TEXT' && item.node.type === 'TEXT') {
+ graph.updateNode(item.node.id, { text: value })
+ overrides[`${item.node.id}:text`] = value
+ }
+ }
+ } else if (definition.type === 'BOOLEAN') {
+ for (const item of targets) {
+ if (item.field === 'VISIBLE') {
+ graph.updateNode(item.node.id, { visible: value === 'true' })
+ overrides[`${item.node.id}:visible`] = value === 'true'
+ }
+ }
+ } else if (definition.type === 'INSTANCE_SWAP' && target) {
+ for (const item of targets) {
+ if (item.field !== 'INSTANCE_SWAP' || item.node.type !== 'INSTANCE') continue
+ graph.swapInstanceComponent(item.node.id, target.id)
+ graph.updateNode(item.node.id, {
+ name: target.name,
+ overrides: {
+ ...item.node.overrides,
+ [`${item.node.id}:name`]: target.name
+ }
+ })
+ overrides[`${item.node.id}:componentId`] = target.id
+ overrides[`${item.node.id}:sourceComponentId`] = item.source.id
+ overrides[`${item.node.id}:name`] = target.name
+ }
+ }
+ graph.updateNode(instance.id, {
+ componentPropertyAssignments: {
+ ...instance.componentPropertyAssignments,
+ [definition.id]: definition.type === 'INSTANCE_SWAP' && target ? target.id : value
+ },
+ overrides
+ })
+ return target
+}
+
+export function removeComponentProperty(
+ graph: SceneGraph,
+ ownerId: string,
+ propertyId: string
+): boolean {
+ const owner = graph.getNode(ownerId)
+ if (!owner || (owner.type !== 'COMPONENT' && owner.type !== 'COMPONENT_SET')) return false
+ graph.updateNode(owner.id, {
+ componentPropertyDefinitions: owner.componentPropertyDefinitions.filter(
+ (definition) => definition.id !== propertyId
+ )
+ })
+ for (const node of graph.getAllNodes()) {
+ if (node.componentPropertyReferences.some((reference) => reference.propertyId === propertyId)) {
+ graph.updateNode(node.id, {
+ componentPropertyReferences: node.componentPropertyReferences.filter(
+ (reference) => reference.propertyId !== propertyId
+ )
+ })
+ }
+ if (node.type === 'INSTANCE' && propertyId in node.componentPropertyAssignments) {
+ graph.updateNode(node.id, {
+ componentPropertyAssignments: Object.fromEntries(
+ Object.entries(node.componentPropertyAssignments).filter(([id]) => id !== propertyId)
+ )
+ })
+ }
+ }
+ return true
+}
diff --git a/packages/scene-graph/src/index.ts b/packages/scene-graph/src/index.ts
index 352eafb02..f9af9a0b0 100644
--- a/packages/scene-graph/src/index.ts
+++ b/packages/scene-graph/src/index.ts
@@ -1,5 +1,5 @@
/* eslint-disable max-lines -- SceneGraph exposes a stable facade over domain modules */
-export * from './images'
+export * from './component-properties'
export * from './copy'
export { copyInstanceComponentProps } from './instances'
export * from './snap'
diff --git a/tests/engine/scene-graph/component-properties.test.ts b/tests/engine/scene-graph/component-properties.test.ts
new file mode 100644
index 000000000..213db3027
--- /dev/null
+++ b/tests/engine/scene-graph/component-properties.test.ts
@@ -0,0 +1,127 @@
+import { describe, expect, test } from 'bun:test'
+
+import {
+ applyComponentPropertyValue,
+ componentPropertyDefinitions,
+ componentPropertyOwners,
+ findComponentPropertyTarget,
+ removeComponentProperty,
+ resolveComponentPropertyValue,
+ SceneGraph
+} from '@open-pencil/scene-graph'
+
+function component(
+ graph: SceneGraph,
+ name: string,
+ parentId: string
+): ReturnType<SceneGraph['createNode']> {
+ return graph.createNode('COMPONENT', parentId, { name })
+}
+
+describe('component properties', () => {
+ test('resolves component and component-set owners and definitions', () => {
+ const graph = new SceneGraph()
+ const page = graph.getPages()[0]
+ const first = component(graph, 'Button/Default', page.id)
+ const second = component(graph, 'Button/Hover', page.id)
+ const set = graph.createNode('COMPONENT_SET', page.id)
+ graph.reparentNode(first.id, set.id)
+ graph.reparentNode(second.id, set.id)
+ const instance = graph.createInstance(first.id, page.id)
+ if (!instance) throw new Error('instance creation failed')
+ graph.updateNode(set.id, {
+ componentPropertyDefinitions: [
+ { id: 'prop:state', name: 'State', type: 'VARIANT', defaultValue: 'Default' }
+ ]
+ })
+
+ expect(componentPropertyOwners(graph, instance).map((node) => node.id)).toEqual([
+ set.id,
+ first.id
+ ])
+ expect(
+ componentPropertyDefinitions(graph, instance).map((definition) => definition.id)
+ ).toEqual(['prop:state'])
+ })
+
+ test('resolves component IDs, keys, library keys, and component-set defaults', () => {
+ const graph = new SceneGraph()
+ const page = graph.getPages()[0]
+ const icon = component(graph, 'Icon', page.id)
+ const keyed = component(graph, 'Keyed', page.id)
+ graph.updateNode(keyed.id, { componentKey: 'icon-key' })
+ const set = graph.createNode('COMPONENT_SET', page.id)
+ graph.reparentNode(icon.id, set.id)
+
+ expect(resolveComponentPropertyValue(graph, keyed.id)?.id).toBe(keyed.id)
+ expect(resolveComponentPropertyValue(graph, 'icon-key')?.id).toBe(keyed.id)
+ expect(resolveComponentPropertyValue(graph, set.id)?.id).toBe(icon.id)
+ })
+
+ test('applies text, boolean, and instance-swap properties to nested targets', () => {
+ const graph = new SceneGraph()
+ const page = graph.getPages()[0]
+ const host = component(graph, 'Host', page.id)
+ const icon = component(graph, 'Icon', page.id)
+ const alternate = component(graph, 'Alternate', page.id)
+ const slot = graph.createInstance(icon.id, host.id)
+ if (!slot) throw new Error('slot creation failed')
+ graph.updateNode(host.id, {
+ componentPropertyDefinitions: [
+ { id: 'prop:swap', name: 'Icon', type: 'INSTANCE_SWAP', defaultValue: icon.id },
+ { id: 'prop:text', name: 'Label', type: 'TEXT', defaultValue: '' },
+ { id: 'prop:visible', name: 'Visible', type: 'BOOLEAN', defaultValue: 'true' }
+ ]
+ })
+ graph.updateNode(slot.id, {
+ componentPropertyReferences: [
+ { propertyId: 'prop:swap', field: 'INSTANCE_SWAP' },
+ { propertyId: 'prop:text', field: 'TEXT' },
+ { propertyId: 'prop:visible', field: 'VISIBLE' }
+ ]
+ })
+ const instance = graph.createInstance(host.id, page.id)
+ if (!instance) throw new Error('host instance creation failed')
+ const text = graph.createNode('TEXT', slot.id)
+ graph.updateNode(text.id, {
+ componentPropertyReferences: [{ propertyId: 'prop:text', field: 'TEXT' }]
+ })
+
+ const swapDefinition = host.componentPropertyDefinitions[0]
+ const swapped = applyComponentPropertyValue(graph, instance.id, swapDefinition, alternate.id)
+ expect(swapped?.id).toBe(alternate.id)
+ const updatedInstance = graph.getNode(instance.id)
+ expect(updatedInstance?.componentPropertyAssignments['prop:swap']).toBe(alternate.id)
+ expect(
+ Object.keys(updatedInstance?.overrides ?? {}).some((key) => key.endsWith(':componentId'))
+ ).toBe(true)
+ const target = findComponentPropertyTarget(graph, instance, 'prop:swap')?.node
+ expect(target?.type).toBe('INSTANCE')
+ expect(target?.componentId).toBe(alternate.id)
+ })
+
+ test('removes definitions, references, and assignments', () => {
+ const graph = new SceneGraph()
+ const page = graph.getPages()[0]
+ const host = component(graph, 'Host', page.id)
+ const icon = component(graph, 'Icon', page.id)
+ const slot = graph.createInstance(icon.id, host.id)
+ if (!slot) throw new Error('slot creation failed')
+ graph.updateNode(host.id, {
+ componentPropertyDefinitions: [
+ { id: 'prop:swap', name: 'Icon', type: 'INSTANCE_SWAP', defaultValue: icon.id }
+ ]
+ })
+ graph.updateNode(slot.id, {
+ componentPropertyReferences: [{ propertyId: 'prop:swap', field: 'INSTANCE_SWAP' }]
+ })
+ const instance = graph.createInstance(host.id, page.id)
+ if (!instance) throw new Error('instance creation failed')
+ graph.updateNode(instance.id, { componentPropertyAssignments: { 'prop:swap': icon.id } })
+
+ expect(removeComponentProperty(graph, host.id, 'prop:swap')).toBe(true)
+ expect(graph.getNode(host.id)?.componentPropertyDefinitions).toEqual([])
+ expect(graph.getNode(slot.id)?.componentPropertyReferences).toEqual([])
+ expect(graph.getNode(instance.id)?.componentPropertyAssignments).toEqual({})
+ })
+})