Skip to content

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

feat: open, paste, and save FigJam connectors (#1233)

Danila Poyarkovf266147ea164
diff --git a/changes/1233/added.md b/changes/1233/added.md
new file mode 100644
index 000000000..63550fc17
--- /dev/null
+++ b/changes/1233/added.md
@@ -0,0 +1 @@
+- FigJam connectors open from `.fig` files and paste from FigJam with their ends, route, caps, line style, and label, bound to the layers they join, and save back so Figma keeps them live (#616).
diff --git a/packages/core/src/canvas/shapes.ts b/packages/core/src/canvas/shapes.ts
index bdf2301cf..975621dff 100644
--- a/packages/core/src/canvas/shapes.ts
+++ b/packages/core/src/canvas/shapes.ts
@@ -528,7 +528,7 @@ export function getVectorPaths(r: SkiaRenderer, node: SceneNode): Path[] | null
if (!node.vectorNetwork) return null
const cached = r.nodePaths.vector.get(node.id)
if (cached) return cached
- const paths = vectorNetworkToPath(r.ck, node.vectorNetwork)
+ const paths = vectorNetworkToPath(r.ck, node.vectorNetwork, node.cornerRadius)
r.nodePaths.store(r.nodePaths.vector, node.id, paths)
return paths
}
diff --git a/packages/core/src/editor/graph-events.ts b/packages/core/src/editor/graph-events.ts
index ca7ce86eb..e0f166dfb 100644
--- a/packages/core/src/editor/graph-events.ts
+++ b/packages/core/src/editor/graph-events.ts
@@ -29,8 +29,10 @@ type GraphEventOptions = {
) => void
}
+// A vector's open corners are rounded by its corner radius, so its paths follow that too.
const GEOMETRY_CACHE_KEYS = new Set<keyof SceneNode>([
'vectorNetwork',
+ 'cornerRadius',
'fillGeometry',
'strokeGeometry'
])
diff --git a/packages/core/src/vector/index.ts b/packages/core/src/vector/index.ts
index d15317991..af86a8018 100644
--- a/packages/core/src/vector/index.ts
+++ b/packages/core/src/vector/index.ts
@@ -36,7 +36,12 @@ function fillType(ck: CanvasKit, windingRule: WindingRule) {
return windingRule === 'EVENODD' ? ck.FillType.EvenOdd : ck.FillType.Winding
}
-export function vectorNetworkToPath(ck: CanvasKit, network: VectorNetwork): Path[] {
+/** A vector network's paths; `cornerRadius` rounds open corners that set no radius of their own. */
+export function vectorNetworkToPath(
+ ck: CanvasKit,
+ network: VectorNetwork,
+ cornerRadius = 0
+): Path[] {
const { vertices, segments, regions } = network
if (regions.length > 0) {
@@ -56,14 +61,14 @@ export function vectorNetworkToPath(ck: CanvasKit, network: VectorNetwork): Path
const openSegments = segments.filter((_, index) => !regionSegmentIndexes.has(index))
if (openSegments.length > 0) {
const openPath = new ck.PathBuilder()
- addOpenSegmentsToPath(openPath, openSegments, vertices)
+ addOpenSegmentsToPath(openPath, openSegments, vertices, cornerRadius)
paths.push(openPath.detachAndDelete())
}
return paths
}
const path = new ck.PathBuilder()
- addOpenSegmentsToPath(path, segments, vertices)
+ addOpenSegmentsToPath(path, segments, vertices, cornerRadius)
return [path.detachAndDelete()]
}
diff --git a/packages/core/src/vector/path-helpers.ts b/packages/core/src/vector/path-helpers.ts
index c7508d239..622073449 100644
--- a/packages/core/src/vector/path-helpers.ts
+++ b/packages/core/src/vector/path-helpers.ts
@@ -1,4 +1,5 @@
import type { VectorSegment, VectorVertex } from '@open-pencil/scene-graph'
+import type { Vector } from '@open-pencil/scene-graph/primitives'
/** Anything path commands can be emitted into: a canvaskit Path or a blob encoder. */
export interface PathSink {
@@ -75,25 +76,126 @@ export function addLoopToPath(
path.close()
}
+function isStraight(seg: VectorSegment): boolean {
+ const { tangentStart: ts, tangentEnd: te } = seg
+ return ts.x === 0 && ts.y === 0 && te.x === 0 && te.y === 0
+}
+
+/** Cubic handle length, as a fraction of the radius, of a circular arc turning by `angle`. */
+function arcHandle(angle: number): number {
+ return (4 / 3) * Math.tan(angle / 4)
+}
+
+interface RoundedCorner {
+ /** Where the arc leaves the incoming segment and joins the outgoing one. */
+ start: Vector
+ end: Vector
+ handleIn: Vector
+ handleOut: Vector
+}
+
+/**
+ * The arc rounding `corner` between straight runs from `from` and to `after`, or null when the
+ * runs do not turn or have no length. A radius never takes more than half of either run.
+ */
+function roundedCorner(
+ from: Vector,
+ corner: Vector,
+ after: Vector,
+ radius: number
+): RoundedCorner | null {
+ const inLength = Math.hypot(corner.x - from.x, corner.y - from.y)
+ const outLength = Math.hypot(after.x - corner.x, after.y - corner.y)
+ if (radius <= 0 || inLength === 0 || outLength === 0) return null
+ const inDir = { x: (corner.x - from.x) / inLength, y: (corner.y - from.y) / inLength }
+ const outDir = { x: (after.x - corner.x) / outLength, y: (after.y - corner.y) / outLength }
+ const turn = Math.acos(Math.max(-1, Math.min(1, inDir.x * outDir.x + inDir.y * outDir.y)))
+ if (turn <= 1e-6) return null
+ const reach = Math.min(radius * Math.tan(turn / 2), inLength / 2, outLength / 2)
+ const handle = arcHandle(turn) * (reach / Math.tan(turn / 2))
+ const start = { x: corner.x - inDir.x * reach, y: corner.y - inDir.y * reach }
+ const end = { x: corner.x + outDir.x * reach, y: corner.y + outDir.y * reach }
+ return {
+ start,
+ end,
+ handleIn: { x: start.x + inDir.x * handle, y: start.y + inDir.y * handle },
+ handleOut: { x: end.x - outDir.x * handle, y: end.y - outDir.y * handle }
+ }
+}
+
+function drawCorner(path: PathSink, corner: RoundedCorner) {
+ path.lineTo(corner.start.x, corner.start.y)
+ path.cubicTo(
+ corner.handleIn.x,
+ corner.handleIn.y,
+ corner.handleOut.x,
+ corner.handleOut.y,
+ corner.end.x,
+ corner.end.y
+ )
+}
+
+/**
+ * Draws one chain, rounding each vertex where two straight segments meet by its corner radius, or
+ * `cornerRadius` when it has none, as Figma rounds a vector's corners. A chain that comes back to
+ * where it started is closed, its last corner rounded too.
+ */
+function addChainToPath(
+ path: PathSink,
+ chain: number[],
+ segments: VectorSegment[],
+ vertices: VectorVertex[],
+ cornerRadius: number
+): void {
+ // The chain's vertices in drawing order; a closed chain ends where it started.
+ const first = findChainStart(chain, segments)
+ const order = [first]
+ for (const segIdx of chain) {
+ const seg = segments[segIdx]
+ order.push(seg.start === order[order.length - 1] ? seg.end : seg.start)
+ }
+ const closed = chain.length > 2 && order[order.length - 1] === first
+ const cornerAt = (index: number): RoundedCorner | null => {
+ const incoming = segments[chain[index - 1]]
+ const outgoing = segments[chain[index % chain.length]]
+ if (!isStraight(incoming) || !isStraight(outgoing)) return null
+ const corner = vertices[order[index]]
+ return roundedCorner(
+ vertices[order[index - 1]],
+ corner,
+ vertices[order[(index % chain.length) + 1]],
+ corner.cornerRadius ?? cornerRadius
+ )
+ }
+ const wrap = closed ? cornerAt(chain.length) : null
+ const begin = wrap?.end ?? vertices[first]
+ path.moveTo(begin.x, begin.y)
+ for (let index = 0; index < chain.length; index++) {
+ const last = index === chain.length - 1
+ const corner = last ? wrap : cornerAt(index + 1)
+ if (corner) {
+ drawCorner(path, corner)
+ continue
+ }
+ const seg = segments[chain[index]]
+ addSegmentDirected(path, seg, vertices, seg.start === order[index])
+ }
+ if (closed) path.close()
+}
+
export function addOpenSegmentsToPath(
path: PathSink,
segments: VectorSegment[],
- vertices: VectorVertex[]
+ vertices: VectorVertex[],
+ cornerRadius = 0
): void {
const visited = new Set<number>()
const chains = buildChains(segments)
for (const chain of chains) {
if (chain.length === 0) continue
- let current = findChainStart(chain, segments)
- path.moveTo(vertices[current].x, vertices[current].y)
- for (const segIdx of chain) {
- visited.add(segIdx)
- const seg = segments[segIdx]
- const forward = seg.start === current
- addSegmentDirected(path, seg, vertices, forward)
- current = forward ? seg.end : seg.start
- }
+ for (const segIdx of chain) visited.add(segIdx)
+ addChainToPath(path, chain, segments, vertices, cornerRadius)
}
for (let i = 0; i < segments.length; i++) {
diff --git a/packages/core/tests/clipboard/figma/connectors.test.ts b/packages/core/tests/clipboard/figma/connectors.test.ts
new file mode 100644
index 000000000..76cf04256
--- /dev/null
+++ b/packages/core/tests/clipboard/figma/connectors.test.ts
@@ -0,0 +1,96 @@
+import { beforeAll, describe, expect, test } from 'bun:test'
+import { join } from 'node:path'
+
+import { expectDefined } from '#core-tests/helpers/assert'
+import { FIXTURES } from '#core-tests/helpers/paths'
+
+import {
+ buildFigmaClipboardHTML,
+ importClipboardNodes,
+ initCodec,
+ parseFigmaClipboard
+} from '@open-pencil/core'
+import { connectorSublayers, SceneGraph } from '@open-pencil/scene-graph'
+import type { SceneNode } from '@open-pencil/scene-graph'
+
+/** Two FigJam stickies joined by four connectors, as FigJam copies them. */
+const FIXTURE = join(FIXTURES, 'clipboard/figjam-connectors.html')
+
+async function importFixture(html: string) {
+ const parsed = expectDefined(await parseFigmaClipboard(html))
+ const graph = new SceneGraph()
+ const ids = importClipboardNodes(parsed.nodes, graph, graph.getPages()[0].id, 0, 0, parsed.blobs)
+ const byName = (name: string) =>
+ expectDefined(ids.map((id) => graph.getNode(id)).find((node) => node?.name === name))
+ return { graph, ids, byName }
+}
+
+function endName(graph: SceneGraph, connector: SceneNode, end: 'connectorStart' | 'connectorEnd') {
+ const id = connector[end]?.nodeId
+ return id ? graph.getNode(id)?.name : null
+}
+
+beforeAll(initCodec)
+
+describe('FigJam connectors', () => {
+ test('import binds their ends and keeps the route, caps, and label Figma drew', async () => {
+ const { graph, byName } = await importFixture(await Bun.file(FIXTURE).text())
+ const elbow = byName('c-elbow-auto')
+ expect(elbow).toMatchObject({
+ type: 'CONNECTOR',
+ connectorLineType: 'ELBOWED',
+ connectorStartCap: 'ROUND',
+ connectorEndCap: 'ARROW_LINES'
+ })
+ expect([
+ endName(graph, elbow, 'connectorStart'),
+ endName(graph, elbow, 'connectorEnd')
+ ]).toEqual(['c-A', 'c-B'])
+ const { line, label, labelBackground } = expectDefined(connectorSublayers(graph, elbow))
+ expect(line.vectorNetwork?.vertices.length).toBe(6)
+ expect(line.cornerRadius).toBe(24)
+ expect(label).toMatchObject({ text: 'label', visible: true })
+ expect(labelBackground.visible).toBe(true)
+
+ // Its end on a FigJam shape, which does not paste, stays where Figma drew it.
+ const straight = byName('c-straight-magnets')
+ expect(straight.connectorEnd).toMatchObject({ nodeId: null, magnet: 'NONE' })
+ const free = byName('c-curved-free')
+ expect(free.connectorEnd).toEqual({
+ nodeId: null,
+ magnet: 'NONE',
+ position: { x: 1200, y: 3000 }
+ })
+ })
+
+ test('export writes them as Figma does, and reading the export back keeps the route', async () => {
+ const { graph, ids } = await importFixture(await Bun.file(FIXTURE).text())
+ const html = expectDefined(
+ await buildFigmaClipboardHTML(
+ ids.map((id) => expectDefined(graph.getNode(id))),
+ graph
+ )
+ )
+ const parsed = expectDefined(await parseFigmaClipboard(html))
+ const record = expectDefined(parsed.nodes.find((node) => node.name === 'c-elbow-auto'))
+ expect(record.type).toBe('CONNECTOR')
+ expect(record.connectorLineStyle).toBe('ELBOWED')
+ expect(record.fillPaints).toBeUndefined()
+ const stickies = new Map(
+ parsed.nodes.filter((node) => node.type === 'STICKY').map((node) => [node.name, node.guid])
+ )
+ expect(record.connectorStart).toMatchObject({
+ endpointNodeID: stickies.get('c-A'),
+ magnet: 'AUTO'
+ })
+ expect(record.connectorEnd).toMatchObject({
+ endpointNodeID: stickies.get('c-B'),
+ magnet: 'AUTO'
+ })
+
+ const reread = await importFixture(html)
+ const elbow = reread.byName('c-elbow-auto')
+ expect(endName(reread.graph, elbow, 'connectorEnd')).toBe('c-B')
+ expect(connectorSublayers(reread.graph, elbow)?.line.vectorNetwork?.vertices.length).toBe(6)
+ })
+})
diff --git a/packages/core/tests/editor/clipboard/import-nodes/filtering.test.ts b/packages/core/tests/editor/clipboard/import-nodes/filtering.test.ts
index 19a0ffc2b..0587118ea 100644
--- a/packages/core/tests/editor/clipboard/import-nodes/filtering.test.ts
+++ b/packages/core/tests/editor/clipboard/import-nodes/filtering.test.ts
@@ -89,7 +89,6 @@ describe('importClipboardNodes: filtering', () => {
const nonVisualTypes = [
'WIDGET',
'STAMP',
- 'CONNECTOR',
'CODE_BLOCK',
'SHAPE_WITH_TEXT',
'TABLE_NODE',
diff --git a/packages/core/tests/editor/graph/events/renderer.test.ts b/packages/core/tests/editor/graph/events/renderer.test.ts
index 6ca990782..314b94e67 100644
--- a/packages/core/tests/editor/graph/events/renderer.test.ts
+++ b/packages/core/tests/editor/graph/events/renderer.test.ts
@@ -11,7 +11,13 @@ describe('graph event renderer invalidation', () => {
})
test('geometry fields invalidate vector and geometry path caches', () => {
- for (const changes of [{ vectorNetwork: null }, { fillGeometry: [] }, { strokeGeometry: [] }]) {
+ for (const changes of [
+ { vectorNetwork: null },
+ // A vector's open corners are rounded by its corner radius.
+ { cornerRadius: 24 },
+ { fillGeometry: [] },
+ { strokeGeometry: [] }
+ ]) {
expect(rendererInvalidationForChanges(changes, { preview: false }).geometryCache).toBe(true)
expect(rendererInvalidationForChanges(changes, { preview: true }).geometryCache).toBe(true)
}
diff --git a/packages/core/tests/vector/corner-radius.test.ts b/packages/core/tests/vector/corner-radius.test.ts
new file mode 100644
index 000000000..22fc06a64
--- /dev/null
+++ b/packages/core/tests/vector/corner-radius.test.ts
@@ -0,0 +1,111 @@
+import { describe, expect, test } from 'bun:test'
+
+import type { VectorSegment, VectorVertex } from '@open-pencil/scene-graph'
+
+import { addOpenSegmentsToPath, type PathSink } from '#core/vector/path-helpers'
+
+const zero = { x: 0, y: 0 }
+
+function line(start: number, end: number): VectorSegment {
+ return { start, end, tangentStart: zero, tangentEnd: zero }
+}
+
+/** Records path commands, with a cubic's handles rounded to a tenth. */
+function recorder(): PathSink & { commands: string[] } {
+ const commands: string[] = []
+ const r = (value: number) => Math.round(value * 10) / 10
+ return {
+ commands,
+ moveTo: (x, y) => commands.push(`M${r(x)},${r(y)}`),
+ lineTo: (x, y) => commands.push(`L${r(x)},${r(y)}`),
+ cubicTo: (x1, y1, x2, y2, x, y) =>
+ commands.push(`C${r(x1)},${r(y1)} ${r(x2)},${r(y2)} ${r(x)},${r(y)}`),
+ close: () => commands.push('Z')
+ }
+}
+
+const elbow: VectorVertex[] = [
+ { x: 0, y: 0 },
+ { x: 100, y: 0 },
+ { x: 100, y: 100 }
+]
+
+function draw(vertices: VectorVertex[], cornerRadius: number) {
+ const path = recorder()
+ addOpenSegmentsToPath(path, [line(0, 1), line(1, 2)], vertices, cornerRadius)
+ return path.commands
+}
+
+// Figma rounds a vector's corners by its corner radius, as a connector's elbows show.
+describe('vector corner radius', () => {
+ test('rounds a right-angle corner with a quarter circle of the radius', () => {
+ expect(draw(elbow, 24)).toEqual(['M0,0', 'L76,0', 'C89.3,0 100,10.7 100,24', 'L100,100'])
+ })
+
+ test('leaves corners sharp without a radius', () => {
+ expect(draw(elbow, 0)).toEqual(['M0,0', 'L100,0', 'L100,100'])
+ })
+
+ test('takes no more than half of a short segment', () => {
+ const short: VectorVertex[] = [
+ { x: 0, y: 0 },
+ { x: 20, y: 0 },
+ { x: 20, y: 100 }
+ ]
+ expect(draw(short, 24).slice(0, 2)).toEqual(['M0,0', 'L10,0'])
+ })
+
+ test("a vertex's own radius wins over the vector's", () => {
+ const own: VectorVertex[] = [
+ { x: 0, y: 0 },
+ { x: 100, y: 0, cornerRadius: 8 },
+ { x: 100, y: 100 }
+ ]
+ expect(draw(own, 24)[1]).toBe('L92,0')
+ })
+
+ test('rounds every corner of a closed outline, the one it starts at too, and closes it', () => {
+ const square: VectorVertex[] = [
+ { x: 0, y: 0 },
+ { x: 100, y: 0 },
+ { x: 100, y: 100 },
+ { x: 0, y: 100 }
+ ]
+ const path = recorder()
+ addOpenSegmentsToPath(path, [line(0, 1), line(1, 2), line(2, 3), line(3, 0)], square, 10)
+ expect(path.commands).toEqual([
+ 'M10,0',
+ 'L90,0',
+ 'C95.5,0 100,4.5 100,10',
+ 'L100,90',
+ 'C100,95.5 95.5,100 90,100',
+ 'L10,100',
+ 'C4.5,100 0,95.5 0,90',
+ 'L0,10',
+ 'C0,4.5 4.5,0 10,0',
+ 'Z'
+ ])
+ })
+
+ test('leaves a corner next to a curve sharp', () => {
+ const path = recorder()
+ const curve = { start: 1, end: 2, tangentStart: { x: 0, y: 40 }, tangentEnd: { x: 0, y: -40 } }
+ addOpenSegmentsToPath(path, [line(0, 1), curve], elbow, 24)
+ expect(path.commands.slice(0, 2)).toEqual(['M0,0', 'L100,0'])
+ })
+
+ test('leaves coincident and straight-through vertices as they are', () => {
+ const coincident: VectorVertex[] = [
+ { x: 0, y: 0 },
+ { x: 100, y: 0 },
+ { x: 100, y: 0 }
+ ]
+ expect(draw(coincident, 24)).toEqual(['M0,0', 'L100,0', 'L100,0'])
+ const straight: VectorVertex[] = [
+ { x: 0, y: 0 },
+ { x: 100, y: 0 },
+ { x: 200, y: 0 }
+ ]
+ expect(draw(straight, 24)).toEqual(['M0,0', 'L100,0', 'L200,0'])
+ })
+})
diff --git a/packages/design-jsx/src/enums.ts b/packages/design-jsx/src/enums.ts
index 7273bb9c3..41a88bd2d 100644
--- a/packages/design-jsx/src/enums.ts
+++ b/packages/design-jsx/src/enums.ts
@@ -61,7 +61,10 @@ export const STROKE_CAP = lowercaseEnum<StrokeCap>([
'ROUND',
'SQUARE',
'ARROW_LINES',
- 'ARROW_EQUILATERAL'
+ 'ARROW_EQUILATERAL',
+ 'TRIANGLE_FILLED',
+ 'DIAMOND_FILLED',
+ 'CIRCLE_FILLED'
])
export const STROKE_JOIN = lowercaseEnum<StrokeJoin>(['MITER', 'BEVEL', 'ROUND'])
export const STROKE_ALIGN = lowercaseEnum<Stroke['align']>(['INSIDE', 'CENTER', 'OUTSIDE'])
diff --git a/packages/design-jsx/tests/enums.test.ts b/packages/design-jsx/tests/enums.test.ts
index 04268e4b6..21a548677 100644
--- a/packages/design-jsx/tests/enums.test.ts
+++ b/packages/design-jsx/tests/enums.test.ts
@@ -72,7 +72,15 @@ describe('design JSX enums', () => {
expect(BLEND_MODE.parse(3)).toBeUndefined()
})
- const caps: StrokeCap[] = ['ROUND', 'SQUARE', 'ARROW_LINES', 'ARROW_EQUILATERAL']
+ const caps: StrokeCap[] = [
+ 'ROUND',
+ 'SQUARE',
+ 'ARROW_LINES',
+ 'ARROW_EQUILATERAL',
+ 'TRIANGLE_FILLED',
+ 'DIAMOND_FILLED',
+ 'CIRCLE_FILLED'
+ ]
test.each(caps)('a %s stroke cap survives export and render', async (cap) => {
const graph = new SceneGraph()
diff --git a/packages/fig/src/document/materialize.ts b/packages/fig/src/document/materialize.ts
index 5576bb78b..eb0f5ab71 100644
--- a/packages/fig/src/document/materialize.ts
+++ b/packages/fig/src/document/materialize.ts
@@ -317,6 +317,8 @@ function materializeReaderInto(
if (occurrence.layoutScale !== undefined) layoutScales.set(node.id, occurrence.layoutScale)
}
}
+ /** Generated frames whose records name other layers, linked once the pass has made them. */
+ const linked: Array<{ node: SceneNode; record: NodeChange }> = []
const createShells = (occurrence: InstanceOccurrence, parentId: string): void => {
if (occurrence.mainComponentId !== null) return
const existingId = sources.get(occurrence.sourceId)
@@ -330,7 +332,9 @@ function materializeReaderInto(
const node = graph.createNode(nodeType, parentId, props)
sources.set(occurrence.sourceId, node.id)
if (node.type === 'COMPONENT') componentIds.set(occurrence.sourceId, node.id)
- generatedFrameCodec(node.type)?.read(graph, node, occurrence.properties, blobs)
+ const codec = generatedFrameCodec(node.type)
+ codec?.read(graph, node, occurrence.properties, blobs)
+ if (codec?.link) linked.push({ node, record: occurrence.properties })
for (const child of occurrence.children) createShells(child, node.id)
}
for (const page of pages) createShells(page, graph.rootId)
@@ -395,6 +399,12 @@ function materializeReaderInto(
for (const page of pages) populateInstances(page)
for (const instanceId of resync) graph.syncInstance(instanceId)
if (resync.size > 0) restoreDerivedSizes(graph, derivedSizes)
+ // Records name other layers by GUID, so links wait until every layer of the pass exists,
+ // instances and the layers inside them included.
+ const layerOf = (sourceId: string) => sources.get(sourceId)
+ for (const { node, record } of linked) {
+ generatedFrameCodec(node.type)?.link?.(graph, node, record, layerOf)
+ }
// Layers and ranges name their styles by the styles' own IDs, which the records' GUIDs are,
// so only links to other layers are renamed to the layers this page added.
for (const node of graph.getAllNodes()) {
diff --git a/packages/fig/src/node-change/generated/codec.ts b/packages/fig/src/node-change/generated/codec.ts
index c4d94a6f4..2cec35a9a 100644
--- a/packages/fig/src/node-change/generated/codec.ts
+++ b/packages/fig/src/node-change/generated/codec.ts
@@ -12,6 +12,16 @@ import type { KiwiNodeChange, SceneNodeToKiwiContext } from '../export/context'
export interface GeneratedFrameCodec {
/** Gives a frame read from its record the sublayers the record describes. */
read(graph: SceneGraph, frame: SceneNode, record: NodeChange, blobs: Uint8Array[]): void
+ /**
+ * Points the frame at the layers its record names by GUID, as a connector's ends do. The reader
+ * calls it once every layer of the pass exists; `layerOf` gives the layer a record became.
+ */
+ link?(
+ graph: SceneGraph,
+ frame: SceneNode,
+ record: NodeChange,
+ layerOf: (sourceId: string) => string | undefined
+ ): void
/** The frame's own record, with its sublayers written on it as Figma stores them. */
write(context: SceneNodeToKiwiContext, frame: SceneNode, nc: KiwiNodeChange): KiwiNodeChange
}
diff --git a/packages/fig/src/node-change/generated/codecs.ts b/packages/fig/src/node-change/generated/codecs.ts
index 48bc7c1f0..7acc77e1f 100644
--- a/packages/fig/src/node-change/generated/codecs.ts
+++ b/packages/fig/src/node-change/generated/codecs.ts
@@ -1,11 +1,13 @@
import type { NodeType } from '@open-pencil/scene-graph'
import type { GeneratedFrameCodec } from './codec'
+import { CONNECTOR_CODEC } from './connector'
import { STICKY_CODEC } from './sticky'
/** Each generated frame type's codec; a type without one is written as a plain frame. */
const GENERATED_FRAME_CODECS: Partial<Record<NodeType, GeneratedFrameCodec>> = {
- STICKY: STICKY_CODEC
+ STICKY: STICKY_CODEC,
+ CONNECTOR: CONNECTOR_CODEC
}
export function generatedFrameCodec(type: NodeType): GeneratedFrameCodec | undefined {
diff --git a/packages/fig/src/node-change/generated/connector.ts b/packages/fig/src/node-change/generated/connector.ts
new file mode 100644
index 000000000..90cbe31d8
--- /dev/null
+++ b/packages/fig/src/node-change/generated/connector.ts
@@ -0,0 +1,309 @@
+import { pick } from 'es-toolkit'
+
+import type { GUID, NodeChange } from '@open-pencil/kiwi/fig/codec'
+import { guidToString, isUnsetGuid, UNSET_GUID } from '@open-pencil/kiwi/fig/guid'
+import {
+ buildConnectorSublayers,
+ connectorRouteEnds,
+ connectorSublayers
+} from '@open-pencil/scene-graph'
+import type {
+ ConnectorEndpoint,
+ ConnectorLineType,
+ ConnectorMagnet,
+ SceneGraph,
+ SceneNode,
+ StrokeCap
+} from '@open-pencil/scene-graph'
+import type { Vector } from '@open-pencil/scene-graph/primitives'
+
+import { nodeChangeToProps } from '../convert'
+import { createFillPaints, createStrokePaints } from '../export/context'
+import type { KiwiNodeChange, SceneNodeToKiwiContext } from '../export/context'
+import type { GeneratedFrameCodec } from './codec'
+import { placement, shaped, sublayerRecord, textSublayer } from './entries'
+import {
+ derivedFrameEntriesOf,
+ generatedSlotPath,
+ generationOverridesOf,
+ type GeneratedEntry
+} from './records'
+
+export const CONNECTOR_SLOTS = { line: 0, label: 1, labelBackground: 2 } as const
+
+/** The fields a CONNECTOR's own record keeps besides its ends, as Figma writes it. */
+const CONNECTOR_RECORD_FIELDS = [
+ 'guid',
+ 'parentIndex',
+ 'phase',
+ 'type',
+ 'name',
+ 'visible',
+ 'opacity',
+ 'blendMode',
+ 'locked',
+ 'size',
+ 'transform',
+ 'autoRename',
+ 'frameMaskDisabled',
+ 'exportSettings',
+ 'pluginData',
+ 'pluginRelaunchData'
+] as const
+
+interface KiwiConnectorEndpoint {
+ endpointNodeID?: GUID
+ position?: Vector
+ magnet?: string
+}
+
+/** A connector end as its record names it: the record of the layer it is bound to, if any. */
+export interface ConnectorEndpointRecord {
+ sourceId: string | null
+ magnet: ConnectorMagnet
+ position: Vector
+}
+
+const MAGNETS: ReadonlySet<string> = new Set<ConnectorMagnet>([
+ 'NONE',
+ 'AUTO',
+ 'AUTO_HORIZONTAL',
+ 'TOP',
+ 'RIGHT',
+ 'BOTTOM',
+ 'LEFT',
+ 'CENTER',
+ 'EDGE',
+ 'ABSOLUTE'
+])
+
+const CAPS: ReadonlySet<string> = new Set<StrokeCap>([
+ 'NONE',
+ 'ROUND',
+ 'SQUARE',
+ 'ARROW_LINES',
+ 'ARROW_EQUILATERAL',
+ 'TRIANGLE_FILLED',
+ 'DIAMOND_FILLED',
+ 'CIRCLE_FILLED'
+])
+
+const LINE_TYPES: ReadonlySet<string> = new Set<ConnectorLineType>([
+ 'ELBOWED',
+ 'STRAIGHT',
+ 'CURVED'
+])
+
+function magnetOf(value: string | undefined): ConnectorMagnet {
+ return value && MAGNETS.has(value) ? (value as ConnectorMagnet) : 'NONE'
+}
+
+function capOf(value: unknown, fallback: StrokeCap): StrokeCap {
+ return typeof value === 'string' && CAPS.has(value) ? (value as StrokeCap) : fallback
+}
+
+function endpointOf(value: unknown): ConnectorEndpointRecord {
+ const endpoint = (value ?? {}) as KiwiConnectorEndpoint
+ const guid = endpoint.endpointNodeID
+ return {
+ sourceId: guid && !isUnsetGuid(guid) ? guidToString(guid) : null,
+ magnet: magnetOf(endpoint.magnet),
+ position: { x: endpoint.position?.x ?? 0, y: endpoint.position?.y ?? 0 }
+ }
+}
+
+/**
+ * A connector end bound to the layer its record names. An end whose layer is not there, as when a
+ * connector is pasted alone, stays free where it was drawn.
+ */
+function boundEndpoint(
+ record: ConnectorEndpointRecord,
+ drawn: Vector | undefined,
+ layerOf: (sourceId: string) => string | undefined
+): ConnectorEndpoint {
+ const nodeId = record.sourceId === null ? null : (layerOf(record.sourceId) ?? null)
+ if (nodeId || record.sourceId === null) {
+ return { nodeId, magnet: record.magnet, position: record.position }
+ }
+ return { nodeId: null, magnet: 'NONE', position: drawn ?? record.position }
+}
+
+function linkConnector(
+ graph: SceneGraph,
+ connector: SceneNode,
+ record: NodeChange,
+ layerOf: (sourceId: string) => string | undefined
+): void {
+ const drawn = connectorRouteEnds(graph, connector)
+ graph.updateNode(connector.id, {
+ connectorStart: boundEndpoint(endpointOf(record.connectorStart), drawn?.start, layerOf),
+ connectorEnd: boundEndpoint(endpointOf(record.connectorEnd), drawn?.end, layerOf)
+ })
+}
+
+function sublayerProps(
+ type: string,
+ entry: GeneratedEntry | undefined,
+ derived: GeneratedEntry | undefined,
+ blobs: Uint8Array[]
+): Partial<SceneNode> {
+ const {
+ nodeType: _type,
+ name: _name,
+ ...props
+ } = nodeChangeToProps(sublayerRecord(type, entry, derived), blobs, 'occurrence')
+ return props
+}
+
+/**
+ * Gives an imported CONNECTOR its line type, caps, and sublayers: the line as Figma last routed
+ * it, and its label on its plate. Its ends are linked once their layers exist.
+ */
+function readConnector(
+ graph: SceneGraph,
+ connector: SceneNode,
+ record: NodeChange,
+ blobs: Uint8Array[]
+): void {
+ const overrides = generationOverridesOf(record)
+ const derived = derivedFrameEntriesOf(record)
+ const { line, label, labelBackground } = CONNECTOR_SLOTS
+ const lineType = record.connectorLineStyle
+ graph.updateNode(connector.id, {
+ fills: [],
+ strokes: [],
+ connectorLineType:
+ typeof lineType === 'string' && LINE_TYPES.has(lineType)
+ ? (lineType as ConnectorLineType)
+ : 'ELBOWED',
+ connectorStartCap: capOf(record.connectorStartCap, 'ROUND'),
+ connectorEndCap: capOf(record.connectorEndCap, 'ARROW_LINES')
+ })
+ const text = overrides.get(label)?.textData?.characters ?? ''
+ const plate = sublayerProps(
+ 'RECTANGLE',
+ overrides.get(labelBackground),
+ derived.get(labelBackground),
+ blobs
+ )
+ const labelProps = sublayerProps('TEXT', overrides.get(label), derived.get(label), blobs)
+ buildConnectorSublayers(graph, connector, {
+ line: sublayerProps('VECTOR', overrides.get(line), derived.get(line), blobs),
+ labelBackground: { ...plate, visible: text !== '' },
+ // Figma places the label inside its plate; here they are siblings.
+ label: {
+ ...labelProps,
+ x: (labelProps.x ?? 0) + (plate.x ?? 0),
+ y: (labelProps.y ?? 0) + (plate.y ?? 0),
+ visible: text !== ''
+ }
+ })
+}
+
+/**
+ * A connector end as Figma writes it. An end bound to a layer the export does not include, as when
+ * a connector is copied alone, is written free where it is drawn, as Figma pastes one.
+ */
+function kiwiConnectorEndpoint(
+ context: SceneNodeToKiwiContext,
+ endpoint: ConnectorEndpoint | null,
+ drawn: Vector | undefined
+) {
+ const guid = endpoint?.nodeId ? context.nodeIdToGuid?.get(endpoint.nodeId) : undefined
+ if (endpoint && (guid || !endpoint.nodeId)) {
+ return {
+ endpointNodeID: guid ?? { ...UNSET_GUID },
+ position: { ...endpoint.position },
+ magnet: endpoint.magnet
+ }
+ }
+ return {
+ endpointNodeID: { ...UNSET_GUID },
+ position: { ...(drawn ?? { x: 0, y: 0 }) },
+ magnet: 'NONE'
+ }
+}
+
+/**
+ * A connector's record: its ends, line type, and caps, and its line, label, and label plate as
+ * `nodeGenerationData` entries, with the route as drawn under `derivedImmutableFrameData`. As for
+ * a sticky note, the derived data is written only when the label is shaped, since Figma draws a
+ * connector from it as saved.
+ */
+function writeConnector(
+ context: SceneNodeToKiwiContext,
+ node: SceneNode,
+ nc: KiwiNodeChange
+): KiwiNodeChange {
+ const record: KiwiNodeChange = pick(nc, CONNECTOR_RECORD_FIELDS)
+ const sublayers = connectorSublayers(context.graph, node)
+ if (!sublayers) return record
+ const drawn = connectorRouteEnds(context.graph, node)
+ record.connectorStart = kiwiConnectorEndpoint(context, node.connectorStart, drawn?.start)
+ record.connectorEnd = kiwiConnectorEndpoint(context, node.connectorEnd, drawn?.end)
+ record.connectorLineStyle = node.connectorLineType
+ record.connectorStartCap = node.connectorStartCap
+ record.connectorEndCap = node.connectorEndCap
+ record.connectorType = 'MANUAL'
+ record.connectorVersion = 1
+ const { line, label, labelBackground } = sublayers
+ const lineEntry: GeneratedEntry = {
+ guidPath: generatedSlotPath(CONNECTOR_SLOTS.line),
+ strokePaints: createStrokePaints(context, line),
+ strokeWeight: line.strokes[0]?.weight ?? line.strokeWeight,
+ strokeCap: 'ROUND',
+ cornerRadius: line.cornerRadius,
+ dashPattern: [...line.dashPattern]
+ }
+ const { entry: labelEntry, derived: labelDerived } = textSublayer(
+ context,
+ CONNECTOR_SLOTS.label,
+ label
+ )
+ const plateEntry: GeneratedEntry = {
+ guidPath: generatedSlotPath(CONNECTOR_SLOTS.labelBackground),
+ visible: labelBackground.visible,
+ fillPaints: createFillPaints(context, labelBackground),
+ cornerRadius: labelBackground.cornerRadius
+ }
+ record.nodeGenerationData = {
+ overrides: [lineEntry, labelEntry, plateEntry],
+ useFineGrainedSyncing: false,
+ diffOnlyRemovals: []
+ }
+ const lineGeometry: KiwiNodeChange = {}
+ context.serializeGeometry(line, lineGeometry, context.blobs)
+ // Figma places the label inside its plate; here they are siblings.
+ labelDerived.transform = {
+ m00: 1,
+ m01: 0,
+ m02: label.x - labelBackground.x,
+ m10: 0,
+ m11: 1,
+ m12: label.y - labelBackground.y
+ }
+ if (lineGeometry.vectorData && shaped(label, labelDerived)) {
+ record.derivedImmutableFrameData = {
+ overrides: [
+ {
+ guidPath: generatedSlotPath(CONNECTOR_SLOTS.line),
+ ...placement(line),
+ vectorData: lineGeometry.vectorData
+ },
+ labelDerived,
+ {
+ guidPath: generatedSlotPath(CONNECTOR_SLOTS.labelBackground),
+ ...placement(labelBackground)
+ }
+ ],
+ version: 1
+ }
+ }
+ return record
+}
+
+export const CONNECTOR_CODEC: GeneratedFrameCodec = {
+ read: readConnector,
+ link: linkConnector,
+ write: writeConnector
+}
diff --git a/packages/fig/src/node-classification.ts b/packages/fig/src/node-classification.ts
index 8bba7a54d..15b1742f2 100644
--- a/packages/fig/src/node-classification.ts
+++ b/packages/fig/src/node-classification.ts
@@ -7,7 +7,6 @@ const UNSUPPORTED_FRAGMENT_TYPES: ReadonlySet<string> = new Set([
'WIDGET',
'STAMP',
'SHAPE_WITH_TEXT',
- 'CONNECTOR',
'CODE_BLOCK',
'TABLE_NODE',
'TABLE_CELL',
diff --git a/packages/fig/tests/document/connector-ends.test.ts b/packages/fig/tests/document/connector-ends.test.ts
new file mode 100644
index 000000000..1910232ef
--- /dev/null
+++ b/packages/fig/tests/document/connector-ends.test.ts
@@ -0,0 +1,32 @@
+import { expect, test } from 'bun:test'
+
+import { guid } from '#fig-tests/helpers/guid'
+import { materializeDocument } from '#fig/document/materialize'
+
+import type { NodeChange } from '@open-pencil/kiwi/fig/codec'
+
+test('a connector binds to an instance read in the same pass', () => {
+ const changes: NodeChange[] = [
+ { guid: guid(1), type: 'DOCUMENT' },
+ { guid: guid(2), type: 'CANVAS', name: 'Page', parentIndex: { guid: guid(1), position: 'a' } },
+ { guid: guid(4), type: 'SYMBOL', name: 'Card', parentIndex: { guid: guid(2), position: 'a' } },
+ {
+ guid: guid(6),
+ type: 'INSTANCE',
+ parentIndex: { guid: guid(2), position: 'b' },
+ symbolData: { symbolID: guid(4) }
+ },
+ { guid: guid(7), type: 'RECTANGLE', parentIndex: { guid: guid(2), position: 'c' } },
+ {
+ guid: guid(8),
+ type: 'CONNECTOR',
+ parentIndex: { guid: guid(2), position: 'd' },
+ connectorStart: { endpointNodeID: guid(6), magnet: 'AUTO' },
+ connectorEnd: { endpointNodeID: guid(7), magnet: 'LEFT' }
+ }
+ ]
+ const { graph, sources } = materializeDocument(changes)
+ const connector = graph.getNode(sources.get('1:8') ?? '')
+ expect(connector?.connectorStart).toMatchObject({ nodeId: sources.get('1:6'), magnet: 'AUTO' })
+ expect(connector?.connectorEnd).toMatchObject({ nodeId: sources.get('1:7'), magnet: 'LEFT' })
+})
diff --git a/packages/scene-graph/AGENTS.md b/packages/scene-graph/AGENTS.md
index 7683730a7..050255317 100644
--- a/packages/scene-graph/AGENTS.md
+++ b/packages/scene-graph/AGENTS.md
@@ -9,7 +9,7 @@ Framework-neutral document model. Owns node types, primitives, geometry, matrice
- Bounds accumulation goes through the helpers in `packages/scene-graph/src/geometry.ts` (`computeBounds`, `computeAbsoluteBounds`, `computeVisualBounds`); do not add another min/max loop.
- Reparenting preserves child world positions; groups preserve them too. Sort children geometrically before creating auto-layout. Consumers such as layer trees must react to reparenting rather than retaining stale child references.
- Use the copy helpers in `packages/scene-graph/src/copy.ts` for nested values (fills, strokes, effects); never hand-copy node properties.
-- A generated frame (Figma's immutable frames such as `STICKY`) owns real child layers built from its template in `packages/scene-graph/src/generated/`; nothing adds, moves, or removes them (`slotScope` reports `locked`), and the layers panel lists the frame alone. Each type registers a `GeneratedFrameKind` in `GENERATED_FRAME_KINDS`, and the editor asks it (`layerRotates`, `layerResizes`, `generatedFrameText`) instead of testing node types (`packages/scene-graph/tests/generated/kind.test.ts`).
+- A generated frame (Figma's immutable frames such as `STICKY`) owns real child layers built from its template in `packages/scene-graph/src/generated/`; nothing adds, moves, or removes them (`slotScope` reports `locked`), and the layers panel lists the frame alone. Each type registers a `GeneratedFrameKind` in `GENERATED_FRAME_KINDS`, and the editor asks it (`layerRotates`, `layerResizes`, `generatedFrameText`) instead of testing node types (`packages/scene-graph/tests/generated/kind.test.ts`). A connector's ends name the layers they follow by ID; a transfer that leaves those layers behind keeps the IDs, and a reader that cannot find one leaves that end free where it was drawn (`packages/scene-graph/tests/generated/connector.test.ts`).
- Instance children map to component children through `componentId`; runtime overrides use the structured `InstanceOverrideState` (`self` and `descendants` maps) in `packages/scene-graph/src/instance-overrides.ts`.
- A bound numeric field records its unit conversion in `variableBindingScales`; preserve it through clone, copy, and transfer so a binding keeps meaning in its new scope. Core reconciles bindings and layout together in `packages/core/src/layout/variables.ts`, which the editor and the Figma API both call rather than reimplementing.
- `componentScale` records an occurrence's coordinates relative to its component definition. Shared rescaling lives in `packages/scene-graph/src/scaling/`; Core's Figma API delegates there instead of scaling nodes itself.
diff --git a/packages/scene-graph/src/copy.ts b/packages/scene-graph/src/copy.ts
index dfb23877c..af14290c2 100644
--- a/packages/scene-graph/src/copy.ts
+++ b/packages/scene-graph/src/copy.ts
@@ -11,6 +11,7 @@
import type {
ArcData,
ComponentPropertyDefinition,
+ ConnectorEndpoint,
Effect,
DerivedTextGlyph,
Fill,
@@ -218,6 +219,10 @@ export function copyDerivedGlyphs(glyphs: DerivedTextGlyph[] | null): DerivedTex
// --- Complex structure copy functions ---
// These replace structuredClone for known types, avoiding its ~24× overhead.
+export function copyConnectorEndpoint(endpoint: ConnectorEndpoint): ConnectorEndpoint {
+ return { ...endpoint, position: { ...endpoint.position } }
+}
+
function copyArcData(a: ArcData): ArcData {
return { startingAngle: a.startingAngle, endingAngle: a.endingAngle, innerRadius: a.innerRadius }
}
@@ -302,6 +307,8 @@ export function cloneNodeProps(
textPathData: src.textPathData ? structuredClone(src.textPathData) : null,
textPathBox: src.textPathBox ? { ...src.textPathBox } : null,
gridPosition: src.gridPosition ? { ...src.gridPosition } : null,
- targetAspectRatio: src.targetAspectRatio ? { ...src.targetAspectRatio } : null
+ targetAspectRatio: src.targetAspectRatio ? { ...src.targetAspectRatio } : null,
+ connectorStart: src.connectorStart ? copyConnectorEndpoint(src.connectorStart) : null,
+ connectorEnd: src.connectorEnd ? copyConnectorEndpoint(src.connectorEnd) : null
}
}
diff --git a/packages/scene-graph/src/generated/connector.ts b/packages/scene-graph/src/generated/connector.ts
new file mode 100644
index 000000000..e32645833
--- /dev/null
+++ b/packages/scene-graph/src/generated/connector.ts
@@ -0,0 +1,195 @@
+import { BLACK } from '../constants'
+import { getWorldMatrix } from '../coordinate'
+import type { SceneGraph } from '../index'
+import Matrix from '../matrix'
+import type { Color, Vector } from '../primitives'
+import type { ConnectorEndpoint, Fill, SceneNode, Stroke, VectorNetwork } from '../types'
+import type { GeneratedFrameKind } from './kind'
+
+/**
+ * A FigJam connector as Figma draws it by default: a grey line 4 px wide with rounded elbows, a
+ * round start, and an arrow at the end. Measured in FigJam.
+ */
+export const CONNECTOR_COLOR: Color = { r: 117 / 255, g: 117 / 255, b: 117 / 255, a: 1 }
+export const CONNECTOR_STROKE_WEIGHT = 4
+export const CONNECTOR_CORNER_RADIUS = 24
+
+export function connectorStroke(color: Color = CONNECTOR_COLOR): Stroke {
+ return {
+ type: 'SOLID',
+ color: { ...color },
+ opacity: 1,
+ visible: true,
+ weight: CONNECTOR_STROKE_WEIGHT,
+ align: 'CENTER',
+ cap: 'ROUND',
+ join: 'ROUND'
+ }
+}
+
+export interface ConnectorSublayers {
+ /** The routed line, a vector whose ends carry the connector's caps. */
+ line: SceneNode
+ /** The plate behind the label, which the line breaks around. */
+ labelBackground: SceneNode
+ label: SceneNode
+}
+
+/** A connector's line, label plate, and label, in drawing order. */
+export function connectorSublayers(
+ graph: SceneGraph,
+ connector: SceneNode
+): ConnectorSublayers | null {
+ const children = graph.getChildren(connector.id)
+ if (children.length !== 3) return null
+ const [line, labelBackground, label] = children
+ if (line.type !== 'VECTOR' || label.type !== 'TEXT') return null
+ return { line, labelBackground, label }
+}
+
+/** FigJam keeps a connector's box to its route: it never turns or resizes on its own. */
+export const CONNECTOR_KIND: GeneratedFrameKind = {
+ complete: (graph, frame) => connectorSublayers(graph, frame) !== null,
+ text: () => undefined,
+ rotates: false,
+ resizes: false,
+ namedByText: false
+}
+
+function solid(color: Color, opacity = 1): Fill {
+ return { type: 'SOLID', color: { ...color }, opacity, visible: true }
+}
+
+/** Adds a connector's sublayers to a CONNECTOR the caller created; its route comes later. */
+export function buildConnectorSublayers(
+ graph: SceneGraph,
+ connector: SceneNode,
+ overrides: Partial<Record<keyof ConnectorSublayers, Partial<SceneNode>>> = {}
+): ConnectorSublayers {
+ const empty: VectorNetwork = { vertices: [], segments: [], regions: [] }
+ const line = graph.createNode('VECTOR', connector.id, {
+ name: 'Line',
+ vectorNetwork: empty,
+ fills: [],
+ strokes: [connectorStroke()],
+ strokeWeight: CONNECTOR_STROKE_WEIGHT,
+ cornerRadius: CONNECTOR_CORNER_RADIUS,
+ ...overrides.line
+ })
+ const labelBackground = graph.createNode('RECTANGLE', connector.id, {
+ name: 'Label background',
+ fills: [solid({ r: 1, g: 1, b: 1, a: 1 })],
+ cornerRadius: 3,
+ visible: false,
+ ...overrides.labelBackground
+ })
+ const label = graph.createNode('TEXT', connector.id, {
+ name: 'Label',
+ text: '',
+ fontFamily: 'Inter',
+ fontWeight: 500,
+ fontSize: 16,
+ lineHeight: 24,
+ textAlignHorizontal: 'CENTER',
+ textAutoResize: 'WIDTH_AND_HEIGHT',
+ fills: [solid(BLACK)],
+ visible: false,
+ ...overrides.label
+ })
+ return { line, labelBackground, label }
+}
+
+/**
+ * Where a connector's line starts and ends, in its parent's axes: the ends a connector keeps when
+ * the layers it was attached to are gone.
+ */
+export function connectorRouteEnds(
+ graph: SceneGraph,
+ connector: SceneNode
+): { start: Vector; end: Vector } | null {
+ const line = connectorSublayers(graph, connector)?.line
+ const vertices = line?.vectorNetwork?.vertices ?? []
+ const first = vertices.at(0)
+ const last = vertices.at(-1)
+ if (!line || !first || !last) return null
+ const at = (vertex: Vector) => ({
+ x: connector.x + line.x + vertex.x,
+ y: connector.y + line.y + vertex.y
+ })
+ return { start: at(first), end: at(last) }
+}
+
+/** A free connector end at a point in the connector's parent's axes. */
+export function freeEndpoint(x: number, y: number): ConnectorEndpoint {
+ return { nodeId: null, magnet: 'NONE', position: { x, y } }
+}
+
+/** A connector end bound to a layer, following it by `magnet`. */
+export function boundEndpoint(
+ nodeId: string,
+ magnet: ConnectorEndpoint['magnet'] = 'AUTO'
+): ConnectorEndpoint {
+ return { nodeId, magnet, position: { x: 0, y: 0 } }
+}
+
+/** How far from a line, beyond half its stroke, a point still lands on it, in canvas units. */
+const CONNECTOR_HIT_SLOP = 4
+/** Points sampled along a curved segment to measure distance to it. */
+const CURVE_SAMPLES = 24
+
+function distanceToSegment(p: Vector, a: Vector, b: Vector): number {
+ const dx = b.x - a.x
+ const dy = b.y - a.y
+ const lengthSquared = dx * dx + dy * dy
+ const t =
+ lengthSquared === 0
+ ? 0
+ : Math.max(0, Math.min(1, ((p.x - a.x) * dx + (p.y - a.y) * dy) / lengthSquared))
+ return Math.hypot(p.x - (a.x + t * dx), p.y - (a.y + t * dy))
+}
+
+function cubicPoint(a: Vector, c1: Vector, c2: Vector, b: Vector, t: number): Vector {
+ const u = 1 - t
+ return {
+ x: u * u * u * a.x + 3 * u * u * t * c1.x + 3 * u * t * t * c2.x + t * t * t * b.x,
+ y: u * u * u * a.y + 3 * u * u * t * c1.y + 3 * u * t * t * c2.y + t * t * t * b.y
+ }
+}
+
+/**
+ * Whether a canvas point lands on a connector's line: within half its stroke and a few units of
+ * slop, plus `pad`. A connector is picked by its line, not by the box around its route.
+ */
+export function hitsConnectorLine(
+ graph: SceneGraph,
+ connector: SceneNode,
+ px: number,
+ py: number,
+ pad = 0
+): boolean {
+ const line = connectorSublayers(graph, connector)?.line
+ const network = line?.vectorNetwork
+ if (!line || !network) return false
+ const inverse = Matrix.invert(getWorldMatrix(line, graph))
+ if (!inverse) return false
+ const [x, y] = Matrix.mapPoints(inverse, [px, py])
+ const point = { x, y }
+ const reach = (line.strokes[0]?.weight ?? line.strokeWeight) / 2 + CONNECTOR_HIT_SLOP + pad
+ return network.segments.some((segment) => {
+ const a = network.vertices[segment.start]
+ const b = network.vertices[segment.end]
+ const { tangentStart: ts, tangentEnd: te } = segment
+ if (ts.x === 0 && ts.y === 0 && te.x === 0 && te.y === 0) {
+ return distanceToSegment(point, a, b) <= reach
+ }
+ const c1 = { x: a.x + ts.x, y: a.y + ts.y }
+ const c2 = { x: b.x + te.x, y: b.y + te.y }
+ let previous = a
+ for (let step = 1; step <= CURVE_SAMPLES; step++) {
+ const current = cubicPoint(a, c1, c2, b, step / CURVE_SAMPLES)
+ if (distanceToSegment(point, previous, current) <= reach) return true
+ previous = current
+ }
+ return false
+ })
+}
diff --git a/packages/scene-graph/src/generated/index.ts b/packages/scene-graph/src/generated/index.ts
index 88c94ce56..a1c5422be 100644
--- a/packages/scene-graph/src/generated/index.ts
+++ b/packages/scene-graph/src/generated/index.ts
@@ -1,5 +1,6 @@
import type { SceneGraph } from '../index'
import type { NodeType, SceneNode } from '../types'
+import { CONNECTOR_KIND } from './connector'
import type { GeneratedFrameKind } from './kind'
import { STICKY_KIND } from './sticky'
@@ -13,7 +14,8 @@ import { STICKY_KIND } from './sticky'
* the type.
*/
const GENERATED_FRAME_KINDS: Partial<Record<NodeType, GeneratedFrameKind>> = {
- STICKY: STICKY_KIND
+ STICKY: STICKY_KIND,
+ CONNECTOR: CONNECTOR_KIND
}
export const GENERATED_FRAME_TYPES: ReadonlySet<NodeType> = new Set(
@@ -50,4 +52,5 @@ export function layerResizes(node: Pick<SceneNode, 'type'>): boolean {
}
export type { GeneratedFrameKind } from './kind'
+export * from './connector'
export * from './sticky'
diff --git a/packages/scene-graph/src/hit-test.ts b/packages/scene-graph/src/hit-test.ts
index 0543c83b0..752639930 100644
--- a/packages/scene-graph/src/hit-test.ts
+++ b/packages/scene-graph/src/hit-test.ts
@@ -1,5 +1,6 @@
import type { SceneGraph, SceneNode, NodeType } from './'
import { getWorldMatrix } from './coordinate'
+import { hitsConnectorLine } from './generated/connector'
import Matrix from './matrix'
const CONTAINER_TYPES = new Set<NodeType>([
@@ -172,6 +173,10 @@ function hitTestChildren(
continue
}
+ if (child.type === 'CONNECTOR') {
+ if (hitsConnectorLine(graph, child, px, py, pad)) return child
+ continue
+ }
if (containsPoint(px, py, child, graph, transformCache, pad)) return child
}
diff --git a/packages/scene-graph/src/node-defaults.ts b/packages/scene-graph/src/node-defaults.ts
index f47ef7069..b0ebc0dc9 100644
--- a/packages/scene-graph/src/node-defaults.ts
+++ b/packages/scene-graph/src/node-defaults.ts
@@ -161,6 +161,11 @@ export function createDefaultNode(
minHeight: null,
maxHeight: null,
targetAspectRatio: null,
+ connectorStart: null,
+ connectorEnd: null,
+ connectorLineType: 'ELBOWED',
+ connectorStartCap: 'ROUND',
+ connectorEndCap: 'ARROW_LINES',
isMask: false,
maskType: 'ALPHA',
maskIsOutline: false,
diff --git a/packages/scene-graph/src/transfer/nodes.ts b/packages/scene-graph/src/transfer/nodes.ts
index f4d4858e1..ddc5ea922 100644
--- a/packages/scene-graph/src/transfer/nodes.ts
+++ b/packages/scene-graph/src/transfer/nodes.ts
@@ -101,6 +101,12 @@ export function prepareNodeTransfer(
node: (id) => refs.nodes.get(id) ?? id
})
}
+ // A connector keeps the layers it was attached to when they are left behind; the end becomes
+ // free where nothing by that ID exists, as a pasted Figma connector does.
+ for (const field of ['connectorStart', 'connectorEnd'] as const) {
+ const endpoint = result[field]
+ if (endpoint?.nodeId) endpoint.nodeId = refs.nodes.get(endpoint.nodeId) ?? endpoint.nodeId
+ }
for (const paths of [result.fillGeometry, result.strokeGeometry]) {
for (const path of paths ?? []) if (path.fillStyleId) path.fillStyleId = style(path.fillStyleId)
}
diff --git a/packages/scene-graph/src/types.ts b/packages/scene-graph/src/types.ts
index ffa985845..7d37131e3 100644
--- a/packages/scene-graph/src/types.ts
+++ b/packages/scene-graph/src/types.ts
@@ -188,7 +188,15 @@ export interface Fill {
customEffectId?: string
}
-export type StrokeCap = 'NONE' | 'ROUND' | 'SQUARE' | 'ARROW_LINES' | 'ARROW_EQUILATERAL'
+export type StrokeCap =
+ | 'NONE'
+ | 'ROUND'
+ | 'SQUARE'
+ | 'ARROW_LINES'
+ | 'ARROW_EQUILATERAL'
+ | 'TRIANGLE_FILLED'
+ | 'DIAMOND_FILLED'
+ | 'CIRCLE_FILLED'
export type StrokeJoin = 'MITER' | 'BEVEL' | 'ROUND'
export type SharedStyleType = 'FILL' | 'TEXT' | 'EFFECT' | 'GRID'
export type SharedStyleKind = 'fill' | 'stroke' | 'text' | 'effect' | 'grid'
@@ -239,6 +247,32 @@ export interface Effect {
export type ConstraintType = 'MIN' | 'CENTER' | 'MAX' | 'STRETCH' | 'SCALE'
export type TextAutoResize = 'NONE' | 'HEIGHT' | 'WIDTH_AND_HEIGHT' | 'TRUNCATE'
+
+/** Where a connector end attaches to a layer: a side, the side Figma picks, or a fixed point. */
+export type ConnectorMagnet =
+ | 'NONE'
+ | 'AUTO'
+ | 'AUTO_HORIZONTAL'
+ | 'TOP'
+ | 'RIGHT'
+ | 'BOTTOM'
+ | 'LEFT'
+ | 'CENTER'
+ | 'EDGE'
+ | 'ABSOLUTE'
+
+/**
+ * One end of a connector. Bound to a layer, it follows the layer by `magnet`, or by `position`
+ * in the layer's own axes when the magnet is `NONE`. Free, `nodeId` is null and `position` is in
+ * the connector's parent's axes.
+ */
+export interface ConnectorEndpoint {
+ nodeId: string | null
+ magnet: ConnectorMagnet
+ position: Vector
+}
+
+export type ConnectorLineType = 'ELBOWED' | 'STRAIGHT' | 'CURVED'
export type TextAlignVertical = 'TOP' | 'CENTER' | 'BOTTOM'
export type TextCase = 'ORIGINAL' | 'UPPER' | 'LOWER' | 'TITLE'
export type TextDecoration = 'NONE' | 'UNDERLINE' | 'STRIKETHROUGH'
@@ -662,6 +696,13 @@ export interface SceneNode {
*/
targetAspectRatio: Vector | null
+ /** A connector's ends and the line between them; null on other layers. */
+ connectorStart: ConnectorEndpoint | null
+ connectorEnd: ConnectorEndpoint | null
+ connectorLineType: ConnectorLineType
+ connectorStartCap: StrokeCap
+ connectorEndCap: StrokeCap
+
isMask: boolean
maskType: MaskType
maskIsOutline: boolean
diff --git a/packages/scene-graph/tests/generated/connector.test.ts b/packages/scene-graph/tests/generated/connector.test.ts
new file mode 100644
index 000000000..b92eabec8
--- /dev/null
+++ b/packages/scene-graph/tests/generated/connector.test.ts
@@ -0,0 +1,102 @@
+import { describe, expect, test } from 'bun:test'
+
+import {
+ applyGraphTransfer,
+ boundEndpoint,
+ buildConnectorSublayers,
+ freeEndpoint,
+ prepareGraphTransfer,
+ SceneGraph
+} from '@open-pencil/scene-graph'
+import type { VectorNetwork } from '@open-pencil/scene-graph'
+
+const straight = { tangentStart: { x: 0, y: 0 }, tangentEnd: { x: 0, y: 0 } }
+
+/** An L route from (0, 0) right to (200, 0), then down to (200, 200). */
+const L_ROUTE: VectorNetwork = {
+ vertices: [
+ { x: 0, y: 0 },
+ { x: 200, y: 0 },
+ { x: 200, y: 200 }
+ ],
+ segments: [
+ { start: 0, end: 1, ...straight },
+ { start: 1, end: 2, ...straight }
+ ],
+ regions: []
+}
+
+function connectedBoxes() {
+ const graph = new SceneGraph()
+ const page = graph.getPages()[0].id
+ const from = graph.createNode('RECTANGLE', page, {
+ name: 'From',
+ x: 0,
+ y: 0,
+ width: 100,
+ height: 100
+ })
+ const to = graph.createNode('RECTANGLE', page, {
+ name: 'To',
+ x: 400,
+ y: 400,
+ width: 100,
+ height: 100
+ })
+ const connector = graph.createNode('CONNECTOR', page, {
+ x: 100,
+ y: 50,
+ width: 200,
+ height: 200,
+ connectorStart: boundEndpoint(from.id, 'RIGHT'),
+ connectorEnd: boundEndpoint(to.id, 'TOP')
+ })
+ buildConnectorSublayers(graph, connector, {
+ line: { vectorNetwork: L_ROUTE, width: 200, height: 200 }
+ })
+ return { graph, page, from, to, connector }
+}
+
+describe('connectors', () => {
+ test('a click lands on a connector along its line, not in the empty box around its route', () => {
+ const { graph, connector } = connectedBoxes()
+ expect(graph.hitTest(200, 52)?.id).toBe(connector.id)
+ expect(graph.hitTest(302, 150)?.id).toBe(connector.id)
+ expect(graph.hitTest(150, 200)).toBeNull()
+ })
+
+ test('a copy with its layers binds to their copies; one without keeps naming the originals', () => {
+ const { graph, page, from, to, connector } = connectedBoxes()
+ const target = new SceneGraph()
+ const together = prepareGraphTransfer({
+ source: graph,
+ target,
+ rootIds: [from.id, to.id, connector.id],
+ dependencyPageIds: [],
+ parentId: target.getPages()[0].id
+ })
+ applyGraphTransfer(target, together)
+ const copied = [...target.nodes.values()].find((node) => node.type === 'CONNECTOR')
+ const fromCopy = [...target.nodes.values()].find((node) => node.name === 'From')
+ expect(copied?.connectorStart?.nodeId).toBe(fromCopy?.id)
+ expect(copied?.connectorStart?.nodeId).not.toBe(from.id)
+
+ const alone = prepareGraphTransfer({
+ source: graph,
+ target: graph,
+ rootIds: [connector.id],
+ dependencyPageIds: [],
+ parentId: page
+ })
+ const props = alone.nodes.find((node) => node.props.type === 'CONNECTOR')?.props
+ expect(props?.connectorEnd?.nodeId).toBe(to.id)
+ })
+
+ test('a free end keeps its point', () => {
+ expect(freeEndpoint(10, 20)).toEqual({
+ nodeId: null,
+ magnet: 'NONE',
+ position: { x: 10, y: 20 }
+ })
+ })
+})
diff --git a/src/app/editor/icons.ts b/src/app/editor/icons.ts
index e698f6eba..a8d57ad80 100644
--- a/src/app/editor/icons.ts
+++ b/src/app/editor/icons.ts
@@ -15,6 +15,7 @@ import IconPenTool from '~icons/lucide/pen-tool'
import IconPencil from '~icons/lucide/pencil'
import IconRows from '~icons/lucide/rows-3'
import IconSmile from '~icons/lucide/smile'
+import IconSpline from '~icons/lucide/spline'
import IconSquare from '~icons/lucide/square'
import IconSlot from '~icons/lucide/square-dashed'
import IconStar from '~icons/lucide/star'
@@ -55,7 +56,8 @@ export const NODE_ICONS: Partial<Record<string, typeof IconSquare>> = {
TEXT: IconType,
VECTOR: IconPenTool,
RECTANGLE: IconSquare,
- STICKY: IconStickyNote
+ STICKY: IconStickyNote,
+ CONNECTOR: IconSpline
}
export const AUTO_LAYOUT_ICONS: Partial<Record<string, typeof IconSquare>> = {
diff --git a/tests/e2e/canvas/connectors-visual.spec.ts b/tests/e2e/canvas/connectors-visual.spec.ts
new file mode 100644
index 000000000..3878e2d6e
--- /dev/null
+++ b/tests/e2e/canvas/connectors-visual.spec.ts
@@ -0,0 +1,14 @@
+import { readFile } from 'node:fs/promises'
+
+import { expect, test, useEditorSetupWithClear } from '#tests/e2e/fixtures'
+import { pasteFigmaClipboard } from '#tests/helpers/canvas/figma-paste'
+
+const editor = useEditorSetupWithClear('/?test&no-chrome&no-rulers')
+
+test('FigJam connectors draw their elbows, curve, caps, dashes, and label as Figma routed them', async () => {
+ const html = await readFile('tests/fixtures/clipboard/figjam-connectors.html', 'utf8')
+ await pasteFigmaClipboard(editor.page, html)
+ await editor.canvas.waitForRender()
+ editor.canvas.assertNoErrors()
+ expect(await editor.canvas.screenshotCanvasRegion()).toMatchSnapshot('figjam-connectors.png')
+})
diff --git a/tests/e2e/canvas/connectors-visual.spec.ts-snapshots/figjam-connectors-openpencil-darwin.png b/tests/e2e/canvas/connectors-visual.spec.ts-snapshots/figjam-connectors-openpencil-darwin.png
new file mode 100644
index 000000000..b07ba103d
Binary files /dev/null and b/tests/e2e/canvas/connectors-visual.spec.ts-snapshots/figjam-connectors-openpencil-darwin.png differ
diff --git a/tests/engine/vector/fill-geometry-regen.test.ts b/tests/engine/vector/fill-geometry-regen.test.ts
index 4ea0917f4..10f7fa110 100644
--- a/tests/engine/vector/fill-geometry-regen.test.ts
+++ b/tests/engine/vector/fill-geometry-regen.test.ts
@@ -109,7 +109,7 @@ describe('regenerateFillGeometry', () => {
network.regions = []
const [g] = regenerateFillGeometry(network, [ENTRY])
const cmds = decode(g.commandsBlob)
- expect(cmds[0]).toBe('M 0,0')
- expect(cmds).toHaveLength(5) // M + 4 line segments around the square
+ // The chain closes, so the path does too.
+ expect(cmds).toEqual(['M 0,0', 'L 10,0', 'L 10,10', 'L 0,10', 'L 0,0', 'Z'])
})
})
diff --git a/tests/fixtures/clipboard/figjam-connectors.html b/tests/fixtures/clipboard/figjam-connectors.html
new file mode 100644
index 000000000..891378725
--- /dev/null
+++ b/tests/fixtures/clipboard/figjam-connectors.html
@@ -0,0 +1,7 @@
+<meta charset="utf-8" /><meta charset="utf-8" /><span
+ data-metadata="<!--(figmeta)eyJmaWxlS2V5IjoiZ2lWd0FNRGdRajFycVlGdlozd1MyYiIsInBhc3RlSUQiOjE2MDQ3MDMxNTYsImRhdGFUeXBlIjoic2NlbmUiLCJlZGl0b3JUeXBlIjoiZmlnamFtIiwiZW52aXJvbm1lbnQiOiJ3d3cuZmlnbWEuY29tIiwic2VsZWN0ZWROb2RlRGF0YSI6IjI6OTR8OXwwfDAsMjo5MHw5fDB8MCwyOjg2fDl8MHwwLDI6ODJ8OXwwfDAsMjo3OXw4fDB8MCwyOjc1fDd8MHwwLDI6NzF8N3wwfDAiLCJpbWFnZUhhc2hlcyI6e319Cg==(/figmeta)-->"
+></span
+><span
+ data-buffer="<!--(figma)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(/figma)-->"
+></span
+><span style="font-size: 16px; white-space: pre-wrap">label</span>
diff --git a/tests/helpers/canvas/figma-paste.ts b/tests/helpers/canvas/figma-paste.ts
new file mode 100644
index 000000000..e24f61b11
--- /dev/null
+++ b/tests/helpers/canvas/figma-paste.ts
@@ -0,0 +1,36 @@
+import type { Page } from '@playwright/test'
+
+/** Space around the pasted layers when they are shown, in screen pixels. */
+const MARGIN = 40
+
+/**
+ * Setup: pastes Figma clipboard HTML onto the current page and shows all of it in the canvas's
+ * top-left `region`, the area `screenshotCanvasRegion` captures by default.
+ */
+export function pasteFigmaClipboard(
+ page: Page,
+ html: string,
+ region = { width: 900, height: 700 }
+): Promise<void> {
+ return page.evaluate(
+ async ({ markup, margin, region }) => {
+ const store = window.openPencil?.getStore?.()
+ if (!store) throw new Error('OpenPencil store not initialized')
+ await store.pasteFromHTML(markup)
+ store.clearSelection()
+ const layers = store.graph.getChildren(store.state.currentPageId)
+ const left = Math.min(...layers.map((layer) => layer.x))
+ const top = Math.min(...layers.map((layer) => layer.y))
+ const right = Math.max(...layers.map((layer) => layer.x + layer.width))
+ const bottom = Math.max(...layers.map((layer) => layer.y + layer.height))
+ const width = region.width - 2 * margin
+ const height = region.height - 2 * margin
+ const zoom = Math.min(width / (right - left), height / (bottom - top))
+ store.state.zoom = zoom
+ store.state.panX = margin - left * zoom
+ store.state.panY = margin - top * zoom
+ store.requestRender()
+ },
+ { markup: html, margin: MARGIN, region }
+ )
+}