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.mdnew file mode 100644index 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.tsindex 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[] | nullif (!node.vectorNetwork) return nullconst 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.tsindex 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.tsindex 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 } = networkif (regions.length > 0) {@@ -56,14 +61,14 @@ export function vectorNetworkToPath(ck: CanvasKit, network: VectorNetwork): Pathconst 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.tsindex 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.tsnew file mode 100644index 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.tsindex 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.tsindex 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.tsnew file mode 100644index 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.tsindex 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.tsindex 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.tsindex 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) returnconst 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.tsindex 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.tsindex 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.tsnew file mode 100644index 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.tsindex 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.tsnew file mode 100644index 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.mdindex 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.tsindex 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.tsnew file mode 100644index 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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: booleanmaskType: MaskTypemaskIsOutline: booleandiff --git a/packages/scene-graph/tests/generated/connector.test.ts b/packages/scene-graph/tests/generated/connector.test.tsnew file mode 100644index 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.tsindex 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.tsnew file mode 100644index 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.pngnew file mode 100644index 000000000..b07ba103dBinary files /dev/null and b/tests/e2e/canvas/connectors-visual.spec.ts-snapshots/figjam-connectors-openpencil-darwin.png differdiff --git a/tests/engine/vector/fill-geometry-regen.test.ts b/tests/engine/vector/fill-geometry-regen.test.tsindex 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.htmlnew file mode 100644index 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.tsnew file mode 100644index 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 }+ )+}