AI-native design editor. Open-source Figma alternative.
feat: drag connector segments and curves as FigJam does (#1419)
Danila Poyarkov87cff1d859ee
diff --git a/changes/1419/added.md b/changes/1419/added.mdnew file mode 100644index 000000000..d86b7b04c--- /dev/null+++ b/changes/1419/added.md@@ -0,0 +1 @@+- Dragging a selected connector's segment, curve, or label reroutes it as FigJam does, and `.fig` files and the Figma clipboard keep those routes and label places.diff --git a/packages/core/src/canvas/overlays/connectors.ts b/packages/core/src/canvas/overlays/connectors.tsindex a55a4ded4..1b97a255f 100644--- a/packages/core/src/canvas/overlays/connectors.ts+++ b/packages/core/src/canvas/overlays/connectors.ts@@ -9,6 +9,8 @@ import type { Vector } from '@open-pencil/scene-graph/primitives'import type { SkiaRenderer } from '#core/canvas/renderer'import type { ConnectorTarget } from '#core/editor/connectors/attach'import {+ CONNECTOR_SEGMENT_HANDLE,+ connectorRouteHandles,connectorScreenEnds,createSceneGeometry,viewportMatrix,@@ -66,7 +68,36 @@ export function drawConnectorHover(strokeConnectorLine(r, canvas, graph, connector, r.auxStroke, preview)}-/** A selected connector, as FigJam shows it: its line outlined and a handle at each end. */+/**+ * The handles that drag a selected connector's line, as FigJam draws them: a bar along the middle+ * of each elbow segment, no longer than the segment, and a dot midway along a curve, both solid.+ */+function drawConnectorRouteHandles(+ r: SkiaRenderer,+ canvas: Canvas,+ graph: SceneGraph,+ connector: SceneNode,+ preview?: RotationPreview | null+) {+ r.auxFill.setMaskFilter(null)+ r.auxFill.setColor(r.selColor())+ const { length, thickness } = CONNECTOR_SEGMENT_HANDLE+ for (const handle of connectorRouteHandles(graph, connector, r, preview)) {+ if (handle.kind === 'curve') {+ canvas.drawCircle(handle.at.x, handle.at.y, CONNECTOR_HANDLE_RADIUS, r.auxFill)+ continue+ }+ const along = Math.min(length, handle.length)+ const [width, height] = handle.vertical ? [thickness, along] : [along, thickness]+ const rect = r.ck.XYWHRect(handle.at.x - width / 2, handle.at.y - height / 2, width, height)+ canvas.drawRRect(r.ck.RRectXY(rect, thickness / 2, thickness / 2), r.auxFill)+ }+}++/**+ * A selected connector, as FigJam shows it: its line outlined, the handles that drag its line,+ * and a handle at each end.+ */export function drawConnectorSelection(r: SkiaRenderer,canvas: Canvas,@@ -75,6 +106,7 @@ export function drawConnectorSelection(preview?: RotationPreview | null) {drawConnectorHover(r, canvas, graph, connector, preview)+ drawConnectorRouteHandles(r, canvas, graph, connector, preview)const ends = connectorScreenEnds(graph, connector, r, preview)if (!ends) returndrawDot(r, canvas, ends.start, CONNECTOR_HANDLE_RADIUS, false)diff --git a/packages/core/src/canvas/overlays/feedback.ts b/packages/core/src/canvas/overlays/feedback.tsindex 597725b5d..0088aca9e 100644--- a/packages/core/src/canvas/overlays/feedback.ts+++ b/packages/core/src/canvas/overlays/feedback.ts@@ -1,11 +1,14 @@import type { Canvas } from 'canvaskit-wasm'import type { SceneGraph } from '@open-pencil/scene-graph'+import { CONNECTOR_LABEL_PADDING, labelledConnector } from '@open-pencil/scene-graph/connectors'import type { Rect } from '@open-pencil/scene-graph/primitives'import type { SnapGuide } from '@open-pencil/scene-graph/snap'+import { paintFills } from '#core/canvas/fills'import { drawNodeHighlightRect } from '#core/canvas/highlight-rect'import type { RenderOverlays, SkiaRenderer } from '#core/canvas/renderer'+import { connectorLabelPlaceholderNode } from '#core/canvas/text/placeholder'import {DROP_HIGHLIGHT_ALPHA,DROP_HIGHLIGHT_STROKE,@@ -176,7 +179,21 @@ export function drawEditingText(const node = overlays.editingTextId ? graph.getNode(overlays.editingTextId) : undefinedconst editor = overlays.textEditorif (!node || !editor?.state?.paragraph) return- inNodeSpace(r, canvas, createSceneGeometry(graph, overlays.rotationPreview), node, () =>- r.drawTextEditOverlay(canvas, node, editor)+ // A connector label is outlined by its plate, as FigJam outlines it, and shows its+ // placeholder while it is empty.+ const outset = labelledConnector(graph, node) ? CONNECTOR_LABEL_PADDING : 0+ const placeholder = connectorLabelPlaceholderNode(+ graph,+ node,+ r.connectorLabelPlaceholder,+ node.id)+ inNodeSpace(r, canvas, createSceneGeometry(graph, overlays.rotationPreview), node, () => {+ if (placeholder) {+ paintFills(r, placeholder.fills, placeholder, graph, (fill) =>+ r.renderText(canvas, placeholder, fill)+ )+ }+ r.drawTextEditOverlay(canvas, node, editor, outset)+ })}diff --git a/packages/core/src/canvas/overlays/selection.ts b/packages/core/src/canvas/overlays/selection.tsindex 43a6d074f..881516d27 100644--- a/packages/core/src/canvas/overlays/selection.ts+++ b/packages/core/src/canvas/overlays/selection.ts@@ -119,7 +119,9 @@ function drawSingleSelection(const rotation = node.rotationif (node.type === 'CONNECTOR') {- drawConnectorSelection(r, canvas, graph, node, preview)+ // While its label is typed into, FigJam shows only the label's box.+ const label = overlays.editingTextId ? graph.getNode(overlays.editingTextId) : undefined+ if (label?.parentId !== node.id) drawConnectorSelection(r, canvas, graph, node, preview)} else if (isPathText) {drawTextPathSelection(r, canvas, node, rotation, graph, editing, preview)if (!editing) r.drawSelectionLabels(canvas, graph, selectedIds, overlays)diff --git a/packages/core/src/canvas/overlays/text-edit.ts b/packages/core/src/canvas/overlays/text-edit.tsindex 40784cbc0..5d19e45ed 100644--- a/packages/core/src/canvas/overlays/text-edit.ts+++ b/packages/core/src/canvas/overlays/text-edit.ts@@ -31,7 +31,9 @@ export function drawTextEditOverlay(r: SkiaRenderer,canvas: Canvas,node: SceneNode,- editor: TextEditor+ editor: TextEditor,+ /** How far the outline sits outside the text, as around a connector label's plate. */+ outset = 0): void {// Path text lays the paragraph out flat and then maps each glyph onto the// path. The flat caret / selection rects are in that flat space, so painting@@ -44,7 +46,10 @@ export function drawTextEditOverlay(}withScreenStroke(r, { color: r.selColor() }, (paint) =>- canvas.drawRect(r.ck.LTRBRect(0, 0, node.width, node.height), paint)+ canvas.drawRect(+ r.ck.LTRBRect(-outset, -outset, node.width + outset, node.height + outset),+ paint+ ))const selRects = editor.getSelectionRects()diff --git a/packages/core/src/canvas/renderer.ts b/packages/core/src/canvas/renderer.tsindex 19f14c7e8..7e802fc80 100644--- a/packages/core/src/canvas/renderer.ts+++ b/packages/core/src/canvas/renderer.ts@@ -173,6 +173,8 @@ export class SkiaRenderer {* null for a canvas that draws only the document, such as an export.*/stickyPlaceholder: string | null = null+ /** What an empty connector label shows while it is typed into; null draws nothing. */+ connectorLabelPlaceholder: string | null = nulltracksSceneSettlement = true/** Colour space this renderer's surface presents; colours convert into it when painting. */presentationColorSpace: RenderColorSpace = 'srgb'diff --git a/packages/core/src/canvas/renderer/methods.ts b/packages/core/src/canvas/renderer/methods.tsindex 54869a195..7e6417a8e 100644--- a/packages/core/src/canvas/renderer/methods.ts+++ b/packages/core/src/canvas/renderer/methods.ts@@ -146,8 +146,8 @@ const rendererMethods = {Overlays.drawAutoLayoutHover(this, canvas, graph, hover)},- drawTextEditOverlay(canvas: Canvas, node: SceneNode, editor: TextEditor): void {- Overlays.drawTextEditOverlay(this, canvas, node, editor)+ drawTextEditOverlay(canvas: Canvas, node: SceneNode, editor: TextEditor, outset = 0): void {+ Overlays.drawTextEditOverlay(this, canvas, node, editor, outset)},drawNodeEditOverlay(diff --git a/packages/core/src/canvas/scene.ts b/packages/core/src/canvas/scene.tsindex b0a2cf33e..c7f6eb5f0 100644--- a/packages/core/src/canvas/scene.ts+++ b/packages/core/src/canvas/scene.ts@@ -60,7 +60,7 @@ import {isReflowedPathText} from './text/derived'import { drawLaidOutEmoji, drawSavedEmoji } from './text/emoji'-import { stickyPlaceholderNode } from './text/sticky-placeholder'+import { stickyPlaceholderNode } from './text/placeholder'function drawVisibleFills(r: SkiaRenderer,diff --git a/packages/core/src/canvas/text/sticky-placeholder.ts b/packages/core/src/canvas/text/placeholder.tssimilarity index 55%rename from packages/core/src/canvas/text/sticky-placeholder.tsrename to packages/core/src/canvas/text/placeholder.tsindex 5f9ec1608..90b27e73d 100644--- a/packages/core/src/canvas/text/sticky-placeholder.ts+++ b/packages/core/src/canvas/text/placeholder.ts@@ -1,7 +1,35 @@import type { SceneGraph, SceneNode } from '@open-pencil/scene-graph'+import { labelledConnector } from '@open-pencil/scene-graph/connectors'import { BLACK } from '@open-pencil/scene-graph/constants'import { generatedFrameOwner, stickySublayers } from '@open-pencil/scene-graph/generated'+/** An empty text drawn as `placeholder`, black at 30%, as FigJam draws its placeholders. */+function withPlaceholder(node: SceneNode, placeholder: string): SceneNode {+ return {+ ...node,+ text: placeholder,+ styleRuns: [],+ textParagraphs: [],+ derivedTextGlyphs: null,+ fills: [{ type: 'SOLID', color: { ...BLACK }, opacity: 0.3, visible: true }]+ }+}++/**+ * An empty connector label while it is typed into, as FigJam draws it under the caret:+ * `placeholder` in the label's style, black at 30%. A label not being edited stays empty and+ * undrawn.+ */+export function connectorLabelPlaceholderNode(+ graph: SceneGraph,+ node: SceneNode,+ placeholder: string | null,+ editingTextId: string | null | undefined+): SceneNode | null {+ if (!placeholder || node.id !== editingTextId || node.text !== '') return null+ return labelledConnector(graph, node) ? withPlaceholder(node, placeholder) : null+}+/*** The body of an empty sticky note as an editing canvas draws it: `placeholder`, in the* interface language, in the body's style, black at 30%, as measured in FigJam. The note's text@@ -15,12 +43,5 @@ export function stickyPlaceholderNode(if (!placeholder || node.type !== 'TEXT' || node.text !== '') return nullconst sticky = generatedFrameOwner(graph, node)if (sticky?.type !== 'STICKY' || stickySublayers(graph, sticky)?.body.id !== node.id) return null- return {- ...node,- text: placeholder,- styleRuns: [],- textParagraphs: [],- derivedTextGlyphs: null,- fills: [{ type: 'SOLID', color: { ...BLACK }, opacity: 0.3, visible: true }]- }+ return withPlaceholder(node, placeholder)}diff --git a/packages/core/src/clipboard.ts b/packages/core/src/clipboard.tsindex 13e88b1d1..0bc992e5e 100644--- a/packages/core/src/clipboard.ts+++ b/packages/core/src/clipboard.ts@@ -5,6 +5,7 @@ import {} from '@open-pencil/fig/clipboard'import {placeSlotContent,+ relinkConnectorEnds,type FigNodeChangeExportRuntime,sceneNodeToKiwi,makeDocumentNodeChange,@@ -230,6 +231,8 @@ async function writeFigmaClipboardHTML().lengthplaceSlotContent(slotContentRecords, dependencyCanvas, written, fractionalPosition)nodeChanges.push(...slotContentRecords)+ // A connector copied before a layer its end joins is joined to it now that both have GUIDs.+ relinkConnectorEnds(nodeChanges, graph, nodeIdToGuid)// Pair each text record with the node it was written from; instance content and slot// content are not emitted in traversal order.const textById = new Map(exportedTextNodes.map((node) => [node.id, node]))diff --git a/packages/core/src/editor/connectors/label-edit.ts b/packages/core/src/editor/connectors/label-edit.tsnew file mode 100644index 000000000..be5a29c02--- /dev/null+++ b/packages/core/src/editor/connectors/label-edit.ts@@ -0,0 +1,27 @@+import type { SceneNode } from '@open-pencil/scene-graph'+import { labelledConnector } from '@open-pencil/scene-graph/connectors'++import type { EditorContext } from '#core/editor/types'+import { measureTextForLayout } from '#core/layout/text-measurement'++/**+ * Sizes an empty connector label to the placeholder its canvas shows while it is typed into, as+ * FigJam sizes the box it outlines then, and returns what puts the label's size back if it is+ * left empty. The size is a preview: the label's text sizes it once typed.+ */+export function fitEmptyLabelToPlaceholder(+ ctx: EditorContext,+ node: SceneNode+): (() => void) | null {+ // The scene's renderer carries the placeholder; an overlay renderer draws no text.+ const placeholder = [...ctx.getRenderers()].find(+ (renderer) => renderer.connectorLabelPlaceholder+ )?.connectorLabelPlaceholder+ if (!placeholder || node.text !== '' || !labelledConnector(ctx.graph, node)) return null+ const before = { width: node.width, height: node.height }+ ctx.graph.updateNodePreview(node.id, measureTextForLayout({ ...node, text: placeholder }))+ return () => {+ const label = ctx.graph.getNode(node.id)+ if (label?.text === '') ctx.graph.updateNodePreview(node.id, before)+ }+}diff --git a/packages/core/src/editor/connectors/line.ts b/packages/core/src/editor/connectors/line.tsnew file mode 100644index 000000000..9f4630693--- /dev/null+++ b/packages/core/src/editor/connectors/line.ts@@ -0,0 +1,146 @@+import type { SceneNode } from '@open-pencil/scene-graph'+import {+ connectorLabelPositionAt,+ connectorRoute,+ connectorSublayers,+ curveControlPoints,+ dragCurve,+ dragElbowSegment,+ elbowJoints,+ type ConnectorPiece+} from '@open-pencil/scene-graph/connectors'+import { getParentWorldMatrix } from '@open-pencil/scene-graph/coordinate'+import Matrix from '@open-pencil/scene-graph/matrix'+import type { Rect, Vector } from '@open-pencil/scene-graph/primitives'++import type { NodePreview } from '#core/editor/node-preview'+import type { EditorContext } from '#core/editor/types'++type BeginNodePreview = (label?: string) => NodePreview++const PREVIEW_LABELS: Record<ConnectorLinePart['kind'], string> = {+ segment: 'Move connector segment',+ curve: 'Bend connector',+ label: 'Move connector label'+}++/** What a drag on a connector's line holds: an elbow segment by its index, the curve, or the label. */+export type ConnectorLinePart =+ | { kind: 'segment'; index: number }+ | { kind: 'curve' }+ | { kind: 'label' }++interface LineDrag {+ connectorId: string+ part: ConnectorLinePart+ /** Where the press was, in the connector's parent's axes. */+ press: Vector+ /** The route as the drag found it, in the connector's parent's axes. */+ pieces: ConnectorPiece[]+ joints: [Vector, Vector]+ handles: [Vector, Vector] | null+ /** The label's plate as the drag found it, in the connector's parent's axes. */+ plate: Rect | null+ preview: NodePreview+}++function shifted(point: Vector, by: Vector): Vector {+ return { x: point.x + by.x, y: point.y + by.y }+}++/**+ * Dragging a selected connector's line, as FigJam does: an elbow segment moves across itself, to+ * whole pixels, a curve bends so the point midway along it follows the pointer, and the label+ * slides along the line or off to one side of it. The connector keeps the result, and one undo+ * step puts it back.+ */+export function createConnectorLineActions(ctx: EditorContext, beginNodePreview: BeginNodePreview) {+ let drag: LineDrag | null = null++ /** A canvas point in the connector's parent's axes. */+ function inParent(connector: SceneNode, x: number, y: number): Vector {+ const parent = connector.parentId ? ctx.graph.getNode(connector.parentId) : undefined+ const toParent = Matrix.invert(getParentWorldMatrix(parent, ctx.graph)) ?? Matrix.identity()+ return Matrix.mapPoint(toParent, { x, y })+ }++ function connectorLineBegin(connectorId: string, part: ConnectorLinePart, x: number, y: number) {+ connectorLineCancel()+ const connector = ctx.graph.getNode(connectorId)+ const route = connector ? connectorRoute(ctx.graph, connector) : null+ if (!connector || !route) return+ const curve = route.pieces.at(0)+ const plate = connectorSublayers(ctx.graph, connector)?.labelBackground+ drag = {+ connectorId,+ part,+ press: inParent(connector, x, y),+ pieces: route.pieces,+ joints: elbowJoints(route.start, route.end, route.sides),+ handles: route.controls.curve ?? (curve ? curveControlPoints(curve) : null),+ plate: plate+ ? {+ x: connector.x + plate.x,+ y: connector.y + plate.y,+ width: plate.width,+ height: plate.height+ }+ : null,+ preview: beginNodePreview(PREVIEW_LABELS[part.kind])+ }+ }++ function connectorLineDrag(x: number, y: number) {+ const current = drag+ const connector = current ? ctx.graph.getNode(current.connectorId) : undefined+ if (!current || !connector) return+ const point = inParent(connector, x, y)+ const delta = { x: point.x - current.press.x, y: point.y - current.press.y }+ // Control points sit in the connector's own axes.+ const local = { x: -connector.x, y: -connector.y }+ if (current.part.kind === 'label') {+ if (!current.plate) return+ const { x: px, y: py, width, height } = current.plate+ // The label's centre follows the pointer, wherever the plate was grabbed.+ const centre = { x: px + width / 2 + delta.x, y: py + height / 2 + delta.y }+ const position = connectorLabelPositionAt(current.pieces, { width, height }, centre)+ if (position) current.preview.update(connector.id, { connectorLabelPosition: position })+ return+ }+ if (current.part.kind === 'curve') {+ if (!current.handles) return+ const [first, second] = dragCurve(current.handles, delta)+ current.preview.update(connector.id, {+ connectorCurveHandles: [shifted(first, local), shifted(second, local)]+ })+ return+ }+ const piece = current.pieces.at(current.part.index)+ if (!piece) return+ const vertical = piece.from.x === piece.to.x+ const offset = Math.round(vertical ? piece.from.x + delta.x : piece.from.y + delta.y)+ const points = dragElbowSegment(current.pieces, current.joints, current.part.index, offset)+ current.preview.update(connector.id, {+ connectorControlPoints: points.map((control) => ({+ ...control,+ position: shifted(control.position, local)+ }))+ })+ }++ function connectorLineCommit() {+ const current = drag+ drag = null+ current?.preview.commit()+ ctx.requestRender()+ }++ function connectorLineCancel() {+ const current = drag+ drag = null+ current?.preview.cancel()+ ctx.requestRender()+ }++ return { connectorLineBegin, connectorLineDrag, connectorLineCommit, connectorLineCancel }+}diff --git a/packages/core/src/editor/connectors/routing.ts b/packages/core/src/editor/connectors/routing.tsindex f25ccb371..4d1d4718b 100644--- a/packages/core/src/editor/connectors/routing.ts+++ b/packages/core/src/editor/connectors/routing.ts@@ -28,9 +28,17 @@ const CONNECTOR_FIELDS: ReadonlySet<string> = new Set<keyof SceneNode>(['connectorEnd','connectorLineType','connectorStartCap',- 'connectorEndCap'+ 'connectorEndCap',+ 'connectorControlPoints',+ 'connectorCurveHandles',+ 'connectorLabelPosition'])+/** What keeping a dragged elbow's new route as its control points changes on the connector. */+const CAPTURED_FIELDS = ['x', 'y', 'connectorControlPoints'] as const++type Captured = Pick<SceneNode, (typeof CAPTURED_FIELDS)[number]>+/** Fields of a connector's sublayers that change its route: the line's weight, the label's size. */const SUBLAYER_FIELDS: ReadonlySet<string> = new Set<string>([...SIZE_FIELDS,@@ -64,8 +72,13 @@ function carriedFreeEnds(graph: SceneGraph, connector: SceneNode): Partial<Scene* once the page it is on is shown.*/export function createConnectorRouting(ctx: EditorContext) {- /** Layers changed since the last pass, and whether any change was more than a preview. */- let pending: { ids: Set<string>; committed: boolean } | null = null+ /**+ * Layers changed since the last pass, whether any change was more than a preview, and whether+ * undo or redo made any.+ */+ let pending: { ids: Set<string>; committed: boolean; replayed: boolean } | null = null+ /** The step an edit just recorded, which the pass that follows the edit may join. */+ let freshStep: UndoEntry | null = nulllet routing = false/*** The ends of connectors moved since the last undo step, as they were before the move. A move@@ -79,11 +92,12 @@ export function createConnectorRouting(ctx: EditorContext) {function schedule(id: string, committed: boolean) {if (routing || ctx.graph.isApplyingImportedState) returnif (!pending) {- pending = { ids: new Set(), committed: false }+ pending = { ids: new Set(), committed: false, replayed: false }queueMicrotask(flush)}pending.ids.add(id)pending.committed ||= committed+ pending.replayed ||= ctx.undo.isReplaying}function changed(id: string, changes: Partial<SceneNode>, committed: boolean) {@@ -147,6 +161,16 @@ export function createConnectorRouting(ctx: EditorContext) {const step = ctx.undo.peekUndo()const fresh = step !== undefined && !seenSteps.has(step)if (step) seenSteps.add(step)+ if (step && fresh) {+ freshStep = step+ // The pass an edit schedules runs in a microtask queued while the edit runs, before or+ // after it records its step, so both come before this one's inner microtask.+ queueMicrotask(() =>+ queueMicrotask(() => {+ if (freshStep === step) freshStep = null+ })+ )+ }const graph = ctx.graphconst moves = fresh? [...unrecorded].flatMap(([id, before]) => {@@ -168,6 +192,29 @@ export function createConnectorRouting(ctx: EditorContext) {})}+ /**+ * Whether the pass follows an edit that recorded a new undo step, which a dragged elbow's route+ * joins as its new control points, as FigJam keeps them after an edit. Undo, redo, previews,+ * and changes that record no step leave the control points as they are.+ */+ function capturesEdit(batch: NonNullable<typeof pending>): boolean {+ if (!batch.committed || batch.replayed || ctx.undo.isReplaying) return false+ return ctx.undo.isBatching || (freshStep !== null && ctx.undo.peekUndo() === freshStep)+ }++ /** Records the control points edits gave dragged elbows into the step that made the edits. */+ function recordCaptured(captured: { id: string; before: Captured; after: Captured }[]) {+ if (captured.length === 0) return+ const apply = (state: 'before' | 'after') => {+ for (const change of captured) ctx.graph.updateNode(change.id, structuredClone(change[state]))+ }+ ctx.undo.extendLastStep({+ label: 'Route connector',+ forward: () => apply('after'),+ inverse: () => apply('before')+ })+ }+function flush() {const batch = pendingpending = null@@ -175,6 +222,8 @@ export function createConnectorRouting(ctx: EditorContext) {const graph = ctx.graphconst affected = connectorsAffectedBy(graph, batch.ids)if (affected.length === 0) return+ const capture = capturesEdit(batch)+ const captured: { id: string; before: Captured; after: Captured }[] = []routing = truetry {const update = batch.committed@@ -186,12 +235,19 @@ export function createConnectorRouting(ctx: EditorContext) {const keepBox = !batch.committedlet moved = falsefor (const connector of affected) {- moved = layoutConnector(graph, connector, update, { keepBox }) || moved+ const before = structuredClone(pick(connector, CAPTURED_FIELDS))+ moved = layoutConnector(graph, connector, update, { keepBox, capture }) || moved+ if (!capture || connector.connectorControlPoints.length === 0) continue+ const after = structuredClone(pick(connector, CAPTURED_FIELDS))+ if (!isEqual(before.connectorControlPoints, after.connectorControlPoints)) {+ captured.push({ id: connector.id, before, after })+ }}if (moved) ctx.requestRender()} finally {routing = false}+ recordCaptured(captured)}// A document read without layout, as a `.fig` is, routes such connectors when shown.diff --git a/packages/core/src/editor/create.ts b/packages/core/src/editor/create.tsindex b28935326..c5d534b4d 100644--- a/packages/core/src/editor/create.ts+++ b/packages/core/src/editor/create.ts@@ -36,6 +36,7 @@ import { createColorSpaceActions } from './color-space'import { createComponentSyncScheduler } from './component-sync'import { createComponentActions } from './components'import { createConnectorDrawActions, createConnectorEndpointActions } from './connectors/draw'+import { createConnectorLineActions } from './connectors/line'import { createConnectorRouting } from './connectors/routing'import { createConnectorStyleActions } from './connectors/style'import { createDesignTokenActions } from './design-tokens'@@ -314,6 +315,7 @@ export function createEditor(options?: EditorOptions) {nodes.beginNodePreview,clipboard.deleteNodes)+ const connectorLines = createConnectorLineActions(ctx, nodes.beginNodePreview)const connectorStyles = createConnectorStyleActions(ctx)const lineEnds = createLineEndActions(ctx, nodes.beginNodePreview)const shaders = createShaderActions(ctx, nodes)@@ -491,6 +493,7 @@ export function createEditor(options?: EditorOptions) {setStatusWorkflow: statuses.setStatusWorkflow,...connectorDrawing,...connectorEndpoints,+ ...connectorLines,...lineEnds,...connectorStyles,...shaders,diff --git a/packages/core/src/editor/text.ts b/packages/core/src/editor/text.tsindex 7573b7b4a..1debbbe9b 100644--- a/packages/core/src/editor/text.ts+++ b/packages/core/src/editor/text.ts@@ -12,6 +12,7 @@ import type { TextEditorState } from '#core/text/editor'import { hasGlyphOutlines } from '#core/text/opentype'import { applyBoundTextEdit } from './components/authoring/text-edit'+import { fitEmptyLabelToPlaceholder } from './connectors/label-edit'import { applyGeneratedTextNameEdit } from './text/name'import { pathTextEditChanges } from './text/path-edit'import {@@ -107,6 +108,8 @@ function applyTextInstanceOverride(export function createTextActions(ctx: EditorContext) {let activeSession: TextEditSession | null = null+ /** Puts back the size an empty connector label had before its placeholder sized it. */+ let restoreEmptyLabel: (() => void) | null = nullconst variableBindings = createVariableBindingActions(ctx)/**@@ -136,6 +139,7 @@ export function createTextActions(ctx: EditorContext) {if (!isPathTextEditable(node)) returnactiveSession = createTextEditSession(node)ctx.state.editingTextId = nodeId+ restoreEmptyLabel = fitEmptyLabelToPlaceholder(ctx, node)if (te) {te.setRenderer(ctx.getRenderer())te.start(node)@@ -219,9 +223,12 @@ export function createTextActions(ctx: EditorContext) {function commitTextEdit() {const te = ctx.getTextEditor()+ const restore = restoreEmptyLabel+ restoreEmptyLabel = nullif (!te?.isActive) {ctx.state.editingTextId = nullactiveSession = null+ restore?.()return}const textState = te.state@@ -229,6 +236,7 @@ export function createTextActions(ctx: EditorContext) {te.stop()ctx.state.editingTextId = nullactiveSession = null+ restore?.()ctx.requestRender()}diff --git a/packages/core/src/geometry/connectors.ts b/packages/core/src/geometry/connectors.tsindex 45e4f538a..f965978ef 100644--- a/packages/core/src/geometry/connectors.ts+++ b/packages/core/src/geometry/connectors.ts@@ -1,7 +1,12 @@import type { SceneGraph, SceneNode } from '@open-pencil/scene-graph'-import { connectorLineEnds } from '@open-pencil/scene-graph/connectors'+import {+ connectorLineEnds,+ connectorRoute,+ connectorSublayers,+ curveMidpoint+} from '@open-pencil/scene-graph/connectors'import Matrix from '@open-pencil/scene-graph/matrix'-import type { Vector } from '@open-pencil/scene-graph/primitives'+import type { Rect, Vector } from '@open-pencil/scene-graph/primitives'import { createSceneGeometry } from './scene'import type { RotationPreview, ViewportTransform } from './types'@@ -22,3 +27,76 @@ export function connectorScreenEnds()return { start: { x: sx, y: sy }, end: { x: ex, y: ey } }}++/** An elbow segment's handle, in screen pixels: a bar along the segment. */+export const CONNECTOR_SEGMENT_HANDLE = { length: 20, thickness: 6 }++/** A handle that drags part of a selected connector's line, on screen. */+export type ConnectorRouteHandle =+ /** An elbow segment's handle, at its middle, dragged across it. */+ | { kind: 'segment'; index: number; at: Vector; vertical: boolean; length: number }+ /** A curve's handle, at its middle, dragged anywhere. */+ | { kind: 'curve'; at: Vector }++/**+ * The handles a selected connector's line is dragged by, as FigJam shows them: one on each+ * segment of an elbow, and one midway along a curve. A straight connector has none.+ */+export function connectorRouteHandles(+ graph: SceneGraph,+ connector: SceneNode,+ viewport: ViewportTransform,+ preview?: RotationPreview | null+): ConnectorRouteHandle[] {+ const { connectorLineType: lineType } = connector+ if (lineType === 'STRAIGHT') return []+ const route = connectorRoute(graph, connector)+ if (!route) return []+ // The route runs in the connector's parent's axes; the connector only moves it.+ const toScreen = Matrix.multiply(+ createSceneGeometry(graph, preview).screenMatrix(connector, viewport),+ Matrix.translated(-connector.x, -connector.y)+ )+ const screen = (point: Vector) => Matrix.mapPoint(toScreen, point)+ if (lineType === 'CURVED') {+ const curve = route.pieces.at(0)+ return curve ? [{ kind: 'curve', at: screen(curveMidpoint(curve)) }] : []+ }+ return route.pieces.flatMap((piece, index) => {+ const from = screen(piece.from)+ const to = screen(piece.to)+ const length = Math.hypot(to.x - from.x, to.y - from.y)+ if (length === 0) return []+ return [+ {+ kind: 'segment' as const,+ index,+ at: { x: (from.x + to.x) / 2, y: (from.y + to.y) / 2 },+ vertical: Math.abs(to.x - from.x) < Math.abs(to.y - from.y),+ length+ }+ ]+ })+}++/** Where a connector's label plate is on screen, while it has a label to drag. */+export function connectorScreenLabel(+ graph: SceneGraph,+ connector: SceneNode,+ viewport: ViewportTransform,+ preview?: RotationPreview | null+): Rect | null {+ const parts = connectorSublayers(graph, connector)+ if (!parts || parts.label.text === '' || !parts.labelBackground.visible) return null+ const plate = parts.labelBackground+ const [x0, y0, x1, y1] = Matrix.mapPoints(+ createSceneGeometry(graph, preview).screenMatrix(plate, viewport),+ [0, 0, plate.width, plate.height]+ )+ return {+ x: Math.min(x0, x1),+ y: Math.min(y0, y1),+ width: Math.abs(x1 - x0),+ height: Math.abs(y1 - y0)+ }+}diff --git a/packages/core/src/geometry/index.ts b/packages/core/src/geometry/index.tsindex c384abc26..283676735 100644--- a/packages/core/src/geometry/index.ts+++ b/packages/core/src/geometry/index.ts@@ -40,7 +40,13 @@ export type {GradientHit,GradientStopLayout} from './gradient'-export { connectorScreenEnds } from './connectors'+export {+ CONNECTOR_SEGMENT_HANDLE,+ connectorRouteHandles,+ connectorScreenEnds,+ connectorScreenLabel,+ type ConnectorRouteHandle+} from './connectors'export {aimLine,draggedLineEnds,diff --git a/packages/core/tests/canvas/text/sticky-placeholder.test.ts b/packages/core/tests/canvas/text/placeholder.test.tssimilarity index 52%rename from packages/core/tests/canvas/text/sticky-placeholder.test.tsrename to packages/core/tests/canvas/text/placeholder.test.tsindex ebdf48371..b41bc75b5 100644--- a/packages/core/tests/canvas/text/sticky-placeholder.test.ts+++ b/packages/core/tests/canvas/text/placeholder.test.ts@@ -3,9 +3,10 @@ import { describe, expect, test } from 'bun:test'import { expectDefined } from '#core-tests/helpers/assert'import { SceneGraph } from '@open-pencil/scene-graph'+import { createConnector, connectorSublayers, freeEndpoint } from '@open-pencil/scene-graph/connectors'import { createSticky, stickySublayers } from '@open-pencil/scene-graph/generated'-import { stickyPlaceholderNode } from '#core/canvas/text/sticky-placeholder'+import { connectorLabelPlaceholderNode, stickyPlaceholderNode } from '#core/canvas/text/placeholder'function emptyNote() {const graph = new SceneGraph()@@ -36,3 +37,30 @@ describe('sticky note placeholder', () => {).toBeNull()})})++describe('connector label placeholder', () => {+ function emptyLabel() {+ const graph = new SceneGraph()+ const connector = createConnector(graph, graph.getPages()[0].id, {+ start: freeEndpoint(0, 0),+ end: freeEndpoint(200, 0)+ })+ return { graph, ...expectDefined(connectorSublayers(graph, connector)) }+ }++ test('an empty label shows it only while it is typed into, at 30% black', () => {+ const { graph, label } = emptyLabel()+ const drawn = expectDefined(connectorLabelPlaceholderNode(graph, label, 'Add text', label.id))+ expect(drawn.text).toBe('Add text')+ expect(drawn.fills[0]).toMatchObject({ opacity: 0.3, color: { r: 0, g: 0, b: 0 } })+ expect(connectorLabelPlaceholderNode(graph, label, 'Add text', null)).toBeNull()+ })++ test('a label with text, or other text being edited, shows none', () => {+ const { graph, label, line } = emptyLabel()+ expect(connectorLabelPlaceholderNode(graph, line, 'Add text', line.id)).toBeNull()+ graph.updateNode(label.id, { text: 'Next' })+ const typed = expectDefined(graph.getNode(label.id))+ expect(connectorLabelPlaceholderNode(graph, typed, 'Add text', label.id)).toBeNull()+ })+})diff --git a/packages/core/tests/clipboard/figma/connectors.test.ts b/packages/core/tests/clipboard/figma/connectors.test.tsindex df00f358e..d8dc80482 100644--- a/packages/core/tests/clipboard/figma/connectors.test.ts+++ b/packages/core/tests/clipboard/figma/connectors.test.ts@@ -1,6 +1,8 @@import { beforeAll, describe, expect, test } from 'bun:test'import { join } from 'node:path'+import * as v from 'valibot'+import { expectDefined } from '#core-tests/helpers/assert'import { FIXTURES } from '#core-tests/helpers/paths'@@ -8,7 +10,13 @@ import { buildFigmaClipboardHTML, importClipboardNodes } from '@open-pencil/coreimport { parseFigmaClipboard } from '@open-pencil/fig/clipboard'import { initCodec } from '@open-pencil/kiwi/fig/codec'import { SceneGraph, type SceneNode } from '@open-pencil/scene-graph'-import { connectorSublayers, layoutConnector } from '@open-pencil/scene-graph/connectors'+import {+ boundEndpoint,+ connectorSublayers,+ createConnector,+ freeEndpoint,+ layoutConnector+} from '@open-pencil/scene-graph/connectors'import type { Vector } from '@open-pencil/scene-graph/primitives'/** Two FigJam stickies joined by four connectors, as FigJam copies them. */@@ -129,6 +137,119 @@ describe('FigJam connectors', () => {})})+/** A curve's control points as a `.fig` record keeps them. */+const HANDLES = v.optional(+ v.array(v.object({ position: v.object({ x: v.number(), y: v.number() }) }))+)++test('a connector copied before a layer it joins keeps both ends joined', async () => {+ const graph = new SceneGraph()+ const page = graph.getPages()[0].id+ const target = graph.createNode('RECTANGLE', page, { name: 'Target', x: 400, width: 100, height: 100 })+ const connector = createConnector(graph, page, {+ start: freeEndpoint(0, 0),+ end: freeEndpoint(0, 0)+ })+ const before = graph.createNode('RECTANGLE', page, { name: 'Before', width: 100, height: 100 })+ graph.updateNode(connector.id, {+ name: 'Joined',+ connectorStart: boundEndpoint(before.id),+ connectorEnd: boundEndpoint(target.id)+ })+ // The connector is written before Before, whose GUID it then has no record of yet.+ const nodes = [target, connector, before].map((node) => expectDefined(graph.getNode(node.id)))+ const parsed = expectDefined(+ await parseFigmaClipboard(expectDefined(await buildFigmaClipboardHTML(nodes, graph)))+ )+ const guidOf = (name: string) => parsed.nodes.find((node) => node.name === name)?.guid+ const record = expectDefined(parsed.nodes.find((node) => node.name === 'Joined'))+ expect(record.connectorStart).toMatchObject({ endpointNodeID: guidOf('Before'), magnet: 'AUTO' })+ expect(record.connectorEnd).toMatchObject({ endpointNodeID: guidOf('Target'), magnet: 'AUTO' })+})++/**+ * A FigJam section holding two shapes, an elbow dragged at its middle and then its first segment,+ * and a curve dragged at its midpoint, as FigJam copies them.+ */+const DRAGGED = join(FIXTURES, 'clipboard/figjam-connector-controls.html')++describe('FigJam connectors dragged into place', () => {+ test('keep their control points and route again as Figma drew them', async () => {+ const { graph } = await importFixture(await Bun.file(DRAGGED).text())+ // They sit inside the section the copy holds.+ const named = (name: string) =>+ expectDefined([...graph.getAllNodes()].find((node) => node.name === name))+ const elbow = named('cp-elbow')+ const curve = named('cp-curve')+ // Figma keeps them in the section's axes; here they are in the connector's own.+ expect(+ elbow.connectorControlPoints.map(({ position, direction }) => [+ direction,+ position.x + elbow.x,+ position.y + elbow.y+ ])+ ).toEqual([+ ['VERTICAL', 304, 80],+ ['HORIZONTAL', 376, 48],+ ['VERTICAL', 448, 240]+ ])+ expect(curve.connectorCurveHandles).not.toBeNull()+ for (const connector of [elbow, curve]) {+ const figma = pageRoute(graph, connector)+ layoutConnector(graph, connector)+ expect({ name: connector.name, route: pageRoute(graph, connector) }).toEqual({+ name: connector.name,+ route: figma+ })+ }+ })++ test('export writes their control points where Figma wrote them', async () => {+ const html = await Bun.file(DRAGGED).text()+ const source = expectDefined(await parseFigmaClipboard(html))+ const { graph, ids } = await importFixture(html)+ // A label dragged along the line keeps its place.+ const elbow = expectDefined(+ [...graph.getAllNodes()].find((node) => node.name === 'cp-elbow')+ )+ graph.updateNode(elbow.id, {+ connectorLabelPosition: { section: 'MIDDLE_TO_END', offset: 0.5, offAxis: 'ABOVE' }+ })+ const exported = expectDefined(+ await parseFigmaClipboard(+ expectDefined(+ await buildFigmaClipboardHTML(+ ids.map((id) => expectDefined(graph.getNode(id))),+ graph+ )+ )+ )+ )+ for (const name of ['cp-elbow', 'cp-curve']) {+ const before = expectDefined(source.nodes.find((node) => node.name === name))+ const after = expectDefined(exported.nodes.find((node) => node.name === name))+ expect({ name, points: after.connectorControlPoints }).toEqual({+ name,+ points: before.connectorControlPoints+ })+ const handles = (node: typeof before) =>+ v+ .parse(HANDLES, node.connectorBezierControlPoints)+ ?.map(({ position }) => [+ Math.round(position.x * 100) / 100,+ Math.round(position.y * 100) / 100+ ])+ expect({ name, handles: handles(after) }).toEqual({ name, handles: handles(before) })+ }+ const reread = expectDefined(exported.nodes.find((node) => node.name === 'cp-elbow'))+ expect(reread.connectorTextMidpoint).toEqual({+ section: 'MIDDLE_TO_END',+ offset: 0.5,+ offAxisOffset: 'ABOVE'+ })+ })+})+/** A connector's line as rounded page points, segment by segment. */function pageRoute(graph: SceneGraph, connector: SceneNode) {const line = expectDefined(connectorSublayers(graph, connector)).linediff --git a/packages/core/tests/editor/connectors/line.test.ts b/packages/core/tests/editor/connectors/line.test.tsnew file mode 100644index 000000000..e05af4306--- /dev/null+++ b/packages/core/tests/editor/connectors/line.test.ts@@ -0,0 +1,237 @@+import { describe, expect, test } from 'bun:test'++import { expectDefined } from '#core-tests/helpers/assert'++import { createEditor } from '@open-pencil/core'+import type { SceneNode } from '@open-pencil/scene-graph'+import {+ boundEndpoint,+ buildConnectorSublayers,+ connectorSublayers,+ layoutConnector+} from '@open-pencil/scene-graph/connectors'++type Editor = ReturnType<typeof createEditor>++/**+ * Two 160 px boxes, the second below and to the right, joined by a connector from the first's+ * right side to the second's left, as the drags were measured in FigJam.+ */+function setup(lineType: SceneNode['connectorLineType'] = 'ELBOWED') {+ const editor = createEditor()+ const page = editor.state.currentPageId+ const graph = editor.graph+ const from = graph.createNode('RECTANGLE', page, { x: 0, y: 0, width: 160, height: 160 })+ const to = graph.createNode('RECTANGLE', page, { x: 480, y: 320, width: 160, height: 160 })+ const connector = graph.createNode('CONNECTOR', page, {+ connectorStart: boundEndpoint(from.id),+ connectorEnd: boundEndpoint(to.id),+ connectorLineType: lineType+ })+ buildConnectorSublayers(graph, connector)+ layoutConnector(graph, connector)+ return { editor, from, to, connector }+}++const settle = () => Promise.resolve()++/** The line's points in page coordinates. */+function route(editor: Editor, connector: SceneNode): number[][] {+ const node = expectDefined(editor.graph.getNode(connector.id))+ const { line } = expectDefined(connectorSublayers(editor.graph, node))+ return (line.vectorNetwork?.vertices ?? []).map((vertex) => [+ Math.round((node.x + line.x + vertex.x) * 100) / 100,+ Math.round((node.y + line.y + vertex.y) * 100) / 100+ ])+}++/** The connector's control points in page coordinates. */+function controls(editor: Editor, connector: SceneNode) {+ const node = expectDefined(editor.graph.getNode(connector.id))+ return node.connectorControlPoints.map(({ position, direction }) => [+ direction,+ position.x + node.x,+ position.y + node.y+ ])+}++async function drag(+ editor: Editor,+ connector: SceneNode,+ part: Parameters<Editor['connectorLineBegin']>[1],+ from: [number, number],+ to: [number, number]+) {+ editor.connectorLineBegin(connector.id, part, ...from)+ editor.connectorLineDrag(...to)+ await settle()+ editor.connectorLineCommit()+ await settle()+}++describe('dragging a connector segment', () => {+ test('moves a middle segment across, and undo puts it back', async () => {+ const { editor, connector } = setup()+ try {+ const before = route(editor, connector)+ await drag(editor, connector, { kind: 'segment', index: 1 }, [320, 240], [352.4, 250])+ expect(controls(editor, connector)).toEqual([['VERTICAL', 352, 240]])+ expect(route(editor, connector)).toEqual([+ [166, 80],+ [352, 80],+ [352, 400],+ [473.5, 400]+ ])+ editor.undoAction()+ await settle()+ expect(controls(editor, connector)).toEqual([])+ expect(route(editor, connector)).toEqual(before)+ } finally {+ editor.dispose()+ }+ })++ test('splits a first segment a stub out of its layer, as FigJam does', async () => {+ const { editor, connector } = setup()+ try {+ await drag(editor, connector, { kind: 'segment', index: 0 }, [240, 80], [240, 16])+ expect(controls(editor, connector)).toEqual([+ ['VERTICAL', 208, 48],+ ['HORIZONTAL', 264, 16],+ ['VERTICAL', 320, 208]+ ])+ expect(route(editor, connector)).toEqual([+ [166, 80],+ [208, 80],+ [208, 16],+ [320, 16],+ [320, 400],+ [473.5, 400]+ ])+ } finally {+ editor.dispose()+ }+ })++ test('keeps the route an edit gives it, and undo of the edit gives the old one back', async () => {+ const { editor, to, connector } = setup()+ try {+ await drag(editor, connector, { kind: 'segment', index: 1 }, [320, 240], [352, 240])+ editor.updateNodeWithUndo(to.id, { y: 400 }, 'Move')+ await settle()+ // The segment across to the moved layer's top is now kept too.+ expect(controls(editor, connector)).toEqual([+ ['VERTICAL', 352, 216],+ ['HORIZONTAL', 456, 352]+ ])+ editor.undoAction()+ await settle()+ expect(controls(editor, connector)).toEqual([['VERTICAL', 352, 240]])+ expect(route(editor, connector)).toEqual([+ [166, 80],+ [352, 80],+ [352, 400],+ [473.5, 400]+ ])+ editor.redoAction()+ await settle()+ expect(controls(editor, connector)).toEqual([+ ['VERTICAL', 352, 216],+ ['HORIZONTAL', 456, 352]+ ])+ } finally {+ editor.dispose()+ }+ })++ test('a connector never dragged keeps routing itself', async () => {+ const { editor, to, connector } = setup()+ try {+ editor.updateNodeWithUndo(to.id, { y: 400 }, 'Move')+ await settle()+ expect(controls(editor, connector)).toEqual([])+ } finally {+ editor.dispose()+ }+ })++ test('moves with the connector and the layers it joins', async () => {+ const { editor, from, to, connector } = setup()+ try {+ await drag(editor, connector, { kind: 'segment', index: 1 }, [320, 240], [352, 240])+ const node = expectDefined(editor.graph.getNode(connector.id))+ editor.updateNodeWithUndo(from.id, { x: 96, y: 48 }, 'Move')+ editor.updateNodeWithUndo(to.id, { x: 576, y: 368 }, 'Move')+ editor.updateNodeWithUndo(connector.id, { x: node.x + 96, y: node.y + 48 }, 'Move')+ await settle()+ expect(route(editor, connector)).toEqual([+ [262, 128],+ [448, 128],+ [448, 448],+ [569.5, 448]+ ])+ } finally {+ editor.dispose()+ }+ })+})++describe('dragging a curved connector', () => {+ test('moves both control points by 4/3 of the drag, and undo straightens it back', async () => {+ const { editor, connector } = setup('CURVED')+ try {+ const before = route(editor, connector)+ await drag(editor, connector, { kind: 'curve' }, [320, 240], [400, 160])+ const node = expectDefined(editor.graph.getNode(connector.id))+ const handles = expectDefined(node.connectorCurveHandles).map(({ x, y }) => [+ Math.round((x + node.x) * 100) / 100,+ Math.round((y + node.y) * 100) / 100+ ])+ expect(handles).toEqual([+ [459.76, -26.67],+ [393.58, 293.33]+ ])+ editor.undoAction()+ await settle()+ expect(editor.graph.getNode(connector.id)?.connectorCurveHandles).toBeNull()+ expect(route(editor, connector)).toEqual(before)+ } finally {+ editor.dispose()+ }+ })+})++describe('dragging a connector label', () => {+ test('slides it along the line or off to one side, and undo puts it back', async () => {+ const editor = createEditor()+ try {+ const page = editor.state.currentPageId+ const graph = editor.graph+ const from = graph.createNode('RECTANGLE', page, { x: 0, y: 0, width: 160, height: 160 })+ const to = graph.createNode('RECTANGLE', page, { x: 480, y: 0, width: 160, height: 160 })+ const connector = graph.createNode('CONNECTOR', page, {+ connectorStart: boundEndpoint(from.id),+ connectorEnd: boundEndpoint(to.id)+ })+ buildConnectorSublayers(graph, connector, { label: { text: 'detour', width: 50, height: 24 } })+ layoutConnector(graph, connector)+ await drag(editor, connector, { kind: 'label' }, [320, 80], [420, 80])+ const position = () => editor.graph.getNode(connector.id)?.connectorLabelPosition+ expect(position()).toMatchObject({ section: 'MIDDLE_TO_END', offAxis: 'NONE' })+ expect(position()?.offset).toBeCloseTo(100 / 153.75, 3)+ await drag(editor, connector, { kind: 'label' }, [420, 80], [420, 140])+ expect(position()?.offAxis).toBe('BELOW')+ // Beside the line, the line runs on uncut.+ expect(route(editor, connector)).toEqual([+ [166, 80],+ [473.5, 80]+ ])+ editor.undoAction()+ editor.undoAction()+ await settle()+ expect(position()).toBeNull()+ } finally {+ editor.dispose()+ }+ })+})diff --git a/packages/fig/src/node-change/generated/connector.ts b/packages/fig/src/node-change/generated/connector.tsindex 391dfe98e..43d06ec0c 100644--- a/packages/fig/src/node-change/generated/connector.ts+++ b/packages/fig/src/node-change/generated/connector.ts@@ -4,7 +4,9 @@ import type { GUID } from '@open-pencil/kiwi/fig'import type { NodeChange } from '@open-pencil/kiwi/fig/codec'import { guidToString, isUnsetGuid, UNSET_GUID } from '@open-pencil/kiwi/fig/guid'import type {+ ConnectorControlPoint,ConnectorEndpoint,+ ConnectorLabelPosition,ConnectorLineType,ConnectorMagnet,SceneGraph,@@ -52,6 +54,69 @@ const CONNECTOR_RECORD_FIELDS = ['pluginRelaunchData'] as const+interface KiwiControlPoint {+ position?: Vector+ axis?: Vector+}++/**+ * A record's control points, in its parent's axes, as points in the connector's own: an elbow's+ * segments along their axes, or a curve's two control points.+ */+function controlPointsOf(value: unknown, origin: Vector): ConnectorControlPoint[] {+ if (!Array.isArray(value)) return []+ return (value as KiwiControlPoint[]).map(({ position, axis }) => ({+ position: { x: (position?.x ?? 0) - origin.x, y: (position?.y ?? 0) - origin.y },+ direction: axis?.x ? 'HORIZONTAL' : 'VERTICAL'+ }))+}++function curveHandlesOf(value: unknown, origin: Vector): [Vector, Vector] | null {+ const points = controlPointsOf(value, origin)+ const first = points.at(0)+ const second = points.at(1)+ return first && second ? [first.position, second.position] : null+}++/** Control points as Figma writes them, in the connector's parent's axes. */+function kiwiControlPoints(points: ConnectorControlPoint[], origin: Vector) {+ return points.map(({ position, direction }) => ({+ position: { x: position.x + origin.x, y: position.y + origin.y },+ axis: direction === 'HORIZONTAL' ? { x: 1, y: 0 } : { x: 0, y: 1 }+ }))+}++const LABEL_SECTIONS: ReadonlySet<string> = new Set<ConnectorLabelPosition['section']>([+ 'MIDDLE_TO_START',+ 'MIDDLE_TO_END'+])+const LABEL_OFF_AXES: ReadonlySet<string> = new Set<ConnectorLabelPosition['offAxis']>([+ 'NONE',+ 'ABOVE',+ 'BELOW'+])++interface KiwiTextMidpoint {+ section?: string+ offset?: number+ offAxisOffset?: string+}++/** Where a record's label was dragged to, from Figma's `connectorTextMidpoint`. */+function labelPositionOf(value: unknown): ConnectorLabelPosition | null {+ if (!value || typeof value !== 'object') return null+ const { section, offset, offAxisOffset } = value as KiwiTextMidpoint+ if (!section || !LABEL_SECTIONS.has(section) || typeof offset !== 'number') return null+ return {+ section: section as ConnectorLabelPosition['section'],+ offset,+ offAxis:+ offAxisOffset && LABEL_OFF_AXES.has(offAxisOffset)+ ? (offAxisOffset as ConnectorLabelPosition['offAxis'])+ : 'NONE'+ }+}+interface KiwiConnectorEndpoint {endpointNodeID?: GUIDposition?: Vector@@ -179,7 +244,10 @@ function readConnector(? (lineType as ConnectorLineType): 'ELBOWED',connectorStartCap: capOf(record.connectorStartCap, 'ROUND'),- connectorEndCap: capOf(record.connectorEndCap, 'ARROW_LINES')+ connectorEndCap: capOf(record.connectorEndCap, 'ARROW_LINES'),+ connectorControlPoints: controlPointsOf(record.connectorControlPoints, connector),+ connectorCurveHandles: curveHandlesOf(record.connectorBezierControlPoints, connector),+ connectorLabelPosition: labelPositionOf(record.connectorTextMidpoint)})const text = overrides.get(label)?.textData?.characters ?? ''const plate = sublayerProps(@@ -226,6 +294,39 @@ function kiwiConnectorEndpoint(}}+/**+ * Joins the ends of the connectors in `records` to the layers they are bound to, once every layer+ * an export writes has its GUID. A connector written before a layer its end joins found no GUID+ * for that layer and was written free; when the layer turns out to be written too, the end joins+ * it again, as Figma pastes it.+ */+export function relinkConnectorEnds(+ records: readonly KiwiNodeChange[],+ graph: SceneGraph,+ nodeIdToGuid: ReadonlyMap<string, GUID>+): void {+ const recordByGuid = new Map(+ records.flatMap((record) => (record.guid ? [[guidToString(record.guid), record] as const] : []))+ )+ for (const [nodeId, guid] of nodeIdToGuid) {+ const node = graph.getNode(nodeId)+ const record = recordByGuid.get(guidToString(guid))+ if (node?.type !== 'CONNECTOR' || record?.type !== 'CONNECTOR') continue+ for (const [field, endpoint] of [+ ['connectorStart', node.connectorStart],+ ['connectorEnd', node.connectorEnd]+ ] as const) {+ const joined = endpoint?.nodeId ? nodeIdToGuid.get(endpoint.nodeId) : undefined+ if (!endpoint || !joined || !recordByGuid.has(guidToString(joined))) continue+ record[field] = {+ endpointNodeID: { ...joined },+ position: { ...endpoint.position },+ magnet: endpoint.magnet+ }+ }+ }+}+/*** 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@@ -246,6 +347,20 @@ function writeConnector(record.connectorLineStyle = node.connectorLineTyperecord.connectorStartCap = node.connectorStartCaprecord.connectorEndCap = node.connectorEndCap+ if (node.connectorControlPoints.length > 0) {+ record.connectorControlPoints = kiwiControlPoints(node.connectorControlPoints, node)+ }+ if (node.connectorCurveHandles) {+ // Figma gives a curve's control points a horizontal axis, which nothing reads.+ record.connectorBezierControlPoints = kiwiControlPoints(+ node.connectorCurveHandles.map((position) => ({ position, direction: 'HORIZONTAL' })),+ node+ )+ }+ if (node.connectorLabelPosition) {+ const { section, offset, offAxis } = node.connectorLabelPosition+ record.connectorTextMidpoint = { section, offset, offAxisOffset: offAxis }+ }record.connectorType = 'MANUAL'record.connectorVersion = 1const { line, label, labelBackground } = sublayersdiff --git a/packages/fig/src/node-change/generated/shape-with-text.ts b/packages/fig/src/node-change/generated/shape-with-text.tsindex 4224311bc..e9fd69984 100644--- a/packages/fig/src/node-change/generated/shape-with-text.ts+++ b/packages/fig/src/node-change/generated/shape-with-text.ts@@ -77,6 +77,8 @@ function backgroundProps(return pick(props, ['fills','strokes',+ 'strokeWeight',+ 'strokeAlign','strokeCap','strokeJoin','dashPattern',diff --git a/packages/fig/src/node-change/index.ts b/packages/fig/src/node-change/index.tsindex f84d2aa07..e152452ec 100644--- a/packages/fig/src/node-change/index.ts+++ b/packages/fig/src/node-change/index.ts@@ -5,6 +5,7 @@ export * from './derived-text/build'export * from './derived-text/data'export * from './derived-text/glyphs'export { parseGuidOrNull } from './export/context'+export { relinkConnectorEnds } from './generated/connector'export * from './export/node'export * from './export/runtime'export { placeSlotContent } from './export/slots'diff --git a/packages/fig/tests/node-change/generated/shape-with-text.test.ts b/packages/fig/tests/node-change/generated/shape-with-text.test.tsindex 2f30f6f29..259744ba0 100644--- a/packages/fig/tests/node-change/generated/shape-with-text.test.ts+++ b/packages/fig/tests/node-change/generated/shape-with-text.test.ts@@ -86,6 +86,8 @@ describe('shapes with text', () => {})expect(shape.fills[0]?.color).toEqual(green)expect(shape.strokes[0]).toMatchObject({ color: darkGreen, weight: 4 })+ // Connectors keep clear of the stroke by its weight.+ expect(shape).toMatchObject({ strokeWeight: 4, strokeAlign: 'CENTER' })const label = expectDefined(shapeWithTextLabel(graph, shape))expect(label).toMatchObject({text: 'Decision',diff --git a/packages/scene-graph/src/connectors/controls.ts b/packages/scene-graph/src/connectors/controls.tsnew file mode 100644index 000000000..35cb371cd--- /dev/null+++ b/packages/scene-graph/src/connectors/controls.ts@@ -0,0 +1,229 @@+import type { Vector } from '../primitives'+import type { ConnectorControlPoint } from '../types'+import { ELBOW_STUB, simplify } from './elbow'+import { along, EPSILON, pointAt, straightPieces, type ConnectorPiece } from './pieces'+import { attachment, OUTWARD, type ConnectorRouteEnd, type ConnectorSide } from './sides'++/**+ * Elbows and curves dragged into place, as FigJam keeps them+ * (`packages/scene-graph/tests/connectors/figma-control-routes.json`): an elbow runs along each+ * dragged segment's line in turn, and a curve takes its two control points as they were left.+ */++type Direction = ConnectorControlPoint['direction']++/** A route end's side, with the line it leaves or arrives along and where it attaches. */+interface RouteSide {+ at: Vector+ direction: Direction+ /** Where a segment joining a parallel control line runs: a stub's length out of the layer. */+ joint: Vector+}++function directionOf(side: ConnectorSide): Direction {+ return side === 'LEFT' || side === 'RIGHT' ? 'HORIZONTAL' : 'VERTICAL'+}++function routeSide(end: ConnectorRouteEnd, side: ConnectorSide): RouteSide {+ const at = attachment(end, side)+ return {+ at,+ direction: directionOf(side),+ joint: end.box ? along(at, OUTWARD[side], ELBOW_STUB) : at+ }+}++/** The coordinate a control line fixes: x for a vertical segment, y for a horizontal one. */+function lineOf(point: ConnectorControlPoint): number {+ return point.direction === 'VERTICAL' ? point.position.x : point.position.y+}++/** Where a run along `direction` through `from` meets the perpendicular line `to`. */+function meet(from: Vector, direction: Direction, to: number): Vector {+ return direction === 'HORIZONTAL' ? { x: to, y: from.y } : { x: from.x, y: to }+}++/**+ * Moves an end along its segment by its gap, towards the next point, unless the segment is no+ * longer than the gap.+ */+function inset(point: Vector, toward: Vector, gap: number): Vector {+ const length = Math.hypot(toward.x - point.x, toward.y - point.y)+ return length <= gap ? point : towards(point, toward, gap)+}++/**+ * An elbow through its control lines: from the start's side to each line in turn, then to the end's+ * side. A line parallel to the run before it is reached by a segment across, at the stub of the+ * end it follows or leads to, or midway between two control lines. Points in line merge, so ends+ * that face each other in line draw straight. Each end then stops short by its gap along its own+ * segment, which may point back into its layer.+ */+export function controlledElbowRoute(+ start: ConnectorRouteEnd,+ end: ConnectorRouteEnd,+ [startSide, endSide]: [ConnectorSide, ConnectorSide],+ [startGap, endGap]: [number, number],+ controls: ConnectorControlPoint[]+): ConnectorPiece[] {+ const from = routeSide(start, startSide)+ const to = routeSide(end, endSide)+ const points: Vector[] = [from.at]+ let at = from.at+ let direction = from.direction+ let joint = from.joint+ const turnOnto = (line: number, lineDirection: Direction) => {+ if (lineDirection === direction) {+ // A parallel line is reached by a segment across it.+ const across = meet(at, direction, direction === 'HORIZONTAL' ? joint.x : joint.y)+ points.push(across)+ at = across+ direction = direction === 'HORIZONTAL' ? 'VERTICAL' : 'HORIZONTAL'+ }+ at = meet(at, direction, line)+ points.push(at)+ direction = lineDirection+ }+ controls.forEach((control, index) => {+ const next = controls.at(index + 1)+ turnOnto(lineOf(control), control.direction)+ // Between two parallel control lines, the segment across runs midway.+ joint =+ next && next.direction === control.direction+ ? {+ x: (control.position.x + next.position.x) / 2,+ y: (control.position.y + next.position.y) / 2+ }+ : to.joint+ })+ // The end's own line, which its last segment arrives along.+ turnOnto(to.direction === 'HORIZONTAL' ? to.at.y : to.at.x, to.direction)+ points.push(to.at)+ const route = simplify(points)+ if (route.length < 2) return straightPieces([from.at, from.at])+ route[0] = inset(route[0], route[1], startGap)+ route[route.length - 1] = inset(route.at(-1) ?? to.at, route.at(-2) ?? from.at, endGap)+ return straightPieces(route)+}++/**+ * A curve through the control points it was dragged to: each end leaves its side's midpoint, less+ * its gap, towards its own control point.+ */+export function controlledCurveRoute(+ start: ConnectorRouteEnd,+ end: ConnectorRouteEnd,+ [startSide, endSide]: [ConnectorSide, ConnectorSide],+ [startGap, endGap]: [number, number],+ [startHandle, endHandle]: [Vector, Vector]+): ConnectorPiece[] {+ const from = towards(attachment(start, startSide), startHandle, startGap)+ const to = towards(attachment(end, endSide), endHandle, endGap)+ return [+ {+ from,+ to,+ handleFrom: { x: startHandle.x - from.x, y: startHandle.y - from.y },+ handleTo: { x: endHandle.x - to.x, y: endHandle.y - to.y }+ }+ ]+}++/** `point` moved `distance` towards `toward`. */+function towards(point: Vector, toward: Vector, distance: number): Vector {+ const length = Math.hypot(toward.x - point.x, toward.y - point.y)+ if (length < EPSILON) return point+ return along(+ point,+ { x: (toward.x - point.x) / length, y: (toward.y - point.y) / length },+ distance+ )+}++/**+ * The control points an elbow keeps for its route as drawn: one for each segment between its+ * first and its last, at the segment's midpoint, as FigJam records them after an edit.+ */+export function elbowControlPoints(pieces: ConnectorPiece[]): ConnectorControlPoint[] {+ return pieces.slice(1, -1).flatMap(({ from, to }) => {+ const vertical = Math.abs(from.x - to.x) < EPSILON+ if (vertical && Math.abs(from.y - to.y) < EPSILON) return []+ return [+ {+ position: { x: (from.x + to.x) / 2, y: (from.y + to.y) / 2 },+ direction: vertical ? 'VERTICAL' : 'HORIZONTAL'+ }+ ]+ })+}++/**+ * Where an elbow's ends turn when its first or last segment is dragged: a stub's length out of+ * each layer, or at a free end's point.+ */+export function elbowJoints(+ start: ConnectorRouteEnd,+ end: ConnectorRouteEnd,+ [startSide, endSide]: [ConnectorSide, ConnectorSide]+): [Vector, Vector] {+ return [routeSide(start, startSide).joint, routeSide(end, endSide).joint]+}++/**+ * The control points an elbow takes when its segment `index` is dragged across to `offset`: an x+ * for a vertical segment, a y for a horizontal one. A segment between others moves alone. Its+ * first or last segment turns at its end's joint, by a new segment across, and then runs at+ * `offset`, as FigJam splits one.+ */+export function dragElbowSegment(+ pieces: ConnectorPiece[],+ [startJoint, endJoint]: [Vector, Vector],+ index: number,+ offset: number+): ConnectorControlPoint[] {+ const piece = pieces.at(index)+ if (!piece || index < 0) return elbowControlPoints(pieces)+ const direction: Direction =+ Math.abs(piece.from.x - piece.to.x) < EPSILON ? 'VERTICAL' : 'HORIZONTAL'+ const across: Direction = direction === 'VERTICAL' ? 'HORIZONTAL' : 'VERTICAL'+ const x = (piece.from.x + piece.to.x) / 2+ const y = (piece.from.y + piece.to.y) / 2+ const moved: ConnectorControlPoint = {+ position: direction === 'VERTICAL' ? { x: offset, y } : { x, y: offset },+ direction+ }+ const before =+ index === 0+ ? [{ position: startJoint, direction: across }]+ : elbowControlPoints(pieces.slice(0, index + 1))+ const after =+ index === pieces.length - 1+ ? [{ position: endJoint, direction: across }]+ : elbowControlPoints(pieces.slice(index))+ return [...before, moved, ...after]+}++/** A curve's control points as drawn: where its handles reach. */+export function curveControlPoints(piece: ConnectorPiece): [Vector, Vector] {+ return [+ { x: piece.from.x + piece.handleFrom.x, y: piece.from.y + piece.handleFrom.y },+ { x: piece.to.x + piece.handleTo.x, y: piece.to.y + piece.handleTo.y }+ ]+}++/** The point midway along a curve, where its handle sits. */+export function curveMidpoint(piece: ConnectorPiece): Vector {+ return pointAt(piece, 0.5)+}++/**+ * The control points a curve takes when the point midway along it is dragged by `delta`: both+ * move by 4/3 of it, which moves the midpoint by exactly `delta`.+ */+export function dragCurve(handles: [Vector, Vector], delta: Vector): [Vector, Vector] {+ const shift = (point: Vector) => ({+ x: point.x + (delta.x * 4) / 3,+ y: point.y + (delta.y * 4) / 3+ })+ return [shift(handles[0]), shift(handles[1])]+}diff --git a/packages/scene-graph/src/connectors/elbow.ts b/packages/scene-graph/src/connectors/elbow.tsindex f77c24653..d9b7e2444 100644--- a/packages/scene-graph/src/connectors/elbow.ts+++ b/packages/scene-graph/src/connectors/elbow.ts@@ -10,7 +10,7 @@ import {} from './sides'/** How far an elbow runs out of a layer before it may turn, unless the layers are closer. */-const ELBOW_STUB = 48+export const ELBOW_STUB = 48/** What a turn costs against length, so that of two equally long routes the simpler wins. */const BEND_COST = 1/** What a run off the line midway between the layers costs, so turns land on that line. */@@ -190,7 +190,7 @@ function cheapestWalk(grid: Grid, startSide: ConnectorSide, endSide: ConnectorSi}/** Drops repeated points and points in the middle of a straight run. */-function simplify(points: Vector[]): Vector[] {+export function simplify(points: Vector[]): Vector[] {const result: Vector[] = []const same = (a: number, b: number) => Math.abs(a - b) < EPSILONfor (const point of points) {diff --git a/packages/scene-graph/src/connectors/index.ts b/packages/scene-graph/src/connectors/index.tsindex dd2d71a5b..33c3f118f 100644--- a/packages/scene-graph/src/connectors/index.ts+++ b/packages/scene-graph/src/connectors/index.ts@@ -1,9 +1,28 @@export { CONNECTOR_NAME, createConnector, type ConnectorContent } from './create'export { hitsConnectorLine } from './hit'-export { CONNECTOR_LABEL_PADDING, placeConnectorLabel, type ConnectorLabelLayout } from './label'-export { attachedConnectors, connectorsAffectedBy, layoutConnector } from './layout'+export {+ CONNECTOR_LABEL_PADDING,+ connectorLabelPositionAt,+ placeConnectorLabel,+ type ConnectorLabelLayout+} from './label'+export {+ curveControlPoints,+ curveMidpoint,+ dragCurve,+ dragElbowSegment,+ elbowControlPoints,+ elbowJoints+} from './controls'+export {+ attachedConnectors,+ connectorRoute,+ connectorsAffectedBy,+ layoutConnector,+ type ConnectorRoute+} from './layout'export { connectorEndGap } from './gaps'export { connectorNetwork, type ConnectorPiece } from './pieces'-export { routeConnector } from './route'+export { routeConnector, type ConnectorRouteControls } from './route'export { connectorSides, type ConnectorRouteEnd, type ConnectorSide } from './sides'export * from './sublayers'diff --git a/packages/scene-graph/src/connectors/label.ts b/packages/scene-graph/src/connectors/label.tsindex dc5414765..a2d91f635 100644--- a/packages/scene-graph/src/connectors/label.ts+++ b/packages/scene-graph/src/connectors/label.ts@@ -1,4 +1,5 @@import type { Rect, Vector } from '../primitives'+import type { ConnectorLabelPosition } from '../types'import {EPSILON,exitPoint,@@ -47,15 +48,180 @@ export interface ConnectorLabelLayout {plate: Rect}+/** Points sampled along a curved piece to measure and search it. */+const CURVE_SAMPLES = 32++/**+ * How far a label dragged off its line sits from it, centre to line: 0.7 of the plate's extent+ * across the line plus 12.3, fitted to the distances FigJam keeps for plates 31 to 118 across.+ */+const OFF_AXIS_SCALE = 0.7+const OFF_AXIS_OFFSET = 12.3+/**+ * How far past half the plate's extent across the line a dragged label may be from it and stay+ * on it, as FigJam lets it.+ */+const OFF_AXIS_SLACK = 12++/** A piece's length along its curve. */+function lengthOf(piece: ConnectorPiece): number {+ if (isStraight(piece)) return pieceLength(piece)+ let length = 0+ let last = piece.from+ for (let step = 1; step <= CURVE_SAMPLES; step++) {+ const point = pointAt(piece, step / CURVE_SAMPLES)+ length += Math.hypot(point.x - last.x, point.y - last.y)+ last = point+ }+ return length+}++/** Where a route is `distance` along it: which piece, how far into it, and which way it runs. */+function alongRoute(pieces: ConnectorPiece[], distance: number) {+ let left = Math.max(0, distance)+ for (const [index, piece] of pieces.entries()) {+ const length = lengthOf(piece)+ if (left <= length || index === pieces.length - 1) {+ const t = length > 0 ? Math.min(1, left / length) : 0+ return { index, t, point: pointAt(piece, t), direction: directionAt(piece, t) }+ }+ left -= length+ }+ return null+}++function directionAt(piece: ConnectorPiece, t: number): Vector {+ const a = pointAt(piece, Math.max(0, t - 0.001))+ const b = pointAt(piece, Math.min(1, t + 0.001))+ const length = Math.hypot(b.x - a.x, b.y - a.y)+ return length > 0 ? { x: (b.x - a.x) / length, y: (b.y - a.y) / length } : { x: 1, y: 0 }+}++/** The side to the left of a run along `direction`, which FigJam calls above. */+function above(direction: Vector): Vector {+ return { x: direction.y, y: -direction.x }+}++/** A plate's extent across a line running along `direction`. */+function extentAcross(size: { width: number; height: number }, direction: Vector): number {+ return Math.abs(direction.y) * size.width + Math.abs(direction.x) * size.height+}++function plateAt(centre: Vector, size: { width: number; height: number }): Rect {+ return { x: centre.x - size.width / 2, y: centre.y - size.height / 2, ...size }+}++/** Cuts the plate's span out of piece `index`, around the point `t` along it. */+function cutAround(+ pieces: ConnectorPiece[],+ index: number,+ t: number,+ plate: Rect+): ConnectorPiece[] {+ const piece = pieces[index]+ // A line between touching layers has no length to cut; it keeps its one point.+ if (pieceLength(piece) <= EPSILON) return pieces+ const t0 = crossing(piece, plate, t, 0)+ const t1 = crossing(piece, plate, t, 1)+ const cut = [+ ...(t0 > EPSILON ? [subPiece(piece, 0, t0)] : []),+ ...(t1 < 1 - EPSILON ? [subPiece(piece, t1, 1)] : [])+ ]+ return [...pieces.slice(0, index), ...cut, ...pieces.slice(index + 1)]+}++/**+ * A label dragged along its line: its centre `offset` of the way from the middle to an end, by+ * length, cutting the line there, or beside the line, which then runs on uncut.+ */+function placeDragged(+ pieces: ConnectorPiece[],+ size: { width: number; height: number },+ { section, offset, offAxis }: ConnectorLabelPosition+): ConnectorLabelLayout | null {+ const total = pieces.reduce((sum, piece) => sum + lengthOf(piece), 0)+ const half = total / 2+ const at = alongRoute(pieces, half + (section === 'MIDDLE_TO_END' ? offset : -offset) * half)+ if (!at) return null+ if (offAxis === 'NONE') {+ const plate = plateAt(at.point, size)+ return { pieces: cutAround(pieces, at.index, at.t, plate), plate }+ }+ const side = above(at.direction)+ const sign = offAxis === 'ABOVE' ? 1 : -1+ const distance = OFF_AXIS_SCALE * extentAcross(size, at.direction) + OFF_AXIS_OFFSET+ const centre = {+ x: at.point.x + side.x * sign * distance,+ y: at.point.y + side.y * sign * distance+ }+ return { pieces, plate: plateAt(centre, size) }+}++/**+ * Where a label dragged to `point` goes, as FigJam places it: at the nearest point of the line,+ * as a share of the way from the middle towards an end, and beside the line once the point is+ * farther from it than half the plate across plus a little.+ */+export function connectorLabelPositionAt(+ pieces: ConnectorPiece[],+ size: { width: number; height: number },+ point: Vector+): ConnectorLabelPosition | null {+ let best: { distance: number; along: number; direction: Vector; across: number } | null = null+ let before = 0+ for (const piece of pieces) {+ const length = lengthOf(piece)+ const samples = isStraight(piece) ? 1 : CURVE_SAMPLES+ for (let step = 0; step < samples; step++) {+ // The nearest point of each straight stretch, curves taken a stretch at a time.+ const a = pointAt(piece, step / samples)+ const b = pointAt(piece, (step + 1) / samples)+ const dx = b.x - a.x+ const dy = b.y - a.y+ const span = Math.hypot(dx, dy)+ const u =+ span > 0+ ? Math.max(0, Math.min(1, ((point.x - a.x) * dx + (point.y - a.y) * dy) / (span * span)))+ : 0+ const near = { x: a.x + dx * u, y: a.y + dy * u }+ const distance = Math.hypot(point.x - near.x, point.y - near.y)+ if (best && distance >= best.distance - EPSILON) continue+ const direction =+ span > 0 ? { x: dx / span, y: dy / span } : directionAt(piece, step / samples)+ const side = above(direction)+ best = {+ distance,+ along: before + (length * (step + u)) / samples,+ direction,+ across: (point.x - near.x) * side.x + (point.y - near.y) * side.y+ }+ }+ before += length+ }+ if (!best || before <= 0) return null+ const half = before / 2+ const beside = best.distance > extentAcross(size, best.direction) / 2 + OFF_AXIS_SLACK+ const side = best.across > 0 ? 'ABOVE' : 'BELOW'+ return {+ // The middle itself counts towards the start, as FigJam records it.+ section: best.along > half + EPSILON ? 'MIDDLE_TO_END' : 'MIDDLE_TO_START',+ offset: Math.min(1, Math.abs(best.along - half) / half),+ offAxis: beside ? side : 'NONE'+ }+}+/*** Places a label's plate on a route and cuts the line where it sits: midway along a straight or- * curved line, and midway along an elbow's longest run, the first of equal runs.+ * curved line, and midway along an elbow's longest run, the first of equal runs, unless it was+ * dragged to a `position` of its own.*/export function placeConnectorLabel(pieces: ConnectorPiece[],- plateSize: { width: number; height: number }+ plateSize: { width: number; height: number },+ position: ConnectorLabelPosition | null = null): ConnectorLabelLayout | null {if (pieces.length === 0) return null+ if (position) return placeDragged(pieces, plateSize, position)let index = 0for (let n = 1; n < pieces.length; n++) {if (pieceLength(pieces[n]) > pieceLength(pieces[index]) + EPSILON) index = n@@ -68,13 +234,5 @@ export function placeConnectorLabel(width: plateSize.width,height: plateSize.height}- // A line between touching layers has no length to cut; it keeps its one point.- if (pieceLength(piece) <= EPSILON) return { pieces, plate }- const t0 = crossing(piece, plate, 0.5, 0)- const t1 = crossing(piece, plate, 0.5, 1)- const cut = [- ...(t0 > EPSILON ? [subPiece(piece, 0, t0)] : []),- ...(t1 < 1 - EPSILON ? [subPiece(piece, t1, 1)] : [])- ]- return { pieces: [...pieces.slice(0, index), ...cut, ...pieces.slice(index + 1)], plate }+ return { pieces: cutAround(pieces, index, 0.5, plate), plate }}diff --git a/packages/scene-graph/src/connectors/layout.ts b/packages/scene-graph/src/connectors/layout.tsindex 1da1ef51c..20fd035e2 100644--- a/packages/scene-graph/src/connectors/layout.ts+++ b/packages/scene-graph/src/connectors/layout.ts@@ -5,11 +5,12 @@ import { computeBounds } from '../geometry'import type { SceneGraph } from '../graph'import Matrix from '../matrix'import type { Vector } from '../primitives'-import type { ConnectorEndpoint, SceneNode, StrokeCap } from '../types'+import type { ConnectorControlPoint, ConnectorEndpoint, SceneNode, StrokeCap } from '../types'+import { elbowControlPoints } from './controls'import { CONNECTOR_LABEL_PADDING, placeConnectorLabel, type ConnectorLabelLayout } from './label'import { connectorNetwork, piecesBounds, type ConnectorPiece } from './pieces'-import { routeConnector } from './route'-import type { ConnectorRouteEnd } from './sides'+import { routeConnector, type ConnectorRouteControls } from './route'+import { connectorSides, type ConnectorRouteEnd, type ConnectorSide } from './sides'import { connectorRouteEnds, connectorSublayers, type ConnectorSublayers } from './sublayers'/**@@ -67,6 +68,67 @@ function changesFor(node: SceneNode, changes: Partial<SceneNode>): Partial<Scenetype Write = [SceneNode, Partial<SceneNode>]+function shifted(point: Vector, by: Vector): Vector {+ return { x: point.x + by.x, y: point.y + by.y }+}++/** Control points carried between the connector's own axes and its parent's, by `by`. */+function shiftControls(+ points: ConnectorControlPoint[],+ curve: [Vector, Vector] | null,+ by: Vector+): ConnectorRouteControls {+ return {+ points: points.map((point) => ({ ...point, position: shifted(point.position, by) })),+ curve: curve && [shifted(curve[0], by), shifted(curve[1], by)]+ }+}++/** A connector's route as its ends and control points give it, in its parent's axes. */+export interface ConnectorRoute {+ start: ConnectorRouteEnd+ end: ConnectorRouteEnd+ sides: [ConnectorSide, ConnectorSide]+ /** The line before its label cuts it. */+ pieces: ConnectorPiece[]+ /** Its control points in its parent's axes. */+ controls: ConnectorRouteControls+}++/**+ * Routes a connector from the layers its ends follow and the control points it was dragged to,+ * without laying anything out. Null when an end cannot be placed.+ */+export function connectorRoute(graph: SceneGraph, connector: SceneNode): ConnectorRoute | null {+ const parts = connectorSublayers(graph, connector)+ const { connectorStart, connectorEnd } = connector+ if (!parts || !connectorStart || !connectorEnd) return null+ // Where the line last ran, for an end whose layer is gone.+ const drawn = connectorRouteEnds(graph, connector)+ const start = routeEnd(+ graph,+ connector,+ connectorStart,+ connector.connectorStartCap,+ drawn?.start+ )+ const end = routeEnd(graph, connector, connectorEnd, connector.connectorEndCap, drawn?.end)+ if (!start || !end) return null+ const weight = parts.line.strokes[0]?.weight ?? parts.line.strokeWeight+ const controls = shiftControls(+ connector.connectorControlPoints,+ connector.connectorCurveHandles,+ connector+ )+ return {+ start,+ end,+ sides: connectorSides(start, end),+ pieces: routeConnector(connector.connectorLineType, start, end, weight, controls),+ controls+ }+}+/*** Where the connector, its line, and its label go for a route with the label placed on it. A* connector that keeps its box places its line and label inside the box it has.@@ -77,7 +139,8 @@ function routeWrites(pieces: ConnectorPiece[],placed: ConnectorLabelLayout | null,labelled: boolean,- keepBox: boolean+ keepBox: boolean,+ controls: ConnectorRouteControls): Write[] | null {const lineBox = pieces.length > 0 ? piecesBounds(pieces) : nullconst boxes = compact([lineBox, labelled ? placed?.plate : null])@@ -85,8 +148,17 @@ function routeWrites(const bounds = computeBounds(boxes)const frame = keepBox ? connector : boundsconst lineOrigin = lineBox ?? bounds+ // Control points stay where they are in the parent as the connector's box moves to fit.+ const local = shiftControls(controls.points, controls.curve, { x: -frame.x, y: -frame.y })const writes: Write[] = [- [connector, keepBox ? {} : pick(frame, ['x', 'y', 'width', 'height'])],+ [+ connector,+ {+ ...(keepBox ? {} : pick(frame, ['x', 'y', 'width', 'height'])),+ connectorControlPoints: local.points,+ connectorCurveHandles: local.curve+ }+ ],[line,{@@ -118,39 +190,36 @@ function routeWrites(* and label to match, through `update` so the caller decides whether that is an edit or a* preview. Returns whether anything moved. A connector with an end that cannot be placed keeps* its route. With `keepBox`, the connector keeps its own position and size, as while a move- * previews.+ * previews. With `capture`, an elbow that was dragged keeps its new route's segments as its+ * control points, as FigJam does after an edit reroutes one.*/export function layoutConnector(graph: SceneGraph,connector: SceneNode,update: (id: string, changes: Partial<SceneNode>) => void = (id, changes) =>graph.updateNode(id, changes),- { keepBox = false }: { keepBox?: boolean } = {}+ { keepBox = false, capture = false }: { keepBox?: boolean; capture?: boolean } = {}): boolean {const parts = connectorSublayers(graph, connector)- const { connectorStart, connectorEnd } = connector- if (!parts || !connectorStart || !connectorEnd) return false- const { line, label } = parts- // Where the line last ran, for an end whose layer is gone.- const drawn = connectorRouteEnds(graph, connector)- const start = routeEnd(- graph,- connector,- connectorStart,- connector.connectorStartCap,- drawn?.start- )- const end = routeEnd(graph, connector, connectorEnd, connector.connectorEndCap, drawn?.end)- if (!start || !end) return false- const weight = line.strokes[0]?.weight ?? line.strokeWeight- const pieces = routeConnector(connector.connectorLineType, start, end, weight)+ const route = connectorRoute(graph, connector)+ if (!parts || !route) return false+ const { label } = parts+ const { pieces } = route+ const controls =+ capture && connector.connectorLineType === 'ELBOWED' && route.controls.points.length > 0+ ? { ...route.controls, points: elbowControlPoints(pieces) }+ : route.controlsconst labelled = label.text !== ''- const placed = placeConnectorLabel(pieces, {- width: label.width + CONNECTOR_LABEL_PADDING * 2,- height: label.height + CONNECTOR_LABEL_PADDING * 2- })+ const placed = placeConnectorLabel(+ pieces,+ {+ width: label.width + CONNECTOR_LABEL_PADDING * 2,+ height: label.height + CONNECTOR_LABEL_PADDING * 2+ },+ connector.connectorLabelPosition+ )const routed = labelled && placed ? placed.pieces : pieces- const writes = routeWrites(connector, parts, routed, placed, labelled, keepBox)+ const writes = routeWrites(connector, parts, routed, placed, labelled, keepBox, controls)let moved = false// A route derives from its ends, so laying it out is layout rather than an edit, as moving the// connector it fits is not.diff --git a/packages/scene-graph/src/connectors/route.ts b/packages/scene-graph/src/connectors/route.tsindex 90990423a..d0bcec27c 100644--- a/packages/scene-graph/src/connectors/route.ts+++ b/packages/scene-graph/src/connectors/route.ts@@ -1,5 +1,6 @@import type { Rect, Vector } from '../primitives'-import type { ConnectorLineType } from '../types'+import type { ConnectorControlPoint, ConnectorLineType } from '../types'+import { controlledCurveRoute, controlledElbowRoute } from './controls'import { elbowRoute } from './elbow'import { connectorEndGap } from './gaps'import { along, EPSILON, exitPoint, straightPieces, ZERO, type ConnectorPiece } from './pieces'@@ -99,16 +100,27 @@ function gapped(end: ConnectorRouteEnd): boolean {return end.magnet !== 'NONE'}+/** Where a connector's line was dragged to, in the connector's parent's axes. */+export interface ConnectorRouteControls {+ /** An elbow's dragged segments, in order. */+ points: ConnectorControlPoint[]+ /** A curve's two control points. */+ curve: [Vector, Vector] | null+}+/*** The pieces of a connector's line between its two ends, in the connector's parent's axes. Ends* attached by a magnet stop short by their caps' gaps; free ends sit on their points. Layers that- * touch or overlap leave an elbow or a curve nothing to route but the start, as in Figma.+ * touch or overlap leave an elbow or a curve nothing to route but the start, as in Figma. An elbow+ * runs along the segments it was dragged to and a curve bends to its dragged control points,+ * leaving their ends by the sides they would take anyway.*/export function routeConnector(lineType: ConnectorLineType,start: ConnectorRouteEnd,end: ConnectorRouteEnd,- strokeWeight: number+ strokeWeight: number,+ controls: ConnectorRouteControls = { points: [], curve: null }): ConnectorPiece[] {const gaps: [number, number] = [gapped(start) ? connectorEndGap(start, strokeWeight, 'start') : 0,@@ -120,11 +132,17 @@ export function routeConnector(const at = sideMidpoint(start.box, startSide)return [{ from: at, to: at, handleFrom: ZERO, handleTo: ZERO }]}+ if (lineType === 'CURVED' && controls.curve) {+ return controlledCurveRoute(start, end, [startSide, endSide], gaps, controls.curve)+ }if (lineType === 'CURVED') {// A curve to a free point arrives facing the way it left, where an elbow arrives along the// longer axis.const curveEndSide = end.box || !start.box ? endSide : opposite(startSide)return curvedRoute(start, end, [startSide, curveEndSide], gaps)}+ if (controls.points.length > 0) {+ return controlledElbowRoute(start, end, [startSide, endSide], gaps, controls.points)+ }return elbowRoute(start, end, [startSide, endSide], gaps) ?? []}diff --git a/packages/scene-graph/src/connectors/sublayers.ts b/packages/scene-graph/src/connectors/sublayers.tsindex f8f8790fe..dcc600130 100644--- a/packages/scene-graph/src/connectors/sublayers.ts+++ b/packages/scene-graph/src/connectors/sublayers.ts@@ -191,3 +191,11 @@ export function boundEndpoint(): ConnectorEndpoint {return { nodeId, magnet, position: { x: 0, y: 0 } }}++/** The connector whose label `node` is, if it is one. */+export function labelledConnector(graph: SceneGraph, node: SceneNode): SceneNode | null {+ if (node.type !== 'TEXT' || !node.parentId) return null+ const owner = graph.getNode(node.parentId)+ if (owner?.type !== 'CONNECTOR') return null+ return connectorSublayers(graph, owner)?.label.id === node.id ? owner : null+}diff --git a/packages/scene-graph/src/copy.ts b/packages/scene-graph/src/copy.tsindex 54328a5db..b367d4e9b 100644--- a/packages/scene-graph/src/copy.ts+++ b/packages/scene-graph/src/copy.ts@@ -315,6 +315,9 @@ export function cloneNodeProps(gridPosition: src.gridPosition ? { ...src.gridPosition } : null,targetAspectRatio: src.targetAspectRatio ? { ...src.targetAspectRatio } : null,connectorStart: src.connectorStart ? copyConnectorEndpoint(src.connectorStart) : null,- connectorEnd: src.connectorEnd ? copyConnectorEndpoint(src.connectorEnd) : null+ connectorEnd: src.connectorEnd ? copyConnectorEndpoint(src.connectorEnd) : null,+ connectorControlPoints: structuredClone(src.connectorControlPoints),+ connectorCurveHandles: structuredClone(src.connectorCurveHandles),+ connectorLabelPosition: src.connectorLabelPosition ? { ...src.connectorLabelPosition } : null}}diff --git a/packages/scene-graph/src/node-defaults.ts b/packages/scene-graph/src/node-defaults.tsindex f00d1f212..0ca8b809d 100644--- a/packages/scene-graph/src/node-defaults.ts+++ b/packages/scene-graph/src/node-defaults.ts@@ -166,6 +166,9 @@ export function createDefaultNode(connectorLineType: 'ELBOWED',connectorStartCap: 'ROUND',connectorEndCap: 'ARROW_LINES',+ connectorControlPoints: [],+ connectorCurveHandles: null,+ connectorLabelPosition: null,isMask: false,maskType: 'ALPHA',maskIsOutline: false,diff --git a/packages/scene-graph/src/types.ts b/packages/scene-graph/src/types.tsindex 41b84e034..d29906264 100644--- a/packages/scene-graph/src/types.ts+++ b/packages/scene-graph/src/types.ts@@ -277,6 +277,26 @@ export interface ConnectorEndpoint {}export type ConnectorLineType = 'ELBOWED' | 'STRAIGHT' | 'CURVED'++/**+ * A segment of an elbow connector that was dragged into place: the line it runs along, through+ * `position`, in the connector's own axes. `position` lies midway along the segment as last drawn.+ */+export interface ConnectorControlPoint {+ position: Vector+ direction: 'HORIZONTAL' | 'VERTICAL'+}++/**+ * Where a connector's label was dragged along its line: `offset` of the way from the middle of+ * the line towards one end, by length, on the line or to one side of it. `ABOVE` is the side to+ * the left of the line's direction.+ */+export interface ConnectorLabelPosition {+ section: 'MIDDLE_TO_START' | 'MIDDLE_TO_END'+ offset: number+ offAxis: 'NONE' | 'ABOVE' | 'BELOW'+}export type TextAlignVertical = 'TOP' | 'CENTER' | 'BOTTOM'export type TextCase = 'ORIGINAL' | 'UPPER' | 'LOWER' | 'TITLE'export type TextDecoration = 'NONE' | 'UNDERLINE' | 'STRIKETHROUGH'@@ -716,6 +736,18 @@ export interface SceneNode {connectorLineType: ConnectorLineTypeconnectorStartCap: StrokeCapconnectorEndCap: StrokeCap+ /**+ * An elbow connector's segments between its first and last, in order, once one was dragged;+ * empty while it routes itself. Kept, unused, while the line is straight or curved.+ */+ connectorControlPoints: ConnectorControlPoint[]+ /**+ * A curved connector's two cubic control points, in the connector's own axes, once its curve+ * was dragged; null while it curves by itself. Kept, unused, while the line is not curved.+ */+ connectorCurveHandles: [Vector, Vector] | null+ /** Where a connector's label was dragged to; null while it sits midway along the line. */+ connectorLabelPosition: ConnectorLabelPosition | nullisMask: booleanmaskType: MaskTypediff --git a/packages/scene-graph/tests/connectors/controls.test.ts b/packages/scene-graph/tests/connectors/controls.test.tsnew file mode 100644index 000000000..42408a803--- /dev/null+++ b/packages/scene-graph/tests/connectors/controls.test.ts@@ -0,0 +1,164 @@+import { describe, expect, test } from 'bun:test'+import { readFileSync } from 'node:fs'++import * as v from 'valibot'++import type { ConnectorControlPoint } from '@open-pencil/scene-graph'+import {+ connectorNetwork,+ dragCurve,+ dragElbowSegment,+ elbowControlPoints,+ elbowJoints,+ routeConnector,+ connectorSides,+ type ConnectorRouteEnd+} from '@open-pencil/scene-graph/connectors'++const pairSchema = v.tuple([v.number(), v.number()])+const boxSchema = v.tuple([v.number(), v.number(), v.number(), v.number()])+const endSchema = v.object({+ box: boxSchema,+ magnet: v.picklist(['AUTO', 'TOP', 'RIGHT', 'BOTTOM', 'LEFT']),+ outline: v.number()+})++/**+ * Routes FigJam derived on 2026-10-23 for connectors dragged into place from a 160 px shape at+ * the origin to another, each with its default caps and a weight of 4: one dragged at its middle+ * segment, one at its first segment, and one curve dragged at its midpoint. The other shape was+ * then moved and resized by script, which keeps the control points as they were.+ */+const oracle = v.parse(+ v.pipe(+ v.string(),+ v.parseJson(),+ v.array(+ v.object({+ name: v.string(),+ lineType: v.picklist(['ELBOWED', 'CURVED']),+ start: endSchema,+ end: endSchema,+ vertices: v.array(pairSchema),+ segments: v.array(v.tuple([v.number(), v.number(), pairSchema, pairSchema])),+ controls: v.array(v.object({ position: pairSchema, axis: pairSchema })),+ curve: v.array(pairSchema)+ })+ )+ ),+ readFileSync(new URL('figma-control-routes.json', import.meta.url), 'utf8')+)++function routeEnd(+ { box: [x, y, width, height], magnet, outline }: v.InferOutput<typeof endSchema>,+ cap: 'ROUND' | 'ARROW_LINES'+): ConnectorRouteEnd {+ return { box: { x, y, width, height }, point: { x: 0, y: 0 }, magnet, cap, outline }+}++function controlPoint(position: [number, number], axis: [number, number]): ConnectorControlPoint {+ return { position: { x: position[0], y: position[1] }, direction: axis[0] ? 'HORIZONTAL' : 'VERTICAL' }+}++const close = (actual: number, expected: number) => Math.abs(actual - expected) <= 0.01++describe('dragged connectors route as Figma does', () => {+ for (const c of oracle) {+ test(c.name, () => {+ const [first, second] = c.curve+ const pieces = routeConnector(+ c.lineType,+ routeEnd(c.start, 'ROUND'),+ routeEnd(c.end, 'ARROW_LINES'),+ 4,+ {+ points: c.controls.map(({ position, axis }) => controlPoint(position, axis)),+ curve: first && second ? [{ x: first[0], y: first[1] }, { x: second[0], y: second[1] }] : null+ }+ )+ const network = connectorNetwork(pieces, { x: 0, y: 0 }, { start: 'ROUND', end: 'ARROW_LINES' })+ expect(network.vertices.map(({ x, y }) => [x, y])).toHaveLength(c.vertices.length)+ for (const [index, [x, y]] of c.vertices.entries()) {+ const vertex = network.vertices[index]+ expect({ index, ok: close(vertex.x, x) && close(vertex.y, y) }).toEqual({ index, ok: true })+ }+ for (const [index, [, , [t0x, t0y], [t1x, t1y]]] of c.segments.entries()) {+ const { tangentStart, tangentEnd } = network.segments[index]+ expect(+ close(tangentStart.x, t0x) &&+ close(tangentStart.y, t0y) &&+ close(tangentEnd.x, t1x) &&+ close(tangentEnd.y, t1y)+ ).toBe(true)+ }+ })+ }+})++/** Two 160 px shapes, the second below and to the right, as the drags were measured from. */+const start = routeEnd({ box: [0, 0, 160, 160], magnet: 'AUTO', outline: 2 }, 'ROUND')+const end = routeEnd({ box: [480, 320, 160, 160], magnet: 'AUTO', outline: 2 }, 'ARROW_LINES')+const auto = routeConnector('ELBOWED', start, end, 4)+const joints = elbowJoints(start, end, connectorSides(start, end))+const points = (controls: ConnectorControlPoint[]) =>+ controls.map(({ position, direction }) => [direction, position.x, position.y])++describe('dragging an elbow segment', () => {+ test('moves a middle segment alone', () => {+ expect(points(dragElbowSegment(auto, joints, 1, 352))).toEqual([['VERTICAL', 352, 240]])+ })++ test('turns a first segment out a stub from its layer', () => {+ const controls = dragElbowSegment(auto, joints, 0, 16)+ expect(points(controls)).toEqual([+ ['VERTICAL', 208, 80],+ ['HORIZONTAL', 244, 16],+ ['VERTICAL', 320, 240]+ ])+ // Recorded at each segment's midpoint once routed, as Figma stores them.+ const routed = routeConnector('ELBOWED', start, end, 4, { points: controls, curve: null })+ expect(points(elbowControlPoints(routed))).toEqual([+ ['VERTICAL', 208, 48],+ ['HORIZONTAL', 264, 16],+ ['VERTICAL', 320, 208]+ ])+ })++ test('turns a last segment out a stub from its layer', () => {+ const controls = dragElbowSegment(auto, joints, 2, 480)+ const routed = routeConnector('ELBOWED', start, end, 4, { points: controls, curve: null })+ expect(points(elbowControlPoints(routed))).toEqual([+ ['VERTICAL', 320, 280],+ ['HORIZONTAL', 376, 480],+ ['VERTICAL', 432, 440]+ ])+ })++ test('turns a lone segment out of both layers', () => {+ const level = routeEnd({ box: [480, 0, 160, 160], magnet: 'AUTO', outline: 2 }, 'ARROW_LINES')+ const straight = routeConnector('ELBOWED', start, level, 4)+ expect(straight).toHaveLength(1)+ const controls = dragElbowSegment(straight, elbowJoints(start, level, ['RIGHT', 'LEFT']), 0, 176)+ const routed = routeConnector('ELBOWED', start, level, 4, { points: controls, curve: null })+ expect(points(elbowControlPoints(routed))).toEqual([+ ['VERTICAL', 208, 128],+ ['HORIZONTAL', 320, 176],+ ['VERTICAL', 432, 128]+ ])+ })+})++test('dragging a curve moves both control points by 4/3 of the drag', () => {+ const [curve] = routeConnector('CURVED', start, end, 4)+ const handles = dragCurve(+ [+ { x: curve.from.x + curve.handleFrom.x, y: curve.from.y + curve.handleFrom.y },+ { x: curve.to.x + curve.handleTo.x, y: curve.to.y + curve.handleTo.y }+ ],+ { x: 80, y: -80 }+ )+ expect(handles.map(({ x, y }) => [Math.round(x * 100) / 100, Math.round(y * 100) / 100])).toEqual([+ [459.76, -26.67],+ [393.58, 293.33]+ ])+})diff --git a/packages/scene-graph/tests/connectors/figma-control-routes.json b/packages/scene-graph/tests/connectors/figma-control-routes.jsonnew file mode 100644index 000000000..56912031a--- /dev/null+++ b/packages/scene-graph/tests/connectors/figma-control-routes.json@@ -0,0 +1,8405 @@+[+ {+ "name": "mid B(480,320,160x160) AUTO",+ "lineType": "ELBOWED",+ "start": {+ "box": [+ 0,+ 0,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "end": {+ "box": [+ 480,+ 320,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "vertices": [+ [+ 168,+ 80+ ],+ [+ 352,+ 80+ ],+ [+ 352,+ 400+ ],+ [+ 471.5,+ 400+ ]+ ],+ "segments": [+ [+ 0,+ 1,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 1,+ 2,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 2,+ 3,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ]+ ],+ "controls": [+ {+ "position": [+ 352,+ 240+ ],+ "axis": [+ 0,+ 1+ ]+ }+ ],+ "curve": []+ },+ {+ "name": "mid B(480,400,160x160) AUTO",+ "lineType": "ELBOWED",+ "start": {+ "box": [+ 0,+ 0,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "end": {+ "box": [+ 480,+ 400,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "vertices": [+ [+ 168,+ 80+ ],+ [+ 352,+ 80+ ],+ [+ 352,+ 352+ ],+ [+ 560,+ 352+ ],+ [+ 560,+ 391.5+ ]+ ],+ "segments": [+ [+ 0,+ 1,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 1,+ 2,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 2,+ 3,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 3,+ 4,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ]+ ],+ "controls": [+ {+ "position": [+ 352,+ 240+ ],+ "axis": [+ 0,+ 1+ ]+ }+ ],+ "curve": []+ },+ {+ "name": "mid B(560,320,160x160) AUTO",+ "lineType": "ELBOWED",+ "start": {+ "box": [+ 0,+ 0,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "end": {+ "box": [+ 560,+ 320,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "vertices": [+ [+ 168,+ 80+ ],+ [+ 352,+ 80+ ],+ [+ 352,+ 400+ ],+ [+ 551.5,+ 400+ ]+ ],+ "segments": [+ [+ 0,+ 1,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 1,+ 2,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 2,+ 3,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ]+ ],+ "controls": [+ {+ "position": [+ 352,+ 240+ ],+ "axis": [+ 0,+ 1+ ]+ }+ ],+ "curve": []+ },+ {+ "name": "mid B(300,320,160x160) AUTO",+ "lineType": "ELBOWED",+ "start": {+ "box": [+ 0,+ 0,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "end": {+ "box": [+ 300,+ 320,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "vertices": [+ [+ 168,+ 80+ ],+ [+ 352,+ 80+ ],+ [+ 352,+ 272+ ],+ [+ 380,+ 272+ ],+ [+ 380,+ 311.5+ ]+ ],+ "segments": [+ [+ 0,+ 1,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 1,+ 2,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 2,+ 3,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 3,+ 4,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ]+ ],+ "controls": [+ {+ "position": [+ 352,+ 240+ ],+ "axis": [+ 0,+ 1+ ]+ }+ ],+ "curve": []+ },+ {+ "name": "mid B(0,400,160x160) AUTO",+ "lineType": "ELBOWED",+ "start": {+ "box": [+ 0,+ 0,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "end": {+ "box": [+ 0,+ 400,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "vertices": [+ [+ 80,+ 168+ ],+ [+ 80,+ 208+ ],+ [+ 352,+ 208+ ],+ [+ 352,+ 352+ ],+ [+ 80,+ 352+ ],+ [+ 80,+ 391.5+ ]+ ],+ "segments": [+ [+ 0,+ 1,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 1,+ 2,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 2,+ 3,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 3,+ 4,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 4,+ 5,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ]+ ],+ "controls": [+ {+ "position": [+ 352,+ 240+ ],+ "axis": [+ 0,+ 1+ ]+ }+ ],+ "curve": []+ },+ {+ "name": "mid B(-300,0,160x160) AUTO",+ "lineType": "ELBOWED",+ "start": {+ "box": [+ 0,+ 0,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "end": {+ "box": [+ -300,+ 0,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "vertices": [+ [+ -8,+ 80+ ],+ [+ -131.5,+ 80+ ]+ ],+ "segments": [+ [+ 0,+ 1,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ]+ ],+ "controls": [+ {+ "position": [+ 352,+ 240+ ],+ "axis": [+ 0,+ 1+ ]+ }+ ],+ "curve": []+ },+ {+ "name": "mid B(-400,320,160x160) AUTO",+ "lineType": "ELBOWED",+ "start": {+ "box": [+ 0,+ 0,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "end": {+ "box": [+ -400,+ 320,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "vertices": [+ [+ 80,+ 168+ ],+ [+ 80,+ 208+ ],+ [+ 352,+ 208+ ],+ [+ 352,+ 400+ ],+ [+ -231.5,+ 400+ ]+ ],+ "segments": [+ [+ 0,+ 1,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 1,+ 2,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 2,+ 3,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 3,+ 4,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ]+ ],+ "controls": [+ {+ "position": [+ 352,+ 240+ ],+ "axis": [+ 0,+ 1+ ]+ }+ ],+ "curve": []+ },+ {+ "name": "mid B(480,0,160x160) AUTO",+ "lineType": "ELBOWED",+ "start": {+ "box": [+ 0,+ 0,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "end": {+ "box": [+ 480,+ 0,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "vertices": [+ [+ 168,+ 80+ ],+ [+ 471.5,+ 80+ ]+ ],+ "segments": [+ [+ 0,+ 1,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ]+ ],+ "controls": [+ {+ "position": [+ 352,+ 240+ ],+ "axis": [+ 0,+ 1+ ]+ }+ ],+ "curve": []+ },+ {+ "name": "mid B(480,8,160x160) AUTO",+ "lineType": "ELBOWED",+ "start": {+ "box": [+ 0,+ 0,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "end": {+ "box": [+ 480,+ 8,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "vertices": [+ [+ 168,+ 80+ ],+ [+ 352,+ 80+ ],+ [+ 352,+ 88+ ],+ [+ 471.5,+ 88+ ]+ ],+ "segments": [+ [+ 0,+ 1,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 1,+ 2,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 2,+ 3,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ]+ ],+ "controls": [+ {+ "position": [+ 352,+ 240+ ],+ "axis": [+ 0,+ 1+ ]+ }+ ],+ "curve": []+ },+ {+ "name": "mid B(480,40,160x160) AUTO",+ "lineType": "ELBOWED",+ "start": {+ "box": [+ 0,+ 0,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "end": {+ "box": [+ 480,+ 40,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "vertices": [+ [+ 168,+ 80+ ],+ [+ 352,+ 80+ ],+ [+ 352,+ 120+ ],+ [+ 471.5,+ 120+ ]+ ],+ "segments": [+ [+ 0,+ 1,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 1,+ 2,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 2,+ 3,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ]+ ],+ "controls": [+ {+ "position": [+ 352,+ 240+ ],+ "axis": [+ 0,+ 1+ ]+ }+ ],+ "curve": []+ },+ {+ "name": "mid B(480,-40,160x160) AUTO",+ "lineType": "ELBOWED",+ "start": {+ "box": [+ 0,+ 0,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "end": {+ "box": [+ 480,+ -40,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "vertices": [+ [+ 168,+ 80+ ],+ [+ 352,+ 80+ ],+ [+ 352,+ 40+ ],+ [+ 471.5,+ 40+ ]+ ],+ "segments": [+ [+ 0,+ 1,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 1,+ 2,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 2,+ 3,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ]+ ],+ "controls": [+ {+ "position": [+ 352,+ 240+ ],+ "axis": [+ 0,+ 1+ ]+ }+ ],+ "curve": []+ },+ {+ "name": "mid B(480,-300,160x160) AUTO",+ "lineType": "ELBOWED",+ "start": {+ "box": [+ 0,+ 0,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "end": {+ "box": [+ 480,+ -300,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "vertices": [+ [+ 168,+ 80+ ],+ [+ 352,+ 80+ ],+ [+ 352,+ -220+ ],+ [+ 471.5,+ -220+ ]+ ],+ "segments": [+ [+ 0,+ 1,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 1,+ 2,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 2,+ 3,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ]+ ],+ "controls": [+ {+ "position": [+ 352,+ 240+ ],+ "axis": [+ 0,+ 1+ ]+ }+ ],+ "curve": []+ },+ {+ "name": "mid B(800,0,160x160) AUTO",+ "lineType": "ELBOWED",+ "start": {+ "box": [+ 0,+ 0,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "end": {+ "box": [+ 800,+ 0,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "vertices": [+ [+ 168,+ 80+ ],+ [+ 791.5,+ 80+ ]+ ],+ "segments": [+ [+ 0,+ 1,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ]+ ],+ "controls": [+ {+ "position": [+ 352,+ 240+ ],+ "axis": [+ 0,+ 1+ ]+ }+ ],+ "curve": []+ },+ {+ "name": "mid B(200,-400,160x160) AUTO",+ "lineType": "ELBOWED",+ "start": {+ "box": [+ 0,+ 0,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "end": {+ "box": [+ 200,+ -400,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "vertices": [+ [+ 80,+ -8+ ],+ [+ 80,+ -48+ ],+ [+ 352,+ -48+ ],+ [+ 352,+ -192+ ],+ [+ 280,+ -192+ ],+ [+ 280,+ -231.5+ ]+ ],+ "segments": [+ [+ 0,+ 1,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 1,+ 2,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 2,+ 3,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 3,+ 4,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 4,+ 5,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ]+ ],+ "controls": [+ {+ "position": [+ 352,+ 240+ ],+ "axis": [+ 0,+ 1+ ]+ }+ ],+ "curve": []+ },+ {+ "name": "mid B(-200,-300,160x160) AUTO",+ "lineType": "ELBOWED",+ "start": {+ "box": [+ 0,+ 0,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "end": {+ "box": [+ -200,+ -300,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "vertices": [+ [+ 80,+ -8+ ],+ [+ 80,+ -48+ ],+ [+ 352,+ -48+ ],+ [+ 352,+ -92+ ],+ [+ -120,+ -92+ ],+ [+ -120,+ -131.5+ ]+ ],+ "segments": [+ [+ 0,+ 1,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 1,+ 2,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 2,+ 3,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 3,+ 4,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 4,+ 5,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ]+ ],+ "controls": [+ {+ "position": [+ 352,+ 240+ ],+ "axis": [+ 0,+ 1+ ]+ }+ ],+ "curve": []+ },+ {+ "name": "mid B(100,250,160x160) AUTO",+ "lineType": "ELBOWED",+ "start": {+ "box": [+ 0,+ 0,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "end": {+ "box": [+ 100,+ 250,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "vertices": [+ [+ 80,+ 168+ ],+ [+ 80,+ 208+ ],+ [+ 352,+ 208+ ],+ [+ 352,+ 202+ ],+ [+ 180,+ 202+ ],+ [+ 180,+ 241.5+ ]+ ],+ "segments": [+ [+ 0,+ 1,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 1,+ 2,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 2,+ 3,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 3,+ 4,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 4,+ 5,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ]+ ],+ "controls": [+ {+ "position": [+ 352,+ 240+ ],+ "axis": [+ 0,+ 1+ ]+ }+ ],+ "curve": []+ },+ {+ "name": "mid B(360,120,160x160) AUTO",+ "lineType": "ELBOWED",+ "start": {+ "box": [+ 0,+ 0,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "end": {+ "box": [+ 360,+ 120,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "vertices": [+ [+ 168,+ 80+ ],+ [+ 352,+ 80+ ],+ [+ 352,+ 200+ ],+ [+ 360,+ 200+ ]+ ],+ "segments": [+ [+ 0,+ 1,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 1,+ 2,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 2,+ 3,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ]+ ],+ "controls": [+ {+ "position": [+ 352,+ 240+ ],+ "axis": [+ 0,+ 1+ ]+ }+ ],+ "curve": []+ },+ {+ "name": "mid B(480,320,160x160) TOP",+ "lineType": "ELBOWED",+ "start": {+ "box": [+ 0,+ 0,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "end": {+ "box": [+ 480,+ 320,+ 160,+ 160+ ],+ "magnet": "TOP",+ "outline": 2+ },+ "vertices": [+ [+ 168,+ 80+ ],+ [+ 352,+ 80+ ],+ [+ 352,+ 272+ ],+ [+ 560,+ 272+ ],+ [+ 560,+ 311.5+ ]+ ],+ "segments": [+ [+ 0,+ 1,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 1,+ 2,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 2,+ 3,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 3,+ 4,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ]+ ],+ "controls": [+ {+ "position": [+ 352,+ 240+ ],+ "axis": [+ 0,+ 1+ ]+ }+ ],+ "curve": []+ },+ {+ "name": "mid B(-300,200,160x160) TOP",+ "lineType": "ELBOWED",+ "start": {+ "box": [+ 0,+ 0,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "end": {+ "box": [+ -300,+ 200,+ 160,+ 160+ ],+ "magnet": "TOP",+ "outline": 2+ },+ "vertices": [+ [+ 8,+ 80+ ],+ [+ 352,+ 80+ ],+ [+ 352,+ 152+ ],+ [+ -220,+ 152+ ],+ [+ -220,+ 191.5+ ]+ ],+ "segments": [+ [+ 0,+ 1,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 1,+ 2,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 2,+ 3,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 3,+ 4,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ]+ ],+ "controls": [+ {+ "position": [+ 352,+ 240+ ],+ "axis": [+ 0,+ 1+ ]+ }+ ],+ "curve": []+ },+ {+ "name": "mid B(480,320,160x160) RIGHT",+ "lineType": "ELBOWED",+ "start": {+ "box": [+ 0,+ 0,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "end": {+ "box": [+ 480,+ 320,+ 160,+ 160+ ],+ "magnet": "RIGHT",+ "outline": 2+ },+ "vertices": [+ [+ 168,+ 80+ ],+ [+ 352,+ 80+ ],+ [+ 352,+ 400+ ],+ [+ 631.5,+ 400+ ]+ ],+ "segments": [+ [+ 0,+ 1,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 1,+ 2,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 2,+ 3,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ]+ ],+ "controls": [+ {+ "position": [+ 352,+ 240+ ],+ "axis": [+ 0,+ 1+ ]+ }+ ],+ "curve": []+ },+ {+ "name": "mid B(-300,200,160x160) RIGHT",+ "lineType": "ELBOWED",+ "start": {+ "box": [+ 0,+ 0,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "end": {+ "box": [+ -300,+ 200,+ 160,+ 160+ ],+ "magnet": "RIGHT",+ "outline": 2+ },+ "vertices": [+ [+ 8,+ 80+ ],+ [+ 352,+ 80+ ],+ [+ 352,+ 280+ ],+ [+ -131.5,+ 280+ ]+ ],+ "segments": [+ [+ 0,+ 1,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 1,+ 2,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 2,+ 3,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ]+ ],+ "controls": [+ {+ "position": [+ 352,+ 240+ ],+ "axis": [+ 0,+ 1+ ]+ }+ ],+ "curve": []+ },+ {+ "name": "mid B(480,320,160x160) BOTTOM",+ "lineType": "ELBOWED",+ "start": {+ "box": [+ 0,+ 0,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "end": {+ "box": [+ 480,+ 320,+ 160,+ 160+ ],+ "magnet": "BOTTOM",+ "outline": 2+ },+ "vertices": [+ [+ 168,+ 80+ ],+ [+ 352,+ 80+ ],+ [+ 352,+ 528+ ],+ [+ 560,+ 528+ ],+ [+ 560,+ 488.5+ ]+ ],+ "segments": [+ [+ 0,+ 1,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 1,+ 2,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 2,+ 3,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 3,+ 4,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ]+ ],+ "controls": [+ {+ "position": [+ 352,+ 240+ ],+ "axis": [+ 0,+ 1+ ]+ }+ ],+ "curve": []+ },+ {+ "name": "mid B(-300,200,160x160) BOTTOM",+ "lineType": "ELBOWED",+ "start": {+ "box": [+ 0,+ 0,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "end": {+ "box": [+ -300,+ 200,+ 160,+ 160+ ],+ "magnet": "BOTTOM",+ "outline": 2+ },+ "vertices": [+ [+ 8,+ 80+ ],+ [+ 352,+ 80+ ],+ [+ 352,+ 408+ ],+ [+ -220,+ 408+ ],+ [+ -220,+ 368.5+ ]+ ],+ "segments": [+ [+ 0,+ 1,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 1,+ 2,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 2,+ 3,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 3,+ 4,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ]+ ],+ "controls": [+ {+ "position": [+ 352,+ 240+ ],+ "axis": [+ 0,+ 1+ ]+ }+ ],+ "curve": []+ },+ {+ "name": "mid B(480,320,160x160) LEFT",+ "lineType": "ELBOWED",+ "start": {+ "box": [+ 0,+ 0,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "end": {+ "box": [+ 480,+ 320,+ 160,+ 160+ ],+ "magnet": "LEFT",+ "outline": 2+ },+ "vertices": [+ [+ 168,+ 80+ ],+ [+ 352,+ 80+ ],+ [+ 352,+ 400+ ],+ [+ 471.5,+ 400+ ]+ ],+ "segments": [+ [+ 0,+ 1,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 1,+ 2,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 2,+ 3,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ]+ ],+ "controls": [+ {+ "position": [+ 352,+ 240+ ],+ "axis": [+ 0,+ 1+ ]+ }+ ],+ "curve": []+ },+ {+ "name": "mid B(-300,200,160x160) LEFT",+ "lineType": "ELBOWED",+ "start": {+ "box": [+ 0,+ 0,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "end": {+ "box": [+ -300,+ 200,+ 160,+ 160+ ],+ "magnet": "LEFT",+ "outline": 2+ },+ "vertices": [+ [+ 8,+ 80+ ],+ [+ 352,+ 80+ ],+ [+ 352,+ 280+ ],+ [+ -291.5,+ 280+ ]+ ],+ "segments": [+ [+ 0,+ 1,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 1,+ 2,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 2,+ 3,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ]+ ],+ "controls": [+ {+ "position": [+ 352,+ 240+ ],+ "axis": [+ 0,+ 1+ ]+ }+ ],+ "curve": []+ },+ {+ "name": "mid B(480,320,320x96) AUTO",+ "lineType": "ELBOWED",+ "start": {+ "box": [+ 0,+ 0,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "end": {+ "box": [+ 480,+ 320,+ 320,+ 96+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "vertices": [+ [+ 168,+ 80+ ],+ [+ 352,+ 80+ ],+ [+ 352,+ 368+ ],+ [+ 471.5,+ 368+ ]+ ],+ "segments": [+ [+ 0,+ 1,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 1,+ 2,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 2,+ 3,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ]+ ],+ "controls": [+ {+ "position": [+ 352,+ 240+ ],+ "axis": [+ 0,+ 1+ ]+ }+ ],+ "curve": []+ },+ {+ "name": "mid B(400,-100,96x320) AUTO",+ "lineType": "ELBOWED",+ "start": {+ "box": [+ 0,+ 0,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "end": {+ "box": [+ 400,+ -100,+ 96,+ 320+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "vertices": [+ [+ 168,+ 80+ ],+ [+ 352,+ 80+ ],+ [+ 352,+ 60+ ],+ [+ 391.5,+ 60+ ]+ ],+ "segments": [+ [+ 0,+ 1,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 1,+ 2,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 2,+ 3,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ]+ ],+ "controls": [+ {+ "position": [+ 352,+ 240+ ],+ "axis": [+ 0,+ 1+ ]+ }+ ],+ "curve": []+ },+ {+ "name": "stub B(480,320,160x160) AUTO",+ "lineType": "ELBOWED",+ "start": {+ "box": [+ 0,+ 0,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "end": {+ "box": [+ 480,+ 320,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "vertices": [+ [+ 168,+ 80+ ],+ [+ 208,+ 80+ ],+ [+ 208,+ 16+ ],+ [+ 320,+ 16+ ],+ [+ 320,+ 400+ ],+ [+ 471.5,+ 400+ ]+ ],+ "segments": [+ [+ 0,+ 1,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 1,+ 2,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 2,+ 3,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 3,+ 4,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 4,+ 5,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ]+ ],+ "controls": [+ {+ "position": [+ 208,+ 48+ ],+ "axis": [+ 0,+ 1+ ]+ },+ {+ "position": [+ 264,+ 16+ ],+ "axis": [+ 1,+ 0+ ]+ },+ {+ "position": [+ 320,+ 208+ ],+ "axis": [+ 0,+ 1+ ]+ }+ ],+ "curve": []+ },+ {+ "name": "stub B(480,400,160x160) AUTO",+ "lineType": "ELBOWED",+ "start": {+ "box": [+ 0,+ 0,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "end": {+ "box": [+ 480,+ 400,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "vertices": [+ [+ 168,+ 80+ ],+ [+ 208,+ 80+ ],+ [+ 208,+ 16+ ],+ [+ 320,+ 16+ ],+ [+ 320,+ 352+ ],+ [+ 560,+ 352+ ],+ [+ 560,+ 391.5+ ]+ ],+ "segments": [+ [+ 0,+ 1,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 1,+ 2,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 2,+ 3,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 3,+ 4,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 4,+ 5,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 5,+ 6,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ]+ ],+ "controls": [+ {+ "position": [+ 208,+ 48+ ],+ "axis": [+ 0,+ 1+ ]+ },+ {+ "position": [+ 264,+ 16+ ],+ "axis": [+ 1,+ 0+ ]+ },+ {+ "position": [+ 320,+ 208+ ],+ "axis": [+ 0,+ 1+ ]+ }+ ],+ "curve": []+ },+ {+ "name": "stub B(560,320,160x160) AUTO",+ "lineType": "ELBOWED",+ "start": {+ "box": [+ 0,+ 0,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "end": {+ "box": [+ 560,+ 320,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "vertices": [+ [+ 168,+ 80+ ],+ [+ 208,+ 80+ ],+ [+ 208,+ 16+ ],+ [+ 320,+ 16+ ],+ [+ 320,+ 400+ ],+ [+ 551.5,+ 400+ ]+ ],+ "segments": [+ [+ 0,+ 1,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 1,+ 2,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 2,+ 3,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 3,+ 4,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 4,+ 5,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ]+ ],+ "controls": [+ {+ "position": [+ 208,+ 48+ ],+ "axis": [+ 0,+ 1+ ]+ },+ {+ "position": [+ 264,+ 16+ ],+ "axis": [+ 1,+ 0+ ]+ },+ {+ "position": [+ 320,+ 208+ ],+ "axis": [+ 0,+ 1+ ]+ }+ ],+ "curve": []+ },+ {+ "name": "stub B(300,320,160x160) AUTO",+ "lineType": "ELBOWED",+ "start": {+ "box": [+ 0,+ 0,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "end": {+ "box": [+ 300,+ 320,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "vertices": [+ [+ 168,+ 80+ ],+ [+ 208,+ 80+ ],+ [+ 208,+ 16+ ],+ [+ 320,+ 16+ ],+ [+ 320,+ 272+ ],+ [+ 380,+ 272+ ],+ [+ 380,+ 311.5+ ]+ ],+ "segments": [+ [+ 0,+ 1,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 1,+ 2,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 2,+ 3,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 3,+ 4,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 4,+ 5,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 5,+ 6,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ]+ ],+ "controls": [+ {+ "position": [+ 208,+ 48+ ],+ "axis": [+ 0,+ 1+ ]+ },+ {+ "position": [+ 264,+ 16+ ],+ "axis": [+ 1,+ 0+ ]+ },+ {+ "position": [+ 320,+ 208+ ],+ "axis": [+ 0,+ 1+ ]+ }+ ],+ "curve": []+ },+ {+ "name": "stub B(0,400,160x160) AUTO",+ "lineType": "ELBOWED",+ "start": {+ "box": [+ 0,+ 0,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "end": {+ "box": [+ 0,+ 400,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "vertices": [+ [+ 80,+ 168+ ],+ [+ 80,+ 208+ ],+ [+ 208,+ 208+ ],+ [+ 208,+ 16+ ],+ [+ 320,+ 16+ ],+ [+ 320,+ 352+ ],+ [+ 80,+ 352+ ],+ [+ 80,+ 391.5+ ]+ ],+ "segments": [+ [+ 0,+ 1,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 1,+ 2,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 2,+ 3,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 3,+ 4,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 4,+ 5,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 5,+ 6,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 6,+ 7,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ]+ ],+ "controls": [+ {+ "position": [+ 208,+ 48+ ],+ "axis": [+ 0,+ 1+ ]+ },+ {+ "position": [+ 264,+ 16+ ],+ "axis": [+ 1,+ 0+ ]+ },+ {+ "position": [+ 320,+ 208+ ],+ "axis": [+ 0,+ 1+ ]+ }+ ],+ "curve": []+ },+ {+ "name": "stub B(-300,0,160x160) AUTO",+ "lineType": "ELBOWED",+ "start": {+ "box": [+ 0,+ 0,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "end": {+ "box": [+ -300,+ 0,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "vertices": [+ [+ 8,+ 80+ ],+ [+ 208,+ 80+ ],+ [+ 208,+ 16+ ],+ [+ 320,+ 16+ ],+ [+ 320,+ 80+ ],+ [+ -131.5,+ 80+ ]+ ],+ "segments": [+ [+ 0,+ 1,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 1,+ 2,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 2,+ 3,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 3,+ 4,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 4,+ 5,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ]+ ],+ "controls": [+ {+ "position": [+ 208,+ 48+ ],+ "axis": [+ 0,+ 1+ ]+ },+ {+ "position": [+ 264,+ 16+ ],+ "axis": [+ 1,+ 0+ ]+ },+ {+ "position": [+ 320,+ 208+ ],+ "axis": [+ 0,+ 1+ ]+ }+ ],+ "curve": []+ },+ {+ "name": "stub B(-400,320,160x160) AUTO",+ "lineType": "ELBOWED",+ "start": {+ "box": [+ 0,+ 0,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "end": {+ "box": [+ -400,+ 320,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "vertices": [+ [+ 80,+ 168+ ],+ [+ 80,+ 208+ ],+ [+ 208,+ 208+ ],+ [+ 208,+ 16+ ],+ [+ 320,+ 16+ ],+ [+ 320,+ 400+ ],+ [+ -231.5,+ 400+ ]+ ],+ "segments": [+ [+ 0,+ 1,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 1,+ 2,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 2,+ 3,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 3,+ 4,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 4,+ 5,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 5,+ 6,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ]+ ],+ "controls": [+ {+ "position": [+ 208,+ 48+ ],+ "axis": [+ 0,+ 1+ ]+ },+ {+ "position": [+ 264,+ 16+ ],+ "axis": [+ 1,+ 0+ ]+ },+ {+ "position": [+ 320,+ 208+ ],+ "axis": [+ 0,+ 1+ ]+ }+ ],+ "curve": []+ },+ {+ "name": "stub B(480,0,160x160) AUTO",+ "lineType": "ELBOWED",+ "start": {+ "box": [+ 0,+ 0,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "end": {+ "box": [+ 480,+ 0,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "vertices": [+ [+ 168,+ 80+ ],+ [+ 208,+ 80+ ],+ [+ 208,+ 16+ ],+ [+ 320,+ 16+ ],+ [+ 320,+ 80+ ],+ [+ 471.5,+ 80+ ]+ ],+ "segments": [+ [+ 0,+ 1,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 1,+ 2,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 2,+ 3,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 3,+ 4,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 4,+ 5,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ]+ ],+ "controls": [+ {+ "position": [+ 208,+ 48+ ],+ "axis": [+ 0,+ 1+ ]+ },+ {+ "position": [+ 264,+ 16+ ],+ "axis": [+ 1,+ 0+ ]+ },+ {+ "position": [+ 320,+ 208+ ],+ "axis": [+ 0,+ 1+ ]+ }+ ],+ "curve": []+ },+ {+ "name": "stub B(480,8,160x160) AUTO",+ "lineType": "ELBOWED",+ "start": {+ "box": [+ 0,+ 0,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "end": {+ "box": [+ 480,+ 8,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "vertices": [+ [+ 168,+ 80+ ],+ [+ 208,+ 80+ ],+ [+ 208,+ 16+ ],+ [+ 320,+ 16+ ],+ [+ 320,+ 88+ ],+ [+ 471.5,+ 88+ ]+ ],+ "segments": [+ [+ 0,+ 1,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 1,+ 2,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 2,+ 3,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 3,+ 4,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 4,+ 5,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ]+ ],+ "controls": [+ {+ "position": [+ 208,+ 48+ ],+ "axis": [+ 0,+ 1+ ]+ },+ {+ "position": [+ 264,+ 16+ ],+ "axis": [+ 1,+ 0+ ]+ },+ {+ "position": [+ 320,+ 208+ ],+ "axis": [+ 0,+ 1+ ]+ }+ ],+ "curve": []+ },+ {+ "name": "stub B(480,40,160x160) AUTO",+ "lineType": "ELBOWED",+ "start": {+ "box": [+ 0,+ 0,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "end": {+ "box": [+ 480,+ 40,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "vertices": [+ [+ 168,+ 80+ ],+ [+ 208,+ 80+ ],+ [+ 208,+ 16+ ],+ [+ 320,+ 16+ ],+ [+ 320,+ 120+ ],+ [+ 471.5,+ 120+ ]+ ],+ "segments": [+ [+ 0,+ 1,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 1,+ 2,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 2,+ 3,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 3,+ 4,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 4,+ 5,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ]+ ],+ "controls": [+ {+ "position": [+ 208,+ 48+ ],+ "axis": [+ 0,+ 1+ ]+ },+ {+ "position": [+ 264,+ 16+ ],+ "axis": [+ 1,+ 0+ ]+ },+ {+ "position": [+ 320,+ 208+ ],+ "axis": [+ 0,+ 1+ ]+ }+ ],+ "curve": []+ },+ {+ "name": "stub B(480,-40,160x160) AUTO",+ "lineType": "ELBOWED",+ "start": {+ "box": [+ 0,+ 0,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "end": {+ "box": [+ 480,+ -40,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "vertices": [+ [+ 168,+ 80+ ],+ [+ 208,+ 80+ ],+ [+ 208,+ 16+ ],+ [+ 320,+ 16+ ],+ [+ 320,+ 40+ ],+ [+ 471.5,+ 40+ ]+ ],+ "segments": [+ [+ 0,+ 1,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 1,+ 2,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 2,+ 3,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 3,+ 4,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 4,+ 5,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ]+ ],+ "controls": [+ {+ "position": [+ 208,+ 48+ ],+ "axis": [+ 0,+ 1+ ]+ },+ {+ "position": [+ 264,+ 16+ ],+ "axis": [+ 1,+ 0+ ]+ },+ {+ "position": [+ 320,+ 208+ ],+ "axis": [+ 0,+ 1+ ]+ }+ ],+ "curve": []+ },+ {+ "name": "stub B(480,-300,160x160) AUTO",+ "lineType": "ELBOWED",+ "start": {+ "box": [+ 0,+ 0,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "end": {+ "box": [+ 480,+ -300,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "vertices": [+ [+ 168,+ 80+ ],+ [+ 208,+ 80+ ],+ [+ 208,+ 16+ ],+ [+ 320,+ 16+ ],+ [+ 320,+ -220+ ],+ [+ 471.5,+ -220+ ]+ ],+ "segments": [+ [+ 0,+ 1,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 1,+ 2,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 2,+ 3,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 3,+ 4,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 4,+ 5,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ]+ ],+ "controls": [+ {+ "position": [+ 208,+ 48+ ],+ "axis": [+ 0,+ 1+ ]+ },+ {+ "position": [+ 264,+ 16+ ],+ "axis": [+ 1,+ 0+ ]+ },+ {+ "position": [+ 320,+ 208+ ],+ "axis": [+ 0,+ 1+ ]+ }+ ],+ "curve": []+ },+ {+ "name": "stub B(800,0,160x160) AUTO",+ "lineType": "ELBOWED",+ "start": {+ "box": [+ 0,+ 0,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "end": {+ "box": [+ 800,+ 0,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "vertices": [+ [+ 168,+ 80+ ],+ [+ 208,+ 80+ ],+ [+ 208,+ 16+ ],+ [+ 320,+ 16+ ],+ [+ 320,+ 80+ ],+ [+ 791.5,+ 80+ ]+ ],+ "segments": [+ [+ 0,+ 1,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 1,+ 2,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 2,+ 3,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 3,+ 4,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 4,+ 5,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ]+ ],+ "controls": [+ {+ "position": [+ 208,+ 48+ ],+ "axis": [+ 0,+ 1+ ]+ },+ {+ "position": [+ 264,+ 16+ ],+ "axis": [+ 1,+ 0+ ]+ },+ {+ "position": [+ 320,+ 208+ ],+ "axis": [+ 0,+ 1+ ]+ }+ ],+ "curve": []+ },+ {+ "name": "stub B(200,-400,160x160) AUTO",+ "lineType": "ELBOWED",+ "start": {+ "box": [+ 0,+ 0,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "end": {+ "box": [+ 200,+ -400,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "vertices": [+ [+ 80,+ -8+ ],+ [+ 80,+ -48+ ],+ [+ 208,+ -48+ ],+ [+ 208,+ 16+ ],+ [+ 320,+ 16+ ],+ [+ 320,+ -192+ ],+ [+ 280,+ -192+ ],+ [+ 280,+ -231.5+ ]+ ],+ "segments": [+ [+ 0,+ 1,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 1,+ 2,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 2,+ 3,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 3,+ 4,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 4,+ 5,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 5,+ 6,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 6,+ 7,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ]+ ],+ "controls": [+ {+ "position": [+ 208,+ 48+ ],+ "axis": [+ 0,+ 1+ ]+ },+ {+ "position": [+ 264,+ 16+ ],+ "axis": [+ 1,+ 0+ ]+ },+ {+ "position": [+ 320,+ 208+ ],+ "axis": [+ 0,+ 1+ ]+ }+ ],+ "curve": []+ },+ {+ "name": "stub B(-200,-300,160x160) AUTO",+ "lineType": "ELBOWED",+ "start": {+ "box": [+ 0,+ 0,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "end": {+ "box": [+ -200,+ -300,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "vertices": [+ [+ 80,+ -8+ ],+ [+ 80,+ -48+ ],+ [+ 208,+ -48+ ],+ [+ 208,+ 16+ ],+ [+ 320,+ 16+ ],+ [+ 320,+ -92+ ],+ [+ -120,+ -92+ ],+ [+ -120,+ -131.5+ ]+ ],+ "segments": [+ [+ 0,+ 1,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 1,+ 2,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 2,+ 3,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 3,+ 4,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 4,+ 5,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 5,+ 6,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 6,+ 7,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ]+ ],+ "controls": [+ {+ "position": [+ 208,+ 48+ ],+ "axis": [+ 0,+ 1+ ]+ },+ {+ "position": [+ 264,+ 16+ ],+ "axis": [+ 1,+ 0+ ]+ },+ {+ "position": [+ 320,+ 208+ ],+ "axis": [+ 0,+ 1+ ]+ }+ ],+ "curve": []+ },+ {+ "name": "stub B(100,250,160x160) AUTO",+ "lineType": "ELBOWED",+ "start": {+ "box": [+ 0,+ 0,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "end": {+ "box": [+ 100,+ 250,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "vertices": [+ [+ 80,+ 168+ ],+ [+ 80,+ 208+ ],+ [+ 208,+ 208+ ],+ [+ 208,+ 16+ ],+ [+ 320,+ 16+ ],+ [+ 320,+ 202+ ],+ [+ 180,+ 202+ ],+ [+ 180,+ 241.5+ ]+ ],+ "segments": [+ [+ 0,+ 1,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 1,+ 2,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 2,+ 3,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 3,+ 4,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 4,+ 5,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 5,+ 6,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 6,+ 7,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ]+ ],+ "controls": [+ {+ "position": [+ 208,+ 48+ ],+ "axis": [+ 0,+ 1+ ]+ },+ {+ "position": [+ 264,+ 16+ ],+ "axis": [+ 1,+ 0+ ]+ },+ {+ "position": [+ 320,+ 208+ ],+ "axis": [+ 0,+ 1+ ]+ }+ ],+ "curve": []+ },+ {+ "name": "stub B(360,120,160x160) AUTO",+ "lineType": "ELBOWED",+ "start": {+ "box": [+ 0,+ 0,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "end": {+ "box": [+ 360,+ 120,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "vertices": [+ [+ 168,+ 80+ ],+ [+ 208,+ 80+ ],+ [+ 208,+ 16+ ],+ [+ 320,+ 16+ ],+ [+ 320,+ 200+ ],+ [+ 351.5,+ 200+ ]+ ],+ "segments": [+ [+ 0,+ 1,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 1,+ 2,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 2,+ 3,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 3,+ 4,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 4,+ 5,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ]+ ],+ "controls": [+ {+ "position": [+ 208,+ 48+ ],+ "axis": [+ 0,+ 1+ ]+ },+ {+ "position": [+ 264,+ 16+ ],+ "axis": [+ 1,+ 0+ ]+ },+ {+ "position": [+ 320,+ 208+ ],+ "axis": [+ 0,+ 1+ ]+ }+ ],+ "curve": []+ },+ {+ "name": "stub B(480,320,160x160) TOP",+ "lineType": "ELBOWED",+ "start": {+ "box": [+ 0,+ 0,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "end": {+ "box": [+ 480,+ 320,+ 160,+ 160+ ],+ "magnet": "TOP",+ "outline": 2+ },+ "vertices": [+ [+ 168,+ 80+ ],+ [+ 208,+ 80+ ],+ [+ 208,+ 16+ ],+ [+ 320,+ 16+ ],+ [+ 320,+ 272+ ],+ [+ 560,+ 272+ ],+ [+ 560,+ 311.5+ ]+ ],+ "segments": [+ [+ 0,+ 1,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 1,+ 2,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 2,+ 3,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 3,+ 4,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 4,+ 5,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 5,+ 6,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ]+ ],+ "controls": [+ {+ "position": [+ 208,+ 48+ ],+ "axis": [+ 0,+ 1+ ]+ },+ {+ "position": [+ 264,+ 16+ ],+ "axis": [+ 1,+ 0+ ]+ },+ {+ "position": [+ 320,+ 208+ ],+ "axis": [+ 0,+ 1+ ]+ }+ ],+ "curve": []+ },+ {+ "name": "stub B(-300,200,160x160) TOP",+ "lineType": "ELBOWED",+ "start": {+ "box": [+ 0,+ 0,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "end": {+ "box": [+ -300,+ 200,+ 160,+ 160+ ],+ "magnet": "TOP",+ "outline": 2+ },+ "vertices": [+ [+ 8,+ 80+ ],+ [+ 208,+ 80+ ],+ [+ 208,+ 16+ ],+ [+ 320,+ 16+ ],+ [+ 320,+ 152+ ],+ [+ -220,+ 152+ ],+ [+ -220,+ 191.5+ ]+ ],+ "segments": [+ [+ 0,+ 1,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 1,+ 2,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 2,+ 3,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 3,+ 4,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 4,+ 5,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 5,+ 6,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ]+ ],+ "controls": [+ {+ "position": [+ 208,+ 48+ ],+ "axis": [+ 0,+ 1+ ]+ },+ {+ "position": [+ 264,+ 16+ ],+ "axis": [+ 1,+ 0+ ]+ },+ {+ "position": [+ 320,+ 208+ ],+ "axis": [+ 0,+ 1+ ]+ }+ ],+ "curve": []+ },+ {+ "name": "stub B(480,320,160x160) RIGHT",+ "lineType": "ELBOWED",+ "start": {+ "box": [+ 0,+ 0,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "end": {+ "box": [+ 480,+ 320,+ 160,+ 160+ ],+ "magnet": "RIGHT",+ "outline": 2+ },+ "vertices": [+ [+ 168,+ 80+ ],+ [+ 208,+ 80+ ],+ [+ 208,+ 16+ ],+ [+ 320,+ 16+ ],+ [+ 320,+ 400+ ],+ [+ 631.5,+ 400+ ]+ ],+ "segments": [+ [+ 0,+ 1,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 1,+ 2,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 2,+ 3,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 3,+ 4,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 4,+ 5,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ]+ ],+ "controls": [+ {+ "position": [+ 208,+ 48+ ],+ "axis": [+ 0,+ 1+ ]+ },+ {+ "position": [+ 264,+ 16+ ],+ "axis": [+ 1,+ 0+ ]+ },+ {+ "position": [+ 320,+ 208+ ],+ "axis": [+ 0,+ 1+ ]+ }+ ],+ "curve": []+ },+ {+ "name": "stub B(-300,200,160x160) RIGHT",+ "lineType": "ELBOWED",+ "start": {+ "box": [+ 0,+ 0,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "end": {+ "box": [+ -300,+ 200,+ 160,+ 160+ ],+ "magnet": "RIGHT",+ "outline": 2+ },+ "vertices": [+ [+ 8,+ 80+ ],+ [+ 208,+ 80+ ],+ [+ 208,+ 16+ ],+ [+ 320,+ 16+ ],+ [+ 320,+ 280+ ],+ [+ -131.5,+ 280+ ]+ ],+ "segments": [+ [+ 0,+ 1,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 1,+ 2,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 2,+ 3,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 3,+ 4,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 4,+ 5,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ]+ ],+ "controls": [+ {+ "position": [+ 208,+ 48+ ],+ "axis": [+ 0,+ 1+ ]+ },+ {+ "position": [+ 264,+ 16+ ],+ "axis": [+ 1,+ 0+ ]+ },+ {+ "position": [+ 320,+ 208+ ],+ "axis": [+ 0,+ 1+ ]+ }+ ],+ "curve": []+ },+ {+ "name": "stub B(480,320,160x160) BOTTOM",+ "lineType": "ELBOWED",+ "start": {+ "box": [+ 0,+ 0,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "end": {+ "box": [+ 480,+ 320,+ 160,+ 160+ ],+ "magnet": "BOTTOM",+ "outline": 2+ },+ "vertices": [+ [+ 168,+ 80+ ],+ [+ 208,+ 80+ ],+ [+ 208,+ 16+ ],+ [+ 320,+ 16+ ],+ [+ 320,+ 528+ ],+ [+ 560,+ 528+ ],+ [+ 560,+ 488.5+ ]+ ],+ "segments": [+ [+ 0,+ 1,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 1,+ 2,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 2,+ 3,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 3,+ 4,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 4,+ 5,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 5,+ 6,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ]+ ],+ "controls": [+ {+ "position": [+ 208,+ 48+ ],+ "axis": [+ 0,+ 1+ ]+ },+ {+ "position": [+ 264,+ 16+ ],+ "axis": [+ 1,+ 0+ ]+ },+ {+ "position": [+ 320,+ 208+ ],+ "axis": [+ 0,+ 1+ ]+ }+ ],+ "curve": []+ },+ {+ "name": "stub B(-300,200,160x160) BOTTOM",+ "lineType": "ELBOWED",+ "start": {+ "box": [+ 0,+ 0,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "end": {+ "box": [+ -300,+ 200,+ 160,+ 160+ ],+ "magnet": "BOTTOM",+ "outline": 2+ },+ "vertices": [+ [+ 8,+ 80+ ],+ [+ 208,+ 80+ ],+ [+ 208,+ 16+ ],+ [+ 320,+ 16+ ],+ [+ 320,+ 408+ ],+ [+ -220,+ 408+ ],+ [+ -220,+ 368.5+ ]+ ],+ "segments": [+ [+ 0,+ 1,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 1,+ 2,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 2,+ 3,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 3,+ 4,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 4,+ 5,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 5,+ 6,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ]+ ],+ "controls": [+ {+ "position": [+ 208,+ 48+ ],+ "axis": [+ 0,+ 1+ ]+ },+ {+ "position": [+ 264,+ 16+ ],+ "axis": [+ 1,+ 0+ ]+ },+ {+ "position": [+ 320,+ 208+ ],+ "axis": [+ 0,+ 1+ ]+ }+ ],+ "curve": []+ },+ {+ "name": "stub B(480,320,160x160) LEFT",+ "lineType": "ELBOWED",+ "start": {+ "box": [+ 0,+ 0,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "end": {+ "box": [+ 480,+ 320,+ 160,+ 160+ ],+ "magnet": "LEFT",+ "outline": 2+ },+ "vertices": [+ [+ 168,+ 80+ ],+ [+ 208,+ 80+ ],+ [+ 208,+ 16+ ],+ [+ 320,+ 16+ ],+ [+ 320,+ 400+ ],+ [+ 471.5,+ 400+ ]+ ],+ "segments": [+ [+ 0,+ 1,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 1,+ 2,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 2,+ 3,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 3,+ 4,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 4,+ 5,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ]+ ],+ "controls": [+ {+ "position": [+ 208,+ 48+ ],+ "axis": [+ 0,+ 1+ ]+ },+ {+ "position": [+ 264,+ 16+ ],+ "axis": [+ 1,+ 0+ ]+ },+ {+ "position": [+ 320,+ 208+ ],+ "axis": [+ 0,+ 1+ ]+ }+ ],+ "curve": []+ },+ {+ "name": "stub B(-300,200,160x160) LEFT",+ "lineType": "ELBOWED",+ "start": {+ "box": [+ 0,+ 0,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "end": {+ "box": [+ -300,+ 200,+ 160,+ 160+ ],+ "magnet": "LEFT",+ "outline": 2+ },+ "vertices": [+ [+ 8,+ 80+ ],+ [+ 208,+ 80+ ],+ [+ 208,+ 16+ ],+ [+ 320,+ 16+ ],+ [+ 320,+ 280+ ],+ [+ -291.5,+ 280+ ]+ ],+ "segments": [+ [+ 0,+ 1,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 1,+ 2,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 2,+ 3,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 3,+ 4,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 4,+ 5,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ]+ ],+ "controls": [+ {+ "position": [+ 208,+ 48+ ],+ "axis": [+ 0,+ 1+ ]+ },+ {+ "position": [+ 264,+ 16+ ],+ "axis": [+ 1,+ 0+ ]+ },+ {+ "position": [+ 320,+ 208+ ],+ "axis": [+ 0,+ 1+ ]+ }+ ],+ "curve": []+ },+ {+ "name": "stub B(480,320,320x96) AUTO",+ "lineType": "ELBOWED",+ "start": {+ "box": [+ 0,+ 0,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "end": {+ "box": [+ 480,+ 320,+ 320,+ 96+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "vertices": [+ [+ 168,+ 80+ ],+ [+ 208,+ 80+ ],+ [+ 208,+ 16+ ],+ [+ 320,+ 16+ ],+ [+ 320,+ 368+ ],+ [+ 471.5,+ 368+ ]+ ],+ "segments": [+ [+ 0,+ 1,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 1,+ 2,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 2,+ 3,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 3,+ 4,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 4,+ 5,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ]+ ],+ "controls": [+ {+ "position": [+ 208,+ 48+ ],+ "axis": [+ 0,+ 1+ ]+ },+ {+ "position": [+ 264,+ 16+ ],+ "axis": [+ 1,+ 0+ ]+ },+ {+ "position": [+ 320,+ 208+ ],+ "axis": [+ 0,+ 1+ ]+ }+ ],+ "curve": []+ },+ {+ "name": "stub B(400,-100,96x320) AUTO",+ "lineType": "ELBOWED",+ "start": {+ "box": [+ 0,+ 0,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "end": {+ "box": [+ 400,+ -100,+ 96,+ 320+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "vertices": [+ [+ 168,+ 80+ ],+ [+ 208,+ 80+ ],+ [+ 208,+ 16+ ],+ [+ 320,+ 16+ ],+ [+ 320,+ 60+ ],+ [+ 391.5,+ 60+ ]+ ],+ "segments": [+ [+ 0,+ 1,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 1,+ 2,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 2,+ 3,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 3,+ 4,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ],+ [+ 4,+ 5,+ [+ 0,+ 0+ ],+ [+ 0,+ 0+ ]+ ]+ ],+ "controls": [+ {+ "position": [+ 208,+ 48+ ],+ "axis": [+ 0,+ 1+ ]+ },+ {+ "position": [+ 264,+ 16+ ],+ "axis": [+ 1,+ 0+ ]+ },+ {+ "position": [+ 320,+ 208+ ],+ "axis": [+ 0,+ 1+ ]+ }+ ],+ "curve": []+ },+ {+ "name": "curve B(480,320,160x160) AUTO",+ "lineType": "CURVED",+ "start": {+ "box": [+ 0,+ 0,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "end": {+ "box": [+ 480,+ 320,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "vertices": [+ [+ 167.53,+ 77.31+ ],+ [+ 474.66,+ 393.38+ ]+ ],+ "segments": [+ [+ 0,+ 1,+ [+ 292.32,+ -104.33+ ],+ [+ -80.99,+ -100.4+ ]+ ]+ ],+ "controls": [],+ "curve": [+ [+ 459.85,+ -27.02+ ],+ [+ 393.68,+ 292.98+ ]+ ]+ },+ {+ "name": "curve B(480,400,160x160) AUTO",+ "lineType": "CURVED",+ "start": {+ "box": [+ 0,+ 0,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "end": {+ "box": [+ 480,+ 400,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "vertices": [+ [+ 167.53,+ 77.31+ ],+ [+ 552.85,+ 395.4+ ]+ ],+ "segments": [+ [+ 0,+ 1,+ [+ 292.32,+ -104.33+ ],+ [+ -159.18,+ -102.42+ ]+ ]+ ],+ "controls": [],+ "curve": [+ [+ 459.85,+ -27.02+ ],+ [+ 393.68,+ 292.98+ ]+ ]+ },+ {+ "name": "curve B(560,320,160x160) AUTO",+ "lineType": "CURVED",+ "start": {+ "box": [+ 0,+ 0,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "end": {+ "box": [+ 560,+ 320,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "vertices": [+ [+ 167.53,+ 77.31+ ],+ [+ 552.85,+ 395.4+ ]+ ],+ "segments": [+ [+ 0,+ 1,+ [+ 292.32,+ -104.33+ ],+ [+ -159.18,+ -102.42+ ]+ ]+ ],+ "controls": [],+ "curve": [+ [+ 459.85,+ -27.02+ ],+ [+ 393.68,+ 292.98+ ]+ ]+ },+ {+ "name": "curve B(300,320,160x160) AUTO",+ "lineType": "CURVED",+ "start": {+ "box": [+ 0,+ 0,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "end": {+ "box": [+ 300,+ 320,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "vertices": [+ [+ 167.53,+ 77.31+ ],+ [+ 383.84,+ 312.42+ ]+ ],+ "segments": [+ [+ 0,+ 1,+ [+ 292.32,+ -104.33+ ],+ [+ 9.84,+ -19.43+ ]+ ]+ ],+ "controls": [],+ "curve": [+ [+ 459.85,+ -27.02+ ],+ [+ 393.68,+ 292.98+ ]+ ]+ },+ {+ "name": "curve B(0,400,160x160) AUTO",+ "lineType": "CURVED",+ "start": {+ "box": [+ 0,+ 0,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "end": {+ "box": [+ 0,+ 400,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "vertices": [+ [+ 87.18,+ 156.47+ ],+ [+ 88.04,+ 397.26+ ]+ ],+ "segments": [+ [+ 0,+ 1,+ [+ 372.67,+ -183.48+ ],+ [+ 305.63,+ -104.27+ ]+ ]+ ],+ "controls": [],+ "curve": [+ [+ 459.85,+ -27.02+ ],+ [+ 393.68,+ 292.98+ ]+ ]+ },+ {+ "name": "curve B(-300,0,160x160) AUTO",+ "lineType": "CURVED",+ "start": {+ "box": [+ 0,+ 0,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "end": {+ "box": [+ -300,+ 0,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "vertices": [+ [+ 7.79,+ 78.19+ ],+ [+ -132.11,+ 83.15+ ]+ ],+ "segments": [+ [+ 0,+ 1,+ [+ 452.06,+ -105.2+ ],+ [+ 525.78,+ 209.83+ ]+ ]+ ],+ "controls": [],+ "curve": [+ [+ 459.85,+ -27.02+ ],+ [+ 393.68,+ 292.98+ ]+ ]+ },+ {+ "name": "curve B(-400,320,160x160) AUTO",+ "lineType": "CURVED",+ "start": {+ "box": [+ 0,+ 0,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "end": {+ "box": [+ -400,+ 320,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "vertices": [+ [+ 87.18,+ 156.47+ ],+ [+ -231.62,+ 398.58+ ]+ ],+ "segments": [+ [+ 0,+ 1,+ [+ 372.67,+ -183.48+ ],+ [+ 625.29,+ -105.6+ ]+ ]+ ],+ "controls": [],+ "curve": [+ [+ 459.85,+ -27.02+ ],+ [+ 393.68,+ 292.98+ ]+ ]+ },+ {+ "name": "curve B(480,0,160x160) AUTO",+ "lineType": "CURVED",+ "start": {+ "box": [+ 0,+ 0,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "end": {+ "box": [+ 480,+ 0,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "vertices": [+ [+ 167.53,+ 77.31+ ],+ [+ 476.81,+ 87.88+ ]+ ],+ "segments": [+ [+ 0,+ 1,+ [+ 292.32,+ -104.33+ ],+ [+ -83.13,+ 205.1+ ]+ ]+ ],+ "controls": [],+ "curve": [+ [+ 459.85,+ -27.02+ ],+ [+ 393.68,+ 292.98+ ]+ ]+ },+ {+ "name": "curve B(480,8,160x160) AUTO",+ "lineType": "CURVED",+ "start": {+ "box": [+ 0,+ 0,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "end": {+ "box": [+ 480,+ 8,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "vertices": [+ [+ 167.53,+ 77.31+ ],+ [+ 476.7,+ 95.83+ ]+ ],+ "segments": [+ [+ 0,+ 1,+ [+ 292.32,+ -104.33+ ],+ [+ -83.03,+ 197.15+ ]+ ]+ ],+ "controls": [],+ "curve": [+ [+ 459.85,+ -27.02+ ],+ [+ 393.68,+ 292.98+ ]+ ]+ },+ {+ "name": "curve B(480,40,160x160) AUTO",+ "lineType": "CURVED",+ "start": {+ "box": [+ 0,+ 0,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "end": {+ "box": [+ 480,+ 40,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "vertices": [+ [+ 167.53,+ 77.31+ ],+ [+ 476.2,+ 127.61+ ]+ ],+ "segments": [+ [+ 0,+ 1,+ [+ 292.32,+ -104.33+ ],+ [+ -82.53,+ 165.38+ ]+ ]+ ],+ "controls": [],+ "curve": [+ [+ 459.85,+ -27.02+ ],+ [+ 393.68,+ 292.98+ ]+ ]+ },+ {+ "name": "curve B(480,-40,160x160) AUTO",+ "lineType": "CURVED",+ "start": {+ "box": [+ 0,+ 0,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "end": {+ "box": [+ 480,+ -40,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "vertices": [+ [+ 167.53,+ 77.31+ ],+ [+ 477.25,+ 48.04+ ]+ ],+ "segments": [+ [+ 0,+ 1,+ [+ 292.32,+ -104.33+ ],+ [+ -83.58,+ 244.94+ ]+ ]+ ],+ "controls": [],+ "curve": [+ [+ 459.85,+ -27.02+ ],+ [+ 393.68,+ 292.98+ ]+ ]+ },+ {+ "name": "curve B(480,-300,160x160) AUTO",+ "lineType": "CURVED",+ "start": {+ "box": [+ 0,+ 0,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "end": {+ "box": [+ 480,+ -300,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "vertices": [+ [+ 167.53,+ 77.31+ ],+ [+ 478.59,+ -211.62+ ]+ ],+ "segments": [+ [+ 0,+ 1,+ [+ 292.32,+ -104.33+ ],+ [+ -84.91,+ 504.6+ ]+ ]+ ],+ "controls": [],+ "curve": [+ [+ 459.85,+ -27.02+ ],+ [+ 393.68,+ 292.98+ ]+ ]+ },+ {+ "name": "curve B(800,0,160x160) AUTO",+ "lineType": "CURVED",+ "start": {+ "box": [+ 0,+ 0,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "end": {+ "box": [+ 800,+ 0,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "vertices": [+ [+ 167.53,+ 77.31+ ],+ [+ 792.47,+ 83.95+ ]+ ],+ "segments": [+ [+ 0,+ 1,+ [+ 292.32,+ -104.33+ ],+ [+ -398.8,+ 209.04+ ]+ ]+ ],+ "controls": [],+ "curve": [+ [+ 459.85,+ -27.02+ ],+ [+ 393.68,+ 292.98+ ]+ ]+ },+ {+ "name": "curve B(200,-400,160x160) AUTO",+ "lineType": "CURVED",+ "start": {+ "box": [+ 0,+ 0,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "end": {+ "box": [+ 200,+ -400,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "vertices": [+ [+ 87.98,+ -0.57+ ],+ [+ 281.77,+ -231.69+ ]+ ],+ "segments": [+ [+ 0,+ 1,+ [+ 371.87,+ -26.45+ ],+ [+ 111.9,+ 524.67+ ]+ ]+ ],+ "controls": [],+ "curve": [+ [+ 459.85,+ -27.02+ ],+ [+ 393.68,+ 292.98+ ]+ ]+ },+ {+ "name": "curve B(-200,-300,160x160) AUTO",+ "lineType": "CURVED",+ "start": {+ "box": [+ 0,+ 0,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "end": {+ "box": [+ -200,+ -300,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "vertices": [+ [+ 87.98,+ -0.57+ ],+ [+ -113.5,+ -134.52+ ]+ ],+ "segments": [+ [+ 0,+ 1,+ [+ 371.87,+ -26.45+ ],+ [+ 507.18,+ 427.5+ ]+ ]+ ],+ "controls": [],+ "curve": [+ [+ 459.85,+ -27.02+ ],+ [+ 393.68,+ 292.98+ ]+ ]+ },+ {+ "name": "curve B(100,250,160x160) AUTO",+ "lineType": "CURVED",+ "start": {+ "box": [+ 0,+ 0,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "end": {+ "box": [+ 100,+ 250,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "vertices": [+ [+ 87.18,+ 156.47+ ],+ [+ 188.33,+ 251.68+ ]+ ],+ "segments": [+ [+ 0,+ 1,+ [+ 372.67,+ -183.48+ ],+ [+ 205.34,+ 41.31+ ]+ ]+ ],+ "controls": [],+ "curve": [+ [+ 459.85,+ -27.02+ ],+ [+ 393.68,+ 292.98+ ]+ ]+ },+ {+ "name": "curve B(360,120,160x160) AUTO",+ "lineType": "CURVED",+ "start": {+ "box": [+ 0,+ 0,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "end": {+ "box": [+ 360,+ 120,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "vertices": [+ [+ 167.53,+ 77.31+ ],+ [+ 362.89,+ 207.99+ ]+ ],+ "segments": [+ [+ 0,+ 1,+ [+ 292.32,+ -104.33+ ],+ [+ 30.78,+ 84.99+ ]+ ]+ ],+ "controls": [],+ "curve": [+ [+ 459.85,+ -27.02+ ],+ [+ 393.68,+ 292.98+ ]+ ]+ },+ {+ "name": "curve B(480,320,160x160) TOP",+ "lineType": "CURVED",+ "start": {+ "box": [+ 0,+ 0,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "end": {+ "box": [+ 480,+ 320,+ 160,+ 160+ ],+ "magnet": "TOP",+ "outline": 2+ },+ "vertices": [+ [+ 167.53,+ 77.31+ ],+ [+ 551.61,+ 318.64+ ]+ ],+ "segments": [+ [+ 0,+ 1,+ [+ 292.32,+ -104.33+ ],+ [+ -157.93,+ -25.65+ ]+ ]+ ],+ "controls": [],+ "curve": [+ [+ 459.85,+ -27.02+ ],+ [+ 393.68,+ 292.98+ ]+ ]+ },+ {+ "name": "curve B(-300,200,160x160) TOP",+ "lineType": "CURVED",+ "start": {+ "box": [+ 0,+ 0,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "end": {+ "box": [+ -300,+ 200,+ 160,+ 160+ ],+ "magnet": "TOP",+ "outline": 2+ },+ "vertices": [+ [+ 7.79,+ 78.19+ ],+ [+ -211.6,+ 201.27+ ]+ ],+ "segments": [+ [+ 0,+ 1,+ [+ 452.06,+ -105.2+ ],+ [+ 605.27,+ 91.71+ ]+ ]+ ],+ "controls": [],+ "curve": [+ [+ 459.85,+ -27.02+ ],+ [+ 393.68,+ 292.98+ ]+ ]+ },+ {+ "name": "curve B(480,320,160x160) RIGHT",+ "lineType": "CURVED",+ "start": {+ "box": [+ 0,+ 0,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "end": {+ "box": [+ 480,+ 320,+ 160,+ 160+ ],+ "magnet": "RIGHT",+ "outline": 2+ },+ "vertices": [+ [+ 167.53,+ 77.31+ ],+ [+ 632.2,+ 396.61+ ]+ ],+ "segments": [+ [+ 0,+ 1,+ [+ 292.32,+ -104.33+ ],+ [+ -238.53,+ -103.63+ ]+ ]+ ],+ "controls": [],+ "curve": [+ [+ 459.85,+ -27.02+ ],+ [+ 393.68,+ 292.98+ ]+ ]+ },+ {+ "name": "curve B(-300,200,160x160) RIGHT",+ "lineType": "CURVED",+ "start": {+ "box": [+ 0,+ 0,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "end": {+ "box": [+ -300,+ 200,+ 160,+ 160+ ],+ "magnet": "RIGHT",+ "outline": 2+ },+ "vertices": [+ [+ 7.79,+ 78.19+ ],+ [+ -131.5,+ 280.21+ ]+ ],+ "segments": [+ [+ 0,+ 1,+ [+ 452.06,+ -105.2+ ],+ [+ 525.18,+ 12.78+ ]+ ]+ ],+ "controls": [],+ "curve": [+ [+ 459.85,+ -27.02+ ],+ [+ 393.68,+ 292.98+ ]+ ]+ },+ {+ "name": "curve B(480,320,160x160) BOTTOM",+ "lineType": "CURVED",+ "start": {+ "box": [+ 0,+ 0,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "end": {+ "box": [+ 480,+ 320,+ 160,+ 160+ ],+ "magnet": "BOTTOM",+ "outline": 2+ },+ "vertices": [+ [+ 167.53,+ 77.31+ ],+ [+ 554.35,+ 473.65+ ]+ ],+ "segments": [+ [+ 0,+ 1,+ [+ 292.32,+ -104.33+ ],+ [+ -160.68,+ -180.67+ ]+ ]+ ],+ "controls": [],+ "curve": [+ [+ 459.85,+ -27.02+ ],+ [+ 393.68,+ 292.98+ ]+ ]+ },+ {+ "name": "curve B(-300,200,160x160) BOTTOM",+ "lineType": "CURVED",+ "start": {+ "box": [+ 0,+ 0,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "end": {+ "box": [+ -300,+ 200,+ 160,+ 160+ ],+ "magnet": "BOTTOM",+ "outline": 2+ },+ "vertices": [+ [+ 7.79,+ 78.19+ ],+ [+ -211.55,+ 359.08+ ]+ ],+ "segments": [+ [+ 0,+ 1,+ [+ 452.06,+ -105.2+ ],+ [+ 605.23,+ -66.09+ ]+ ]+ ],+ "controls": [],+ "curve": [+ [+ 459.85,+ -27.02+ ],+ [+ 393.68,+ 292.98+ ]+ ]+ },+ {+ "name": "curve B(480,320,160x160) LEFT",+ "lineType": "CURVED",+ "start": {+ "box": [+ 0,+ 0,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "end": {+ "box": [+ 480,+ 320,+ 160,+ 160+ ],+ "magnet": "LEFT",+ "outline": 2+ },+ "vertices": [+ [+ 167.53,+ 77.31+ ],+ [+ 474.66,+ 393.38+ ]+ ],+ "segments": [+ [+ 0,+ 1,+ [+ 292.32,+ -104.33+ ],+ [+ -80.99,+ -100.4+ ]+ ]+ ],+ "controls": [],+ "curve": [+ [+ 459.85,+ -27.02+ ],+ [+ 393.68,+ 292.98+ ]+ ]+ },+ {+ "name": "curve B(-300,200,160x160) LEFT",+ "lineType": "CURVED",+ "start": {+ "box": [+ 0,+ 0,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "end": {+ "box": [+ -300,+ 200,+ 160,+ 160+ ],+ "magnet": "LEFT",+ "outline": 2+ },+ "vertices": [+ [+ 7.79,+ 78.19+ ],+ [+ -291.5,+ 280.16+ ]+ ],+ "segments": [+ [+ 0,+ 1,+ [+ 452.06,+ -105.2+ ],+ [+ 685.18,+ 12.82+ ]+ ]+ ],+ "controls": [],+ "curve": [+ [+ 459.85,+ -27.02+ ],+ [+ 393.68,+ 292.98+ ]+ ]+ },+ {+ "name": "curve B(480,320,320x96) AUTO",+ "lineType": "CURVED",+ "start": {+ "box": [+ 0,+ 0,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "end": {+ "box": [+ 480,+ 320,+ 320,+ 96+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "vertices": [+ [+ 167.53,+ 77.31+ ],+ [+ 473.58,+ 362.42+ ]+ ],+ "segments": [+ [+ 0,+ 1,+ [+ 292.32,+ -104.33+ ],+ [+ -79.91,+ -69.44+ ]+ ]+ ],+ "controls": [],+ "curve": [+ [+ 459.85,+ -27.02+ ],+ [+ 393.68,+ 292.98+ ]+ ]+ },+ {+ "name": "curve B(400,-100,96x320) AUTO",+ "lineType": "CURVED",+ "start": {+ "box": [+ 0,+ 0,+ 160,+ 160+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "end": {+ "box": [+ 400,+ -100,+ 96,+ 320+ ],+ "magnet": "AUTO",+ "outline": 2+ },+ "vertices": [+ [+ 167.53,+ 77.31+ ],+ [+ 399.77,+ 68.5+ ]+ ],+ "segments": [+ [+ 0,+ 1,+ [+ 292.32,+ -104.33+ ],+ [+ -6.09,+ 224.49+ ]+ ]+ ],+ "controls": [],+ "curve": [+ [+ 459.85,+ -27.02+ ],+ [+ 393.68,+ 292.98+ ]+ ]+ }+]\ No newline at end of filediff --git a/packages/scene-graph/tests/connectors/label-position.test.ts b/packages/scene-graph/tests/connectors/label-position.test.tsnew file mode 100644index 000000000..cda23ed1d--- /dev/null+++ b/packages/scene-graph/tests/connectors/label-position.test.ts@@ -0,0 +1,106 @@+import { describe, expect, test } from 'bun:test'++import type { ConnectorLabelPosition } from '@open-pencil/scene-graph'+import {+ connectorLabelPositionAt,+ placeConnectorLabel,+ routeConnector,+ type ConnectorRouteEnd+} from '@open-pencil/scene-graph/connectors'++/**+ * Labels FigJam placed on 2026-10-23 after they were dragged, on connectors from a 160 px shape at+ * the origin, with their default caps and a weight of 4: "detour" (a 67 × 41 plate), "hi"+ * (31 × 41) and "a longer label" (118 × 41).+ */+const shape = (x: number, y: number, cap: 'ROUND' | 'ARROW_LINES'): ConnectorRouteEnd => ({+ box: { x, y, width: 160, height: 160 },+ point: { x: 0, y: 0 },+ magnet: 'AUTO',+ cap,+ outline: 2+})+const level = routeConnector('ELBOWED', shape(0, 0, 'ROUND'), shape(480, 0, 'ARROW_LINES'), 4)+const elbow = routeConnector('ELBOWED', shape(0, 0, 'ROUND'), shape(480, 320, 'ARROW_LINES'), 4)+const DETOUR = { width: 67, height: 41 }++function placed(+ pieces: typeof level,+ size: { width: number; height: number },+ position: ConnectorLabelPosition+) {+ const layout = placeConnectorLabel(pieces, size, position)+ if (!layout) throw new Error('No plate placed')+ const round = (n: number) => Math.round(n * 10) / 10+ return {+ plate: [round(layout.plate.x), round(layout.plate.y)],+ line: layout.pieces.map(({ from, to }) => [round(from.x), round(from.y), round(to.x), round(to.y)])+ }+}++describe('a dragged label sits where FigJam keeps it', () => {+ test('along a straight line, cutting it', () => {+ expect(+ placed(level, DETOUR, { section: 'MIDDLE_TO_END', offset: 0.6616183, offAxis: 'NONE' }).line+ ).toEqual([+ [168, 80, 386.7, 80],+ [453.7, 80, 471.5, 80]+ ])+ // Near the start the plate covers the line up to it.+ expect(+ placed(level, DETOUR, { section: 'MIDDLE_TO_START', offset: 0.7893803, offAxis: 'NONE' })+ .line+ ).toEqual([[233.5, 80, 471.5, 80]])+ })++ test('beside a straight line, which runs on uncut', () => {+ const position = { section: 'MIDDLE_TO_END', offset: 0.396971 } as const+ expect(placed(level, DETOUR, { ...position, offAxis: 'ABOVE' })).toEqual({+ plate: [346.5, 18.5],+ line: [[168, 80, 471.5, 80]]+ })+ expect(placed(level, DETOUR, { ...position, offAxis: 'BELOW' }).plate).toEqual([346.5, 100.5])+ })++ test('along an elbow by length, onto any of its segments', () => {+ const along = (section: ConnectorLabelPosition['section'], offset: number) =>+ placed(elbow, DETOUR, { section, offset, offAxis: 'NONE' }).plate+ expect(along('MIDDLE_TO_START', 0.2574374)).toEqual([286.5, 139])+ expect(along('MIDDLE_TO_START', 0.7680386)[0]).toBeCloseTo(206.87, 0)+ expect(along('MIDDLE_TO_END', 0.8359569)).toEqual([386.9, 379.5])+ })++ test('beside an elbow segment, farther out the wider the plate across it', () => {+ const beside = (size: { width: number; height: number }, offAxis: 'ABOVE' | 'BELOW') =>+ placed(elbow, size, { section: 'MIDDLE_TO_START', offset: 0, offAxis }).plate+ // Above a downward run is to its right; FigJam keeps these plates within 0.3 px.+ expect(beside(DETOUR, 'ABOVE')[0]).toBeCloseTo(345.5, 0)+ expect(beside(DETOUR, 'BELOW')[0]).toBeCloseTo(227.5, 0)+ expect(beside({ width: 31, height: 41 }, 'ABOVE')[0]).toBeCloseTo(338.5, 0)+ expect(beside({ width: 118, height: 41 }, 'ABOVE')[0]).toBeCloseTo(356, 0)+ expect(+ placed(elbow, DETOUR, { section: 'MIDDLE_TO_END', offset: 1, offAxis: 'ABOVE' }).plate+ ).toEqual([438, 338.5])+ })+})++describe('dragging a label', () => {+ const at = (x: number, y: number) => connectorLabelPositionAt(level, DETOUR, { x, y })++ test('takes the nearest point of the line as a share of the way from its middle', () => {+ expect(at(380, 80)).toMatchObject({ section: 'MIDDLE_TO_END', offAxis: 'NONE' })+ expect(at(380, 80)?.offset).toBeCloseTo(0.39697, 3)+ expect(at(200, 80)).toMatchObject({ section: 'MIDDLE_TO_START', offAxis: 'NONE' })+ // Past an end it stays at the end.+ expect(at(700, 80)?.offset).toBe(1)+ })++ test('leaves the line once farther from it than FigJam lets it be', () => {+ expect(at(380, 110)?.offAxis).toBe('NONE')+ expect(at(380, 114)?.offAxis).toBe('BELOW')+ expect(at(380, 20)?.offAxis).toBe('ABOVE')+ expect(+ connectorLabelPositionAt(elbow, DETOUR, { x: 380, y: 239.75 })+ ).toMatchObject({ section: 'MIDDLE_TO_START', offset: 0, offAxis: 'ABOVE' })+ })+})diff --git a/packages/vue/src/canvas/surface/lifecycle.ts b/packages/vue/src/canvas/surface/lifecycle.tsindex a12592d28..20559c4da 100644--- a/packages/vue/src/canvas/surface/lifecycle.ts+++ b/packages/vue/src/canvas/surface/lifecycle.ts@@ -57,19 +57,27 @@ export function createCanvasSurfaceManager({}let sceneBackingRenderTimer: ReturnType<typeof setTimeout> | null = null- // The scene of an editing canvas shows an empty sticky note's placeholder in the interface- // language, and draws it again when the language changes.+ // The scene of an editing canvas shows an empty sticky note's placeholder, and every layer an+ // empty connector label's while it is typed into, as the overlays draw the text being edited,+ // in the interface language, and draws them again when the language changes.const showsStickyPlaceholder = options?.layer !== 'overlays'let stickyPlaceholder: string = editorMessages.get().stickyPlaceholder- const stopStickyPlaceholder = editorMessages.subscribe((messages) => {- if (messages.stickyPlaceholder === stickyPlaceholder) return- stickyPlaceholder = messages.stickyPlaceholder- if (!state.renderer || !showsStickyPlaceholder) return- state.renderer.stickyPlaceholder = stickyPlaceholder+ let connectorLabelPlaceholder: string = editorMessages.get().connectorLabelPlaceholder+ const stopPlaceholders = editorMessages.subscribe((messages) => {+ if (+ messages.stickyPlaceholder === stickyPlaceholder &&+ messages.connectorLabelPlaceholder === connectorLabelPlaceholder+ ) {+ return+ }+ ;({ stickyPlaceholder, connectorLabelPlaceholder } = messages)+ if (!state.renderer) return+ showPlaceholders(state.renderer)editor.requestRender()})- function showStickyPlaceholder(renderer: SkiaRenderer) {+ function showPlaceholders(renderer: SkiaRenderer) {+ renderer.connectorLabelPlaceholder = connectorLabelPlaceholderif (showsStickyPlaceholder) renderer.stickyPlaceholder = stickyPlaceholder}@@ -128,7 +136,7 @@ export function createCanvasSurfaceManager({state.renderer.presentationColorSpace = result.presentation ?? 'srgb'state.renderer.tracksSceneSettlement = options?.layer !== 'overlays'state.renderer.tiledSceneEnabled = options?.sceneRenderer === 'tiled'- showStickyPlaceholder(state.renderer)+ showPlaceholders(state.renderer)editor.setCanvasKit(ck, state.renderer)// The scene surface draws shader frames; an overlay surface has none to draw.if (options?.layer !== 'overlays' && !editor.hasShaderRasterizer())@@ -241,7 +249,7 @@ export function createCanvasSurfaceManager({)function destroy() {- stopStickyPlaceholder()+ stopPlaceholders()stopPresentationRefresh()stopColorSpaceRefresh()clearSceneBackingRenderTimer()diff --git a/packages/vue/src/canvas/useCanvasInput.ts b/packages/vue/src/canvas/useCanvasInput.tsindex 33027a853..1f7a880ef 100644--- a/packages/vue/src/canvas/useCanvasInput.ts+++ b/packages/vue/src/canvas/useCanvasInput.ts@@ -52,6 +52,7 @@ const ESCAPABLE_DRAGS: ReadonlySet<DragState['type']> = new Set<DragState['type''rotate','connector-draw','connector-end',+ 'connector-line','line-end'])@@ -380,6 +381,11 @@ export function useCanvasInput(return}+ if (d.type === 'connector-line') {+ editor.connectorLineDrag(cx, cy)+ return+ }+if (d.type === 'line-end') {editor.lineEndDrag(cx, cy, { shift: e.shiftKey, alt: e.altKey })returndiff --git a/packages/vue/src/i18n/locales/de/editor.json b/packages/vue/src/i18n/locales/de/editor.jsonindex a2dd8b759..d07704b28 100644--- a/packages/vue/src/i18n/locales/de/editor.json+++ b/packages/vue/src/i18n/locales/de/editor.json@@ -8,6 +8,7 @@"arcSweep": "Bogen","arcRatio": "Verhältnis","stickyPlaceholder": "Beliebigen Text eingeben, jemanden mit @ erwähnen",+ "connectorLabelPlaceholder": "Text hinzufügen","showUI": "UI anzeigen ({shortcut})","previewing": "Vorschau","resetPreview": "Zurücksetzen",diff --git a/packages/vue/src/i18n/locales/es/editor.json b/packages/vue/src/i18n/locales/es/editor.jsonindex 72091d01e..397a52ade 100644--- a/packages/vue/src/i18n/locales/es/editor.json+++ b/packages/vue/src/i18n/locales/es/editor.json@@ -8,6 +8,7 @@"arcSweep": "Barrido","arcRatio": "Proporción","stickyPlaceholder": "Escribe lo que quieras, @menciona a alguien",+ "connectorLabelPlaceholder": "Añadir texto","showUI": "Mostrar interfaz ({shortcut})","previewing": "Vista previa","resetPreview": "Restablecer",diff --git a/packages/vue/src/i18n/locales/fr/editor.json b/packages/vue/src/i18n/locales/fr/editor.jsonindex 768cf574e..e88f32e1f 100644--- a/packages/vue/src/i18n/locales/fr/editor.json+++ b/packages/vue/src/i18n/locales/fr/editor.json@@ -8,6 +8,7 @@"arcSweep": "Balayage","arcRatio": "Rapport","stickyPlaceholder": "Écrivez ce que vous voulez, @mentionnez quelqu’un",+ "connectorLabelPlaceholder": "Ajouter du texte","showUI": "Afficher l’interface ({shortcut})","previewing": "Aperçu","resetPreview": "Réinitialiser",diff --git a/packages/vue/src/i18n/locales/it/editor.json b/packages/vue/src/i18n/locales/it/editor.jsonindex abca48a5e..4aa95f4ed 100644--- a/packages/vue/src/i18n/locales/it/editor.json+++ b/packages/vue/src/i18n/locales/it/editor.json@@ -8,6 +8,7 @@"arcSweep": "Ampiezza","arcRatio": "Rapporto","stickyPlaceholder": "Scrivi qualsiasi cosa, @menziona qualcuno",+ "connectorLabelPlaceholder": "Aggiungi testo","showUI": "Mostra interfaccia ({shortcut})","previewing": "Anteprima","resetPreview": "Ripristina",diff --git a/packages/vue/src/i18n/locales/ja/editor.json b/packages/vue/src/i18n/locales/ja/editor.jsonindex f8815f548..b47551956 100644--- a/packages/vue/src/i18n/locales/ja/editor.json+++ b/packages/vue/src/i18n/locales/ja/editor.json@@ -8,6 +8,7 @@"arcSweep": "スイープ","arcRatio": "比率","stickyPlaceholder": "自由に入力、@で誰かをメンション",+ "connectorLabelPlaceholder": "テキストを追加","showUI": "UIを表示 ({shortcut})","previewing": "プレビュー中","resetPreview": "リセット",diff --git a/packages/vue/src/i18n/locales/pl/editor.json b/packages/vue/src/i18n/locales/pl/editor.jsonindex 22437b23e..ad270121a 100644--- a/packages/vue/src/i18n/locales/pl/editor.json+++ b/packages/vue/src/i18n/locales/pl/editor.json@@ -8,6 +8,7 @@"arcSweep": "Zakres","arcRatio": "Proporcja","stickyPlaceholder": "Wpisz cokolwiek, @wspomnij kogoś",+ "connectorLabelPlaceholder": "Dodaj tekst","showUI": "Pokaż interfejs ({shortcut})","previewing": "Podgląd","resetPreview": "Resetuj",diff --git a/packages/vue/src/i18n/locales/ru/editor.json b/packages/vue/src/i18n/locales/ru/editor.jsonindex 76fc69bf3..69c042de6 100644--- a/packages/vue/src/i18n/locales/ru/editor.json+++ b/packages/vue/src/i18n/locales/ru/editor.json@@ -8,6 +8,7 @@"arcSweep": "Охват","arcRatio": "Соотношение","stickyPlaceholder": "Пишите что угодно, @упоминайте кого угодно",+ "connectorLabelPlaceholder": "Добавить текст","showUI": "Показать интерфейс ({shortcut})","previewing": "Просмотр","resetPreview": "Сбросить",diff --git a/packages/vue/src/i18n/locales/zh-cn/editor.json b/packages/vue/src/i18n/locales/zh-cn/editor.jsonindex 652ef294d..2076e9a64 100644--- a/packages/vue/src/i18n/locales/zh-cn/editor.json+++ b/packages/vue/src/i18n/locales/zh-cn/editor.json@@ -8,6 +8,7 @@"arcSweep": "扫掠","arcRatio": "比例","stickyPlaceholder": "输入任意内容,@提及任何人",+ "connectorLabelPlaceholder": "添加文本","showUI": "显示界面({shortcut})","previewing": "预览中","resetPreview": "重置",diff --git a/packages/vue/src/i18n/messages/editor.ts b/packages/vue/src/i18n/messages/editor.tsindex c5874ccf2..b3bb1c37a 100644--- a/packages/vue/src/i18n/messages/editor.ts+++ b/packages/vue/src/i18n/messages/editor.ts@@ -19,6 +19,8 @@ export const editorMessageDefaults = {arcRatio: 'Ratio',/** What an empty sticky note shows in its body on the canvas. */stickyPlaceholder: 'Type anything, @mention anyone',+ /** What an empty connector label shows on the canvas while it is typed into. */+ connectorLabelPlaceholder: 'Add text',showUI: params('Show UI ({shortcut})'),previewing: 'Previewing',startPreview: params('Preview ({shortcut})'),diff --git a/packages/vue/src/shared/input/connector/line.ts b/packages/vue/src/shared/input/connector/line.tsnew file mode 100644index 000000000..d53422a4b--- /dev/null+++ b/packages/vue/src/shared/input/connector/line.ts@@ -0,0 +1,84 @@+import type { Editor } from '@open-pencil/core'+import {+ CONNECTOR_SEGMENT_HANDLE,+ connectorRouteHandles,+ connectorScreenLabel+} from '@open-pencil/core/geometry'++import { MOVE_CURSOR, buildResizeCursor } from '#vue/shared/input/geometry'+import type { DragState } from '#vue/shared/input/types'++/** How far past a line handle the pointer still picks it, in screen pixels. */+const LINE_HANDLE_SLACK = 3+/** How near a curve's handle the pointer picks it, in screen pixels. */+const CURVE_HANDLE_HIT_RADIUS = 8++/** The line handle of the only selected connector under a screen point, if any. */+function connectorLineAt(editor: Editor, sx: number, sy: number) {+ const { state } = editor+ if (state.selectedIds.size !== 1) return null+ const [id] = state.selectedIds+ const connector = editor.graph.getNode(id)+ if (connector?.type !== 'CONNECTOR' || connector.locked) return null+ // The label lies over the middle of its run, so it takes the press before that segment does.+ const plate = connectorScreenLabel(editor.graph, connector, state, state.rotationPreview)+ if (+ plate &&+ sx >= plate.x &&+ sx <= plate.x + plate.width &&+ sy >= plate.y &&+ sy <= plate.y + plate.height+ ) {+ return { connectorId: id, part: { kind: 'label' as const } }+ }+ const handles = connectorRouteHandles(editor.graph, connector, state, state.rotationPreview)+ const hit = handles.find((handle) => {+ const dx = Math.abs(sx - handle.at.x)+ const dy = Math.abs(sy - handle.at.y)+ if (handle.kind === 'curve') return Math.hypot(dx, dy) <= CURVE_HANDLE_HIT_RADIUS+ const along = Math.min(CONNECTOR_SEGMENT_HANDLE.length, handle.length) / 2 + LINE_HANDLE_SLACK+ const across = CONNECTOR_SEGMENT_HANDLE.thickness / 2 + LINE_HANDLE_SLACK+ return handle.vertical ? dx <= across && dy <= along : dx <= along && dy <= across+ })+ if (!hit) return null+ return {+ connectorId: id,+ part:+ hit.kind === 'curve'+ ? { kind: 'curve' as const }+ : { kind: 'segment' as const, index: hit.index },+ vertical: hit.kind === 'segment' && hit.vertical+ }+}++/**+ * The cursor over a selected connector's line handle, as FigJam shows it: a two-way arrow across+ * an elbow segment, the way it slides, and the four-way arrow over a curve's handle.+ */+export function connectorLineCursor(editor: Editor, cx: number, cy: number): string | null {+ const { panX, panY, zoom } = editor.state+ const hit = connectorLineAt(editor, cx * zoom + panX, cy * zoom + panY)+ if (!hit || hit.part.kind === 'label') return null+ if (hit.part.kind === 'curve') return MOVE_CURSOR+ return buildResizeCursor(hit.vertical ? 0 : 90)+}++/** Drags a selected connector's elbow segment, curve, or label by its handle. */+export function tryStartConnectorLineDrag(+ editor: Editor,+ cx: number,+ cy: number,+ sx: number,+ sy: number,+ setDrag: (drag: DragState) => void+): boolean {+ const hit = connectorLineAt(editor, sx, sy)+ if (!hit) return false+ editor.connectorLineBegin(hit.connectorId, hit.part, cx, cy)+ setDrag({+ type: 'connector-line',+ commit: () => editor.connectorLineCommit(),+ cancel: () => editor.connectorLineCancel()+ })+ return true+}diff --git a/packages/vue/src/shared/input/select.ts b/packages/vue/src/shared/input/select.tsindex 41db3c941..eee6345f4 100644--- a/packages/vue/src/shared/input/select.ts+++ b/packages/vue/src/shared/input/select.ts@@ -6,6 +6,7 @@ import { editedGradient, type Editor } from '@open-pencil/core'import type { SceneNode } from '@open-pencil/scene-graph'import { tryStartConnectorEndDrag } from '#vue/shared/input/connector/end'+import { tryStartConnectorLineDrag } from '#vue/shared/input/connector/line'import { tryStartGradientDrag } from '#vue/shared/input/gradient'import { tryStartLineEndDrag } from '#vue/shared/input/line/end'import { tryStartResize } from '#vue/shared/input/resize'@@ -56,6 +57,7 @@ function tryStartHandleDrag(if (editedGradient(editor.graph, editor.state.gradientEdit)) return falseif (tryStartShapeHandleDrag(editor, sx, sy, altKey, setDrag)) return trueif (tryStartConnectorEndDrag(editor, sx, sy, setDrag)) return true+ if (tryStartConnectorLineDrag(editor, cx, cy, sx, sy, setDrag)) return trueif (tryStartLineEndDrag(editor, cx, cy, setDrag)) return trueconst scaleDrag = tryStartStickyScale(cx, cy, editor)if (scaleDrag) {diff --git a/packages/vue/src/shared/input/select/hover.ts b/packages/vue/src/shared/input/select/hover.tsindex 4a3483910..8e1dcc8bc 100644--- a/packages/vue/src/shared/input/select/hover.ts+++ b/packages/vue/src/shared/input/select/hover.ts@@ -1,6 +1,7 @@import type { Editor } from '@open-pencil/core'import { layerResizes, layerRotates } from '@open-pencil/scene-graph/generated'+import { connectorLineCursor } from '#vue/shared/input/connector/line'import {MOVE_CURSOR,buildResizeCursor,@@ -87,11 +88,12 @@ export function updateHoverCursor(return null}- // As a press does: a line's ends, then resizing, then a label, then rotation; a read-only- // document has none.+ // As a press does: a line's ends, a connector's line handles, then resizing, then a label, then+ // rotation; a read-only document has none.const cursor = editor.state.readOnly? null: ((lineEndAt(editor, cx, cy) ? MOVE_CURSOR : null) ??+ connectorLineCursor(editor, cx, cy) ??getResizeCursorForSelection(cx, cy, editor) ??(hitTestLabel(cx, cy, fns) ? null : getRotationCursorForSelection(cx, cy, editor)))updateHoveredNode(cx, cy, editor, fns, deep)diff --git a/packages/vue/src/shared/input/types.ts b/packages/vue/src/shared/input/types.tsindex 5f3425481..b094e26cb 100644--- a/packages/vue/src/shared/input/types.ts+++ b/packages/vue/src/shared/input/types.ts@@ -57,6 +57,13 @@ export interface DragConnectorEnd {cancel: () => void}+/** An elbow segment or the curve of a selected connector dragged into place. */+export interface DragConnectorLine {+ type: 'connector-line'+ commit: () => void+ cancel: () => void+}+/** An end of a selected line or arrow dragged to aim it. */export interface DragLineEnd {type: 'line-end'@@ -288,6 +295,7 @@ export type DragState =| DragStickyDraw| DragConnectorDraw| DragConnectorEnd+ | DragConnectorLine| DragLineEnd| DragGradient| DragMovediff --git a/packages/vue/tests/shared/input/select/hover.test.ts b/packages/vue/tests/shared/input/select/hover.test.tsindex 8760298fb..7bd06e93d 100644--- a/packages/vue/tests/shared/input/select/hover.test.ts+++ b/packages/vue/tests/shared/input/select/hover.test.ts@@ -2,7 +2,7 @@ import { afterEach, expect, test } from 'bun:test'import { createEditor, type Editor } from '@open-pencil/core'import type { SceneNode } from '@open-pencil/scene-graph'-import { boundEndpoint, createConnector } from '@open-pencil/scene-graph/connectors'+import { boundEndpoint, createConnector, layoutConnector } from '@open-pencil/scene-graph/connectors'import { createSticky } from '@open-pencil/scene-graph/generated'import {@@ -94,3 +94,20 @@ test("a line's ends show the move cursor, and its length takes no resize", () =>expect(updateHoverCursor(0, 2, editor, NO_HITS)).toBe(MOVE_CURSOR)expect(updateHoverCursor(100, 3, editor, NO_HITS)).toBeNull()})++test("an elbow's segment handles show the way they slide, as in FigJam", () => {+ editor = createEditor()+ const page = editor.state.currentPageId+ const a = editor.graph.createNode('RECTANGLE', page, { x: 0, y: 0, width: 100, height: 100 })+ const b = editor.graph.createNode('RECTANGLE', page, { x: 300, y: 200, width: 100, height: 100 })+ const connector = createConnector(editor.graph, page, {+ start: boundEndpoint(a.id),+ end: boundEndpoint(b.id),+ lineType: 'ELBOWED'+ })+ layoutConnector(editor.graph, connector)+ editor.select([connector.id])+ // Right out of the first box, down the middle, then right into the second.+ expect(updateHoverCursor(200, 150, editor, NO_HITS)).toBe(buildResizeCursor(0))+ expect(updateHoverCursor(150, 50, editor, NO_HITS)).toBe(buildResizeCursor(90))+})diff --git a/tests/fixtures/clipboard/figjam-connector-controls.html b/tests/fixtures/clipboard/figjam-connector-controls.htmlnew file mode 100644index 000000000..aebfefa36--- /dev/null+++ b/tests/fixtures/clipboard/figjam-connector-controls.html@@ -0,0 +1,7 @@+<meta charset="utf-8" /><meta charset="utf-8" /><span+ data-metadata="<!--(figmeta)eyJmaWxlS2V5IjoiZ2lWd0FNRGdRajFycVlGdlozd1MyYiIsInBhc3RlSUQiOjE0MTY5NTM2NzYsImRhdGFUeXBlIjoic2NlbmUiLCJlZGl0b3JUeXBlIjoiZmlnamFtIiwiZW52aXJvbm1lbnQiOiJ3d3cuZmlnbWEuY29tIiwic2VsZWN0ZWROb2RlRGF0YSI6IjM5OjY0MDR8MTR8MHwwIiwiaW1hZ2VIYXNoZXMiOnt9fQo=(/figmeta)-->"+></span+><span+ data-buffer="<!--(figma)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(/figma)-->"+></span+><span style="white-space: pre-wrap"><br /><br /><br /></span>