mirror of
https://github.com/excalidraw/excalidraw.git
synced 2026-11-22 14:01:54 +03:00
* fix(element): don't store movePoints() options on linear elements
`LinearElementEditor.movePoints()` passed its `otherUpdates` straight into
`mutateElement()`, so the `moveMidPointsWithElement` option ended up as a
property on every arrow updated through its bindings. Only the bindings are
element properties now.
Claude Opus 5.5 (xhigh)
* feat(element): position skeleton arrow labels with `label.labelPosition`
`convertToExcalidrawElements()` always centered an arrow's label halfway
along it. A skeleton arrow's `label` can now set `labelPosition` (0-1 along
the arrow's path, as bound arrow labels store it), e.g. to keep a label
where a layout engine placed it.
Claude Opus 5.5 (xhigh)
* fix(element): place skeleton bound arrows where binding puts them
`convertToExcalidrawElements()` bound arrows to elements but kept the
endpoints the skeleton gave, which aren't where Excalidraw puts the ends of
bound arrows. The first time their bindings were updated (e.g. on undo/redo,
or moving an element they're bound to) the arrows jumped there, e.g. by up to
~50px for arrows converted from Mermaid diagrams. Bound arrows are now placed
where their bindings put them once all elements are converted.
Claude Opus 5.5 (xhigh)
* fix(element): measure and frame skeleton bound arrows as placed
Placing bound arrows in `convertToExcalidrawElements()` re-measured their
labels without the given render environment (`updateBoundElements()` now
forwards one to `handleBindTextResize()`), and ran after frames were sized
around them, so a label rewrapped by its shortened arrow could stick out of
its frame. Arrows are now placed before frames are sized.
Claude Opus 5.5 (xhigh)
* fix(element): don't skip placing arrows listed by elements they aren't bound to
Placing skeleton bound arrows skips arrows already updated through another
element, but marked every arrow an element's `boundElements` listed as
updated, though `updateBoundElements()` only updates those bound to it. A
stale entry on an element placed earlier kept the arrow from being placed.
Claude Opus 5.5 (xhigh)
* fix(element): don't grow arrow height to fit rewrapped labels
Review finding 1.
The skeleton placement pass in convertToExcalidrawElements() calls
updateBoundElements(), which calls handleBindTextResize() for arrows with
labels. When the label rewraps taller than getBoundTextMaxHeight() allows
(for arrows under 80px tall, that is the label's old height), it set the
arrow's `height` from the text, leaving it inconsistent with its points.
Reproduction steps:
convertToExcalidrawElements() with rectangles A (0,0,100x20) and
B (500,0,100x20), an arrow at (100,10) with points [[0,0],[400,0]] bound
from A to B with label "aaaa bbbb cccc dddd eeee fff", and a frame
containing all three. Placement shortens the arrow, so the label wraps to
2 lines (height 25 -> 50).
Failure case:
observed arrow height 130 (50 + 80 padding) with points [[0,0],[388,0]];
expected 0, as the points are horizontal. The stale height persists
through updateScene() and inflates later getBoundTextMaxHeight() results.
The same happens in the editor: dragging the end point of a horizontal
labelled arrow (linearElementEditor.test.tsx) left it at height 130.
Fix:
handleBindTextResize() no longer grows arrow containers to fit their
label, matching redrawTextBoundingBox(), which already exempts arrows:
an arrow's size derives from its points, and its label is positioned
along them rather than within its height. The label itself still
rewraps. The linearElementEditor inline snapshot that recorded the
bogus height of 130 for a horizontal arrow is updated to 0.
* fix(element): keep skeleton arrow labels where labelPosition put them
Review finding 2.
A skeleton arrow's `label.labelPosition` is a fraction of the arrow's path
as given (the only path a caller such as a layout engine knows), but the
placement pass (updateBoundElements() on bound arrows) then shortens both
ends by their binding gaps, and the stored fraction was resolved against
the shortened path. Unless both ends were trimmed equally, the label no
longer sat where the caller put it.
Reproduction steps:
convertToExcalidrawElements() with rectangles A (0,0,100x100) and
B (400,0,100x100), and an arrow at (80,50) with points [[0,0],[250,0]]
bound from A to B, label { text: "LABEL", labelPosition: 0.25 }. The
fraction denotes x = 80 + 0.25 * 250 = 142.5 on the arrow as given.
Placement moves the start to x = 106 (off A by the gap) and keeps the end
at 330. Label center measured with
LinearElementEditor.getBoundTextElementPosition().
Failure case:
observed label center x = 162 (0.25 of the placed 106..330 path), expected
142.5: 19.5px off. Other inputs: arrow 60..440, labelPosition 0.8 rendered
at 336.4 instead of 364 (-27.6px); arrow 100..400, labelPosition 0.25 at
178 instead of 175 (+3px).
Fix:
convertToExcalidrawElements() records the point a given labelPosition
denotes on the arrow as given, and after placing bound arrows re-derives
labelPosition as the parameter of the closest point on the placed path,
so the label stays at that point. Default labels (no labelPosition given)
are re-projected as an explicit 0.5 is: a layout engine that omits it
(mermaid-to-excalidraw does, for every edge label) puts its labels at the
midpoints of its routes as given. A point on a stretch placing trimmed
off projects onto the arrow's end, so the label is kept as close to it as
it can be while clear of the arrow's ends and arrowheads
(clampLabelPositionOffEnds()). The closest-point
projection is extracted from handleBoundTextDragging() into
LinearElementEditor.getPathParameterAtPoint() and reused, unchanged.
* fix(element): clamp skeleton arrow label positions as restore does
Review finding 3.
Reproduction steps:
- Call `convertToExcalidrawElements` with arrows whose
`label.labelPosition` is 5, -1, NaN, Infinity or -Infinity, both
unbound and bound to two rectangles via `start`/`end`.
- Read `labelPosition` off the resulting text elements.
Failure case:
- Unbound arrows: 5 -> stored 5, -1 -> stored -1 (expected 1 and 0,
what `restore` would produce via `clamp(v, 0, 1)`).
- Bound arrows: already 1 and 0, only because the placement pass
re-derives `labelPosition` from the placed path.
- NaN/Infinity/-Infinity: 0.5 on both, since `cloneJSON` of the skeleton
turns them into `null`, which falls back to the default.
Fix: `bindTextToContainer` now normalizes an arrow label's
`labelPosition` the way `restore` does: finite values are clamped to
[0,1], anything else falls back to DEFAULT_BOUND_TEXT_LABEL_POSITION.
This covers every arrow label at creation, independent of the cloneJSON
side effect and of whether the placement pass touches the arrow. The
`labelPoints` lookup is unaffected, as `getPointAtPathParameter` already
clamps and rejects non-finite values.
* fix(element): store skeleton arrow label x/y where placed arrows put them
Review finding 4.
Placing bound arrows (updateBoundElements) moves and shortens them and
rewraps their labels via handleBindTextResize, which sets the label's
new width/height but, for arrow containers, never its x/y. The labels
convertToExcalidrawElements returned kept the x/y computed for the
arrow as given and the label as first wrapped.
Reproduction: convertToExcalidrawElements with rectangles A(0,0,100x20)
and B(500,0,100x20), and an arrow at (100,10) with points (0,0)-(400,0)
bound A->B, labelled "aaaa bbbb cccc dddd eeee fff". Compare the
label's stored x/y with LinearElementEditor.getBoundTextElementPosition
on the returned elements.
Failure case (observed vs expected, i.e. derived from the placed arrow):
- in a frame, or not: x=160, y=-2.5 (240x50) vs x=180, y=-14.998
- with labelPosition 0.25: x=60, y=-2.5 vs x=80, y=-14.998
- short label "hi" (no rewrap): y=-2.5 vs y=-2.498 (the old 0.5px drift)
Consumers reading label.x/y directly, rather than through
getTextElementWithAccuratePosition, saw the box ~20px off.
Fix: in transform.ts, in the loop after placement that re-derives
labelPosition, also set every placed arrow's label x/y to
LinearElementEditor.getBoundTextElementPosition, after labelPosition is
final. All labels of placed arrows get it, given labelPosition or not.
Not fixed in handleBindTextResize: the editor deliberately treats arrow
label x/y as a cache. The renderer, bounds, hit testing and the WYSIWYG
editor derive them from the arrow every time (see the doc comment on
getTextElementWithAccuratePosition). Writing them there would change
editor history/snapshots for no visible effect. convertToExcalidrawElements
returns the elements as data, so its stored x/y should be right. Before
this branch they were, up to 0.5px.
Tests: a regression test checks that stored label x/y match the placed
arrow, with and without labelPosition. It fails before the fix (160 vs
180). Two exact x/y assertions on "HELLO WORLD!!" labels became
toBeCloseTo. Four snapshots change: label x/y now follow the placed
arrows (sub-pixel in y, up to ~3px in x where placement is asymmetric),
and version goes 3 -> 4 from the extra mutation.
* fix(excalidraw): strip leaked moveMidPointsWithElement on restore
`LinearElementEditor.movePoints()` used to spread its `otherUpdates`
straight into `mutateElement()`, so the `moveMidPointsWithElement` option
was persisted as a property on every arrow/line updated through its
bindings. 25902dc3b stopped writing it, but scenes saved before that
still carry it, and `restoreElementWithProperties()` keeps unknown keys
(it spreads `...element` and only deletes `strokeSharpness` and
`boundElementIds`), so the junk prop survived every load and kept
travelling through saved files, collab payloads and history deltas.
Reproduction steps:
- Call `restoreElements()` on an arrow carrying
`moveMidPointsWithElement: false` and a line carrying
`moveMidPointsWithElement: true` (new test in restore.test.ts).
Failure case:
- Observed: the restored arrow still has
`moveMidPointsWithElement: false` ("expected { id: 'id1', type:
'arrow', ... } to not have property "moveMidPointsWithElement"",
received `false`).
- Expected: the prop is not an element property and is dropped.
Fix:
- Delete `moveMidPointsWithElement` alongside the other stripped legacy
props in `restoreElementWithProperties()`, and type it as a deprecated
input prop there.
History: the leak was introduced by c141960ad ("feat: Non-elbow arrow
snapping and behavior changes (#9670)"), merged to master on
2025-11-25, and it is still present on master. It is not in any npm
release tag (v0.18.0, v0.18.1), but it shipped via master builds
(excalidraw.com and `@next` prereleases) for ~11 months, so real
scenes carry the prop.
Review finding 5.
* refactor(element): pass moveMidPointsWithElement as a movePoints option
Review finding 6.
Reproduction / evidence: `LinearElementEditor.movePoints()` took
`moveMidPointsWithElement` in its `otherUpdates` argument (typed next to
`startBinding`/`endBinding`), which is the bag of element updates forwarded
to `_updatePoints()` and from there into `scene.mutateElement()`. Callers:
- `updateBoundElements()` (binding.ts) passed
`{ moveMidPointsWithElement: <same element at both ends> }` as
`otherUpdates` - the only caller setting a real value.
- `LinearElementEditor` point dragging (two call sites) forwarded
`updates?.moveMidPointsWithElement` from `PointMoveOtherUpdates`, but
`pointDraggingUpdates()` never sets that field, so it was always
undefined there.
Before 25902dc3b this put `moveMidPointsWithElement: false/true` on every
arrow updated through its bindings (and bumped its version). 25902dc3b
fixed it by copying only `startBinding`/`endBinding` out of `otherUpdates`
in the non-elbow branch of `_updatePoints()`.
Failure case: `otherUpdates` still mixed a behaviour flag with element
properties, so the filter in `_updatePoints()` had to know about every
non-property key. Any new option added to `otherUpdates` the same way
would be silently persisted on linear elements (and saved to scenes)
unless the filter was updated too.
Fix: move `moveMidPointsWithElement` into `movePoints()`'s existing
`options` parameter, next to `isBindingEnabled` /
`isMidpointSnappingEnabled`, and drop it from `otherUpdates` and from
`PointMoveOtherUpdates` (along with the dead forwarding at the two drag
call sites). `otherUpdates` now only holds element properties, so the
non-elbow branch of `_updatePoints()` spreads it directly again, as on
master; `mutateElement()` skips undefined values, so explicitly undefined
bindings remain no-ops. The elbow branch's binding filtering is untouched.
Behaviour is unchanged (no snapshot changes). Added a test that the option
still keeps midpoints moving with the element and isn't stored on it.
* refactor(element): place skeleton bound arrows once each, per arrow
Review finding 8.
The placement pass in `convertToExcalidrawElements` simulated moving every
bindable element (`updateBoundElements` per bindable) and repurposed
`simultaneouslyUpdated` as an "already placed" ledger (a fresh copy per
call to dodge the id-set cache), then re-collected the arrows each call
touched for the label loop. Its correctness hinged on `updateBoundElements`
internals: updating both ends from either one, the `doesNeedUpdate` stale
`boundElements` filter, and the array-identity id cache. It already broke
once (fdc8262d5).
Reproduction / evidence: a scratch vitest dumped the output (minus seeds,
nonces and timestamps, versions kept) of `convertToExcalidrawElements` for
arrows bound across two shapes, to the same shape at both ends (2- and
4-point), elbow arrows (one and two ends bound), arrows in frames, six
arrows on one labelled hub, text ends with ids referenced before the
elements, and multi-point arrows, and spied on `movePoints`. Every bound
arrow was placed exactly once.
Failure case: none found. Skeleton bindings all go through `applyBinding`,
which always lists the arrow on the bindable, so the ledger never skipped
or double-placed an arrow. This is a maintainability fix.
Fix: extract the per-arrow body of `updateBoundElements`' visitor into an
exported `updateBoundArrow` (`updateBoundPoint` for each binding, then
`movePoints` with `moveMidPointsWithElement` for arrows bound to one
element at both ends, then `handleBindTextResize`), and call it from
`updateBoundElements`. Dropped the visitor's per-binding `changedElement`
check: after `doesNeedUpdate`, one end is always bound to `changedElement`,
so it always held. The transform pass now iterates the arrows bound to
elements present and places each once, re-deriving its label's
`labelPosition` and x/y in the same loop. No ledger, no copies of it, no
per-bindable calls. Outputs of the scratch dump, versions included, are
byte-identical before and after; all existing tests and snapshots pass
unchanged.
* fix(element): don't nudge skeleton arrow ends by 0.5px
bindLinearElementToElement() moved every skeleton arrow's start 0.5px
towards its end and its end 0.5px towards its start, "so bindings don't
overlap with start/end bound element coordinates" (#7195). The placement
pass now re-places every bound end with updateBoundArrow(), which puts
it off the bound element by the binding gap, so for bound ends the
nudge was dead work (a clone, nudge and normalize that's overwritten).
It only still had an effect on ends nothing re-places: the unbound end
of half-bound arrows, and both ends of unbound arrows (including those
whose start/end reference missing ids, which bind nothing).
Reproduction (convertToExcalidrawElements, regenerateIds: false):
- fully bound: rect A (0,0,100x100), rect B (400,0,100x100), arrow at
(100,50) points [0,0]->[300,0], start A, end B
- half bound: rect A, arrow at (100,50) points [0,0]->[300,100], start A
- half bound: rect B, arrow at (100,50) points [0,0]->[300,0], end B
- start: { id: "nope" } (missing), and an arrow with no start/end, both
at (100,50) points [0,0]->[300,0]
Failure case (observed -> expected):
- fully bound: x 106, points [0,0]->[288,0], version 5 both with and
without the nudge (it's fully overwritten)
- half bound (start): unbound end at (399.5, 149.5) -> (400, 150)
- half bound (end): unbound start at x 100.5 -> 100
- missing ref / unbound: x 100.5, points [0,0]->[299,0] while width
stays 300 (stale, getNormalizeElementPointsAndCoords() doesn't update
it) -> x 100, points [0,0]->[300,0], width 300
Fix: remove the nudge (and the single point early return that only
guarded it), so ends are either placed by their bindings or kept where
the skeleton puts them. Bound ends can't be left unplaced: the bound
elements are always added to the element store, and updateBoundPoint()
only skips degenerate arrows the nudge didn't change either.
Snapshot changes: the unbound arrows in "should transform linear
elements" and "should transform to labelled arrows when label provided
for arrows" now keep x as given (100/450 instead of 100.5/450.5) and
points spanning their width ([0,0]->[100,0] instead of [99,0]). Their
labels don't move (the arrow midpoints are unchanged). The "should bind
arrows to existing elements if ids are correct" assertion, whose ids
are missing and so bind nothing, now expects x 255 as given (was 255.5).
Adds a regression test that a half-bound arrow's unbound end and an
unbound arrow stay where the skeleton puts them.
Review finding 9.
* perf(element): measure skeleton arrow labels once, as placed
Review finding 11.
`bindTextToContainer` ran `redrawTextBoundingBox` on every label, so an
arrow's label was wrapped and measured against the arrow as given, then the
placement pass (`updateBoundArrow` -> `handleBindTextResize`) wrapped and
measured it again against the arrow shortened by its binding gaps, always
throwing the first result away.
Reproduction: a scratch vitest mocked `wrapText` / `measureText` with
counters and converted two shapes and a 400px arrow bound to both with the
label "aaaa bbbb cccc dddd eeee fff".
Failure case: observed wrapText x2 (maxWidth 280, then 271.6) and
measureText x3 (newTextElement's unwrapped measurement, the discarded
redraw, the placed rewrap); expected wrapText x1, measureText x2. Six
labelled arrows on one shape: wrapText 13, measureText 20 (now 7 / 14).
Unbound labelled arrows were already measured once (wrap 1 / measure 2).
Fix: `bindTextToContainer` no longer measures arrow labels; the transform
records them, the placement pass drops each label `updateBoundArrow` just
measured, and the labels left (of arrows not placed) are measured after it
with `redrawTextBoundingBox`, as before. Nothing between creating a label
and the pass reads its size: binding only sets `startBinding` /
`endBinding` (no points), `labelPoints` is still taken on the input arrow,
and for arrow containers `handleBindTextResize` ignores the old label
height. Measuring the leftovers after the pass, rather than predicting at
creation which arrows get placed, means no label can go unmeasured.
A scratch dump of 18 scenarios (bound / one end / same shape both ends /
elbow / created and text ends / missing end id / ids before data / frame /
single point / autoResize: false / labelPosition in and out of range /
unbound / hub of six / shape labels) is identical before and after (seeds,
nonces and timestamps stripped, versions kept), except the label `version`
of placed arrows, one lower for the dropped mutation; the 4 snapshot
changes are exactly that. Added a test asserting the wrap / measure counts
for a bound and an unbound labelled arrow (fails before: 3 wraps vs 2).
* fix(editor): re-measure bound labels with the host's render environment
Review finding 12.
The finding: the `renderEnvironment` option this branch added to
`updateBoundElements` (a9b2d2878) was passed only by the transform, and
since e0f198c15 not even by that (it calls `updateBoundArrow` directly),
so the option was dead while documenting that it "measures the labels of
the updated arrows". Meanwhile every editor path re-measured bound labels
with the default environment, ignoring the host's
`<Excalidraw renderEnvironment>` (its custom `textMetrics`), so a label
laid out with the host's metrics re-wrapped the first time its arrow was
touched.
The re-wrap itself predates this branch: master's `updateBoundElements`
never took an environment and called `handleBindTextResize(element,
scene, false)`, as `LinearElementEditor`'s point drag still did. Rather
than drop the dead option, this wires it (and the other label-measuring
editor paths) to the host's environment.
Reproduction: convert two rectangles A, B and an arrow bound to both,
labelled "aaaa bbbb cccc dddd eeee ffff", with
`convertToExcalidrawElements(..., { renderEnvironment })`, whose
`textMetrics.getLineWidth` is `text.length * 5`. Move B by 1px and call
`updateBoundElements(B, scene)` as the drag path does. In the editor:
render `<Excalidraw renderEnvironment={env}>` with the same scene and drag
or arrow-key nudge B, align A and B, undo/redo the drag, or drag the
arrow's point.
Failure case (this branch and master alike):
observed: "aaaa bbbb cccc dddd eeee ffff", width 145, becomes
"aaaa bbbb cccc dddd\neeee ffff", width 190
expected: unchanged, "aaaa bbbb cccc dddd eeee ffff", width 145
Cause: no editor caller passed `updateBoundElements` an environment, so
it called `updateBoundArrow` without one; `ElementsDelta`'s redraw,
`LinearElementEditor`'s point drag and `listMarker`'s re-numbering
likewise measured without one.
Fix: optional `renderEnvironment` threaded the way resize already does it
(a trailing param, or an option where the function takes an options bag):
- `updateBoundElements`: its existing option is now passed by the editor
(doc comment updated); `updateBindings` gains the same option and
forwards it. Both pass it to `updateBoundArrow`.
- drag: `dragSelectedElements` (new trailing param), from the selection tool.
- arrow-key nudge (App.tsx).
- align / distribute: `alignElements` / `distributeElements` (new trailing
param), from their actions.
- rotate/resize: the `updateBoundElements` calls in `transformElements`,
`rotateMultipleElements`, `resizeSingleElement`, `resizeMultipleElements`
now pass the environment they already had.
- sticky notes: `updateStickyNoteLayout` passes its `renderEnvironment` on
to its bound-arrow pass.
- undo/redo: `ApplyToOptions.renderEnvironment` reaches
`ElementsDelta.redrawElements` (both the bound-text redraw and the
bound-arrow pass); `History.undo/redo` and `HistoryDelta.applyTo` take
it, the history actions pass `app.renderEnvironment`, and
`App.applyDeltas` defaults to it.
- `LinearElementEditor` point drag: `handleBindTextResize` gets
`app.renderEnvironment`.
- list-marker re-numbering on duplicate (`advanceDuplicatedListMarkers`,
`applyListMarkerAdvances`, new trailing param): both its label redraw and
its free-text refresh.
- the remaining editor callers of `updateBoundElements` / `updateBindings`,
each of which can move a labelled arrow bound to the element: text
editing (App.text, textWysiwyg), duplicate, crop/uncrop, wrap/unwrap
(also its `redrawTextBoundingBox`), font/style/auto-resize actions,
element type conversion, and the Stats position/angle/dimension inputs
(`moveElement` gets a trailing param).
Left alone:
- `updateBindings`' arrow branch (`updateArrowBindings`): it only rebinds
the arrow's ends and measures no label.
- `transform.ts`: already measured with its environment (via
`updateBoundArrow`).
- callers that already passed `app.renderEnvironment` to
`redrawTextBoundingBox` / `handleBindTextResize` (resize, Stats font
size, font/bound-text actions, textWysiwyg submit, type conversion).
- `updateBoundElements` re-measures only arrow labels (its visitor skips
non-arrows), so no non-arrow container label path needed changing there.
- free-text measurement helpers called directly (`measureText`, `wrapText`,
`refreshTextDimensions`, ...) outside these bound-label paths: not part
of this finding.
Without the prop, `app.renderEnvironment` is the owner-window environment
with no `textMetrics`, so measurement still falls back to the global
provider or a canvas; single-window behaviour is unchanged (no snapshot
changes). All new params are optional, so external callers are unaffected.
Tests: a direct `updateBoundElements` test (packages/element) and editor
tests rendering `<Excalidraw renderEnvironment>` for drag, nudge, align,
undo/redo and arrow point drag; each fails without its path's change.
* refactor(element): build one scene in skeleton conversion, resync it
convertToExcalidrawElements built a temp `scene` from the element store
before labels and the elements skeleton arrows bind to were created, and
then a second `boundScene` from the completed store for the bound-arrow
placement pass, so the function held two scenes over overlapping element
objects (Review finding 13).
Evidence that the divergence produces no wrong output: the early scene
is only used to measure non-arrow container labels (the container and
label are passed directly; the sticky fit gets its label explicitly) and
by bindBindingElement (geometry from the arrow and the element passed
in; the map is only consulted for a text's container, and containers are
always in the snapshot). This was already so on master, where the same
snapshot scene was used the same way. To check, the scene was
temporarily resynced (replaceAllElements) after every store addition,
including before each bindBindingElement, and outputs were diffed
against the current code (reseeded, ids canonicalized) for created
rectangle/ellipse/diamond/text ends, elbow arrows, existing ids bound by
two arrows (copied twice), text ends, a labelled sticky note, a frame
around them, and an arrow label (given its own id) used as another
arrow's start: all identical, and the full suite passed in that mode.
So this is a maintainability fix: drop `boundScene` and resync the one
scene with replaceAllElements once the store is complete, which is what
`new Scene(...)` did. Outputs, snapshots and versions are unchanged.
* fix(element): place skeleton arrows' created end shapes along the arrow
`convertToExcalidrawElements` creates a rectangle/ellipse/diamond/text for
a skeleton arrow's `start`/`end` given by `type` (no id), and placed it as
if every arrow ran left to right: the start shape left of the arrow's
`x`, the end shape right of `x + width`, both centered on the arrow's `y`.
For any other direction the shape isn't where the arrow starts or ends,
so the arrow is bound to a shape it doesn't reach, and the placement pass
(e0f198c15) then moves its ends to where those bindings put them.
Reproduction: an arrow at (0,0) with `start: { type: "rectangle" }`,
`end: { type: "ellipse" }` and
- "diagonal": points [0,0]->[100,100]
- "vertical": points [0,0]->[0,200]
- "right-to-left": points [0,0]->[-200,0]
or `end: { type: "text", text: "end" }` on the diagonal one.
Failure case (HEAD): the shapes are at (-100,-50) and (100,-50) whatever
the direction, and the ends are bound at fixedPoints the editor can't
create, outside the shapes:
- "diagonal": ellipse at (100,-50), the arrow ends at (100,100): end
bound at fixedPoint [0,1.5].
- "vertical": end bound at [0,2.5], and the start is placed at y=56, as
the arrow runs down the rectangle's edge.
- "right-to-left": ellipse at x=200, on the wrong side: end bound at
[-4,0.5001], and the start is placed at x=-106, on the far side of the
rectangle the arrow passes through.
- the text end is bound at [0,4.5] the same way.
Expected: the shapes at the arrow's start/end, the arrow pointing into
them, both ends bound on their outlines and placed off them by the
binding gap.
Fix: new `getArrowEndShapePosition` centers the shape on the arrow's
first/last segment as extended past the end, at the distance from its
center to its outline (rectangle/text box, ellipse or diamond) in that
direction, so the end lies on its outline. Explicit `x`/`y` still win,
and an existing end text still keeps its x. Left-to-right arrows are
placed as before. Other directions change, e.g. the 300x300 start
rectangle of the 395x35 arrow in "should bind arrows to existing shapes
when start / end provided with ids" moves up 13.3px, onto the arrow's
line (snapshot updated).
* fix(element): unbind unreachable skeleton arrow ends, rebind the rest
`convertToExcalidrawElements` binds skeleton arrows to their `start`/`end`
elements while it is still creating elements, and the placement pass
(e0f198c15) then places every bound end where its binding puts it. Two
kinds of bindings made at conversion time are wrong, and placing the
arrows exposes them.
1. Ends given beyond the binding area of their element
A layout engine (e.g. mermaid's sequence diagrams, whose messages are
bound to the participants' headers but drawn far below them) can bind an
end the user could never bind in the editor. Its fixedPoint lies well
outside the element, and `normalizeFixedPoint` clamps it, so the binding
can't hold the end where it was given.
Reproduction: rectangles A (0,0 100x20) and B (500,0 100x20).
- "half-far": an arrow at (100,10) with points [0,0]->[450,490], start A,
end B, so its end is given at (550,500), far below B.
- "beyond": an arrow at (50,40) with points [0,0]->[500,0], start A, end B,
20px below both, so beyond binding distance.
Failure case (HEAD):
- "half-far": end bound to B at fixedPoint [0.5001,10]. Placing moves the
end from the given (550,500) to (550,200).
- "beyond": both ends bound at fixedPoint [0.5001,2]. That's a binding the
editor can't create, and it moves the arrow onto the headers the first
time A or B is moved.
Expected: ends beyond the binding area are left unbound where given.
Ends within it stay bound.
Fix: new `isPointInBindingArea` (collision.ts) checks whether a point is
inside an element or within binding distance of its outline.
`isEndBoundBeyondBindingArea` (binding.ts) applies it to an arrow's bound
end. Before placing, the pass unbinds every end beyond its element's
binding area (`unbindBindingElement`, which also drops the arrow from
the element's `boundElements`). An arrow with no binding left isn't
placed and keeps its geometry as given.
The check ignores frame clipping (`getBindingCandidates` still skips
the clipped parts of frame children): frames are sized around their
children only at the end of the conversion, so an element given with a
`frameId` would be checked against a 0x0 frame, and every end bound to
it would be beyond reach. Arrows unbound from an element are still
framed with it, as the frame pass frames what is bound to a frame's
children (through their `boundElements`, which no longer list them).
An end that just falls short of its element is extended onto it instead
(`extendBoundEndOntoElement`, binding.ts): its end segment is extended
past the end by the segment's length, at least 100px, and if that
reaches the element, the end is moved to where it does, off the element
by the binding gap, and stays bound. This keeps bindings a generator
meant to make, but drew arrows slightly too short for.
Reproduction: rectangle B (500,0 100x20), an arrow at (150,10) with
points [0,0]->[250,0], end B, so its end is given 100px short of B.
Expected: end bound to B, moved to (500 - binding gap, 10).
2. Ends bound before their element is sized
A rectangle/ellipse/diamond with a label and no width/height is created
0x0 and sized to fit its label only when its label is bound. That happens
in the same pass that binds arrows, in skeleton order. An arrow listed
before the element therefore binds to a 0x0 element, and
`calculateFixedPointForNonElbowArrowBinding` binds ends on elements
smaller than MIN_BINDABLE_SIZE to their center. Nothing recomputes the
binding once the element is sized, so the placement pass re-aims the end
at the center, and the result depends on element order.
Reproduction: an arrow at (100,50) with points [0,0]->[300,0], end bound
to B, where B is a rectangle at (400,25) with label "B" and no size
(sized to 20x35).
Failure case (HEAD):
arrow listed first: endBinding.fixedPoint [0.5001,0.5001] (center),
points [[0,0],[294,-7.11]] (tilted)
B listed first: endBinding.fixedPoint [0,0.714] (left edge),
points [[0,0],[294,0]] (straight)
Expected: the same in either order, the "B listed first" result.
Fix: the pass rebinds each end that is still bound
(`bindBindingElement`, keeping its mode) against its element as sized.
For elements whose size didn't change after binding, this gives the
same binding as before.
Signed-off-by: Mark Tolmacs <mark@lazycat.hu>
* fix(editor): convert TTD dialog diagrams with the host's render environment
Review finding 7.
The text-to-diagram dialog (the Mermaid tab, and the AI chat's preview and
insert) converted mermaid's skeletons with `convertToExcalidrawElements`
without the host's `renderEnvironment`, while pasting a mermaid definition
(App.clipboard) passes `app.renderEnvironment`. So with a host's custom
`textMetrics`, every label in the dialog's conversion, container and arrow
labels alike, was measured with the default (canvas) metrics. The gap
predates this branch: d3a9c2a19 added the option and passed it from the
paste path, but not from the dialog.
Reproduction: render `<Excalidraw renderEnvironment={env}>`, whose
`textMetrics.getLineWidth` is `text.length * 5`, open the Mermaid dialog
and insert a diagram with a 100x40 rectangle labelled "aaaa bbbb cccc", and
an arrow labelled "aaaa bbbb cccc dddd eeee ffff" bound to it.
Failure case:
preview: both labels wrapped by the default metrics ("aaaa bbbb\ncccc",
"aaaa bbbb cccc dddd\neeee ffff"), and the rectangle grown to
height 60 to fit two lines
inserted: `addElementsFromPasteOrLibrary` redraws the labels with the
host's environment, so they end up on one line, but the
rectangle stays 60 high, around a one-line label
Expected: as when pasting the same definition: one-line labels (70px and
145px wide) in the preview and the scene, and the rectangle 40 high.
Fix: `convertMermaidToExcalidraw` takes an optional `renderEnvironment` and
passes it to `convertToExcalidrawElements`. Its three callers pass
`app.renderEnvironment`: the Mermaid tab's preview (whose result is what
it inserts), and the AI chat's preview (`useMermaidRenderer`, now using
`useApp`) and insert (`TextToDiagram`).
Left alone: `exportScene`, which renders the preview, takes no environment;
it draws already measured elements, so the preview's layout now matches the
inserted one.
Without the prop, `app.renderEnvironment` has no `textMetrics`, so
measurement falls back as before (no snapshot changes).
Tests: inserting from the Mermaid dialog under a host environment
(renderEnvironmentLabels.test.tsx); the rectangle's height fails without
the fix.
* fix(element): decide skeleton arrow end bindings before moving either end
When placing skeleton arrows, each end bound beyond its element's binding
area is either extended onto the element (if it just falls short) or
unbound. 61255ad73 did this one end at a time: start first, then end. For
elbow arrows, extending the start goes through `movePoints`, which reroutes
the whole arrow from both its bindings. That moved the still-bound end onto
its element before it was checked, so it was kept bound. The result
depended on which end was the start.
Reproduction: rectangles A (0,0 100x20) and B (500,0 100x20), and an elbow
arrow (`elbowed: true`) [0,0]→[400,0]→[400,490] at (150,10), bound from A
to B. Its start falls 50px short of A, and its end is at (550,500), far
below B.
Failure case:
A→B: start extended onto A and bound, end rerouted to about (550,26)
just under B, and left bound to B
B→A (same arrow reversed): end extended onto A and bound, start left at
(550,500) and unbound
Expected: both directions as B→A: the A end extended and bound, the B end
left where given and unbound.
Fix: `extendBoundEndOntoElement` becomes `getBoundEndExtension`, which only
returns where the end would be extended to and moves nothing. The skeleton
conversion now checks both ends against the arrow as given. It unbinds the
unreachable ends first, so the reroute doesn't take them along, then
applies every extension in one `movePoints` call, then rebinds as before.
Only elbow arrows were affected: moving one end of a non-elbow arrow leaves
its other end in place. Mermaid's converter doesn't produce elbow arrows,
so this needs hand-written or LLM-generated skeletons.
Signed-off-by: Mark Tolmacs <mark@lazycat.hu>
* fix(element): rebind elbow skeleton arrows before extending their ends
The placement pass (61255ad73, 2fe86fe7f) extends bound ends that just
fall short of their elements onto them with one `movePoints` call. Only
after that does it rebind each end against its element as sized. For
elbow arrows, `movePoints` reroutes the whole arrow from both its
bindings. A binding made before its element was sized (a labelled shape
with no width/height, listed after the arrow, is still 0x0 when the
arrow binds to it) points at the element's center. The reroute then
routes the end around the element to that center, and the rebind that
follows keeps the side the end was rerouted to. The result depended on
element order.
Reproduction: rectangle A (0,25 100x50), rectangle B at (400,25) with
label "B" and no size (sized to 20x35), and an elbow arrow
(`elbowed: true`) at (150,50) with points [0,0]->[250,0], bound from A to
B. Its start falls 50px short of A, so it gets extended.
Failure case:
[A, B, arrow]: endBinding.fixedPoint [-0.3,0.714] (B's left side),
points [[0,0],[288,0]]
[A, arrow, B]: endBinding.fixedPoint [1.3,0.5] (B's right side), six
points running past B to x=466 and back into its right
side at (426,42.5)
The same happens when the extended end is the one bound to B (the arrow
at (106,50) with points [0,0]->[224,0], ending 70px short of B), and when
both ends are extended.
Expected: the same in either order, the [A, B, arrow] result.
Fix: before extending an elbow arrow's ends, rebind both of them against
their elements as sized: an end being extended at the point it's
extended to (`calculateFixedPointForNonElbowArrowBinding` with that
point as the focus point, then `bindBindingElementToFixedPoint`), and
any other end where it is (`bindBindingElement`). Then extend, and rebind
as before.
Rebinding before the move only the ends not being extended isn't enough:
an extended end would still be rerouted to its element's center. Neither
is rebinding only after the move, because by then the reroute has
already put the end on the wrong side.
Only elbow arrows were affected: moving one end of a non-elbow arrow
doesn't reroute it, so the rebind after the move already corrects it.
Tests: "should route elbow arrows extended onto elements as to elements
sized to fit their labels after them as to those before them"
(transform.test.ts), covering the start and the end extended. It fails
without the fix (`expected 1.3 to be less than 0`).
Signed-off-by: Mark Tolmacs <mark@lazycat.hu>
* fix(element): clamp skeleton arrow labels only off the ends they're trimmed off
ee5d10684 keeps skeleton arrow labels where `labelPosition` put them on
the arrow as given, by projecting that point onto the arrow as placed. A
point on a stretch placing trimmed off projects onto the arrow's end, so
`clampLabelPositionOffEnds` keeps the label clear of the end and its
arrowhead. But the clamp ran on the label of every bound arrow, wherever
its point projected. Labels on the arrow as placed were moved off its
ends too, which unbound (unplaced) arrows don't do.
Reproduction: rectangles A (0,0 100x100) and B (192,0 100x100), and an
arrow at (106,50) with points [0,0]->[80,0], bound from A to B. Its ends
are already off A and B by the binding gap, so placing it trims nothing.
Label widths are as measured in the tests.
Failure case:
label "LABEL" (50px), no labelPosition: labelPosition 0.375, center
x=136, 10px toward the start, off the end arrowhead
label "LABELX" (60px), no labelPosition: labelPosition 0.5, center
x=146: too wide to clear both ends, so centered again. A 10px wider
label jumps back 10px
arrow [0,0]->[300,0] instead, label 220px wide at labelPosition 0.3:
0.3667, 20px off where it was given
Expected: as on the same arrows unbound: 0.5 (center x=146) for both
default labels, and 0.3 for the given one.
Fix: `clampLabelPositionOffEnds` returns the position unchanged unless it
is at an end of the arrow (0 or 1, within PRECISION), where points on
trimmed-off stretches project to.
Snapshot: the label in "should bind arrows to shapes when start / end
provided without ids" was too wide to clear both ends, so the clamp had
centered it at exactly 0.5. It now keeps its projected position,
0.4999999949 (and is stored at x=240 instead of 240.00000045, with its
version bumped as the position changed).
Signed-off-by: Mark Tolmacs <mark@lazycat.hu>
* fix(element): create skeleton arrow labels unrotated
Arrow labels aren't rotated: `restore` resets their `angle` to 0, and
`redrawTextBoundingBox` asserts it outside production and resets it. A
skeleton label can still give an `angle` (its type allows the generic
element props). Until 472c87980 every skeleton label was measured with
`redrawTextBoundingBox` as soon as it was created, so an arrow label's
angle was reset there. Since then, labels of placed (bound) arrows are
measured only as placed, through `handleBindTextResize`, which leaves
`angle` as given. Labels of arrows not placed are still measured with
`redrawTextBoundingBox`, so outside production a given angle failed its
invariant.
Reproduction: rectangles A (0,0 100x100) and B (400,0 100x100), and an
arrow at (106,50) with points [0,0]->[288,0] and label
{ text: "L", angle: 1 }, once bound from A to B and once unbound.
Failure case:
bound: label angle 1
unbound: "text element angle must be 0 if bound to arrow container"
(outside production; angle 0 in production)
Expected: label angle 0 on both arrows, as after `restore`.
Fix: the label of an arrow is created with angle 0, as `restore`
normalizes it. The labels of other containers are still rotated with
them by `redrawTextBoundingBox`.
Signed-off-by: Mark Tolmacs <mark@lazycat.hu>
* fix(element): keep skeleton loop arrows' midpoints where given
The placement pass (45276e6a9) places skeleton bound arrows with
`updateBoundArrow`, which the editor also uses as an element moves. For
an arrow bound to the same element at both ends, it passes
`moveMidPointsWithElement`, so that a loop moves with its element as a
whole: its midpoints follow its start. Placing a skeleton arrow moves
nothing it's bound to, only its ends, so a loop's midpoints followed its
start as it was placed off the element, and the loop changed shape.
Midpoints of other arrows stay where given. Only the start drags them,
so the result also depended on which end was the start.
Reproduction: rectangle A (0,0 100x100), and an arrow from A's center
around to A's right side: points (50,50) (50,-60) (160,-60) (160,50)
(106,50), bound to A at both ends.
Failure case:
from the center: start placed off A's top edge, 56px up, at (50,-6),
and the midpoints 56px up with it: (50,-116) (160,-116) (160,-6).
The loop is 56px taller, and its last segment into A is diagonal
from A's top edge (50,0): midpoints 6px up: (50,-66) (160,-66) (160,44)
either, reversed: no change, as its start is already off A
Expected: the midpoints where given, (50,-60) (160,-60) (160,50), with
only the ends placed.
Fix: `updateBoundArrow` takes `boundElementMoved` (default true, as the
editor calls it). The placement pass passes false, so loops are placed
like other arrows: only their ends move. Placed loops stay put under the
editor's next binding update, and still move whole with their element.
Left alone: a reversed loop given from the center still keeps its end
there. For loops, `updateBoundPoint` places the end with the arrowhead at
its fixed point and the other on the outline, and a skeleton end is bound
where given, here at the center. That's the editor's own rule from
master, applied to the binding as given.
Signed-off-by: Mark Tolmacs <mark@lazycat.hu>
---------
Signed-off-by: Mark Tolmacs <mark@lazycat.hu>
Co-authored-by: Mark Tolmacs <mark@lazycat.hu>
1154 lines
35 KiB
TypeScript
1154 lines
35 KiB
TypeScript
import { KEYS, ROUNDNESS, arrayToMap, DEFAULT_ZOOM } from "@excalidraw/common";
|
|
|
|
import { pointFrom } from "@excalidraw/math";
|
|
|
|
import { actionWrapTextInContainer } from "@excalidraw/excalidraw/actions/actionBoundText";
|
|
|
|
import { Excalidraw, isLinearElement } from "@excalidraw/excalidraw";
|
|
|
|
import { API } from "@excalidraw/excalidraw/tests/helpers/api";
|
|
import { UI, Pointer, Keyboard } from "@excalidraw/excalidraw/tests/helpers/ui";
|
|
import {
|
|
act,
|
|
fireEvent,
|
|
render,
|
|
} from "@excalidraw/excalidraw/tests/test-utils";
|
|
|
|
import { defaultLang, setLanguage } from "@excalidraw/excalidraw/i18n";
|
|
|
|
import type { Radians } from "@excalidraw/math";
|
|
|
|
import {
|
|
bindBindingElement,
|
|
getBindingGap,
|
|
updateBoundElements,
|
|
} from "../src/binding";
|
|
import { Scene } from "../src/Scene";
|
|
import { convertToExcalidrawElements } from "../src/transform";
|
|
import { getAllMidpoints } from "../src/utils";
|
|
import { getTransformHandles } from "../src/transformHandles";
|
|
import {
|
|
getTextEditor,
|
|
TEXT_EDITOR_SELECTOR,
|
|
} from "../../excalidraw/tests/queries/dom";
|
|
|
|
import type { RenderEnvironment } from "../src/renderEnvironment";
|
|
import type {
|
|
ExcalidrawArrowElement,
|
|
ExcalidrawBindableElement,
|
|
ExcalidrawLinearElement,
|
|
ExcalidrawTextElement,
|
|
FixedPointBinding,
|
|
NonDeleted,
|
|
} from "../src/types";
|
|
|
|
const { h } = window;
|
|
|
|
const mouse = new Pointer("mouse");
|
|
|
|
describe("binding for simple arrows", () => {
|
|
describe("when both endpoints are bound inside the same element", () => {
|
|
beforeEach(async () => {
|
|
mouse.reset();
|
|
|
|
await act(() => {
|
|
return setLanguage(defaultLang);
|
|
});
|
|
await render(<Excalidraw handleKeyboardGlobally={true} />);
|
|
});
|
|
|
|
it("should create an `inside` binding", () => {
|
|
// Create a rectangle
|
|
UI.clickTool("rectangle");
|
|
mouse.reset();
|
|
mouse.downAt(100, 100);
|
|
mouse.moveTo(200, 200);
|
|
mouse.up();
|
|
|
|
const rect = API.getSelectedElement();
|
|
|
|
// Draw arrow with endpoint inside the filled rectangle
|
|
UI.clickTool("arrow");
|
|
mouse.downAt(110, 110);
|
|
mouse.moveTo(160, 160);
|
|
mouse.up();
|
|
|
|
const arrow = API.getSelectedElement() as ExcalidrawLinearElement;
|
|
expect(arrow.x).toBe(110);
|
|
expect(arrow.y).toBe(110);
|
|
|
|
// Should bind to the rectangle since endpoint is inside
|
|
expect(arrow.startBinding?.elementId).toBe(rect.id);
|
|
expect(arrow.endBinding?.elementId).toBe(rect.id);
|
|
|
|
const startBinding = arrow.startBinding as FixedPointBinding;
|
|
expect(startBinding.fixedPoint[0]).toBeGreaterThanOrEqual(0);
|
|
expect(startBinding.fixedPoint[0]).toBeLessThanOrEqual(1);
|
|
expect(startBinding.fixedPoint[1]).toBeGreaterThanOrEqual(0);
|
|
expect(startBinding.fixedPoint[1]).toBeLessThanOrEqual(1);
|
|
expect(startBinding.mode).toBe("inside");
|
|
|
|
const endBinding = arrow.endBinding as FixedPointBinding;
|
|
expect(endBinding.fixedPoint[0]).toBeGreaterThanOrEqual(0);
|
|
expect(endBinding.fixedPoint[0]).toBeLessThanOrEqual(1);
|
|
expect(endBinding.fixedPoint[1]).toBeGreaterThanOrEqual(0);
|
|
expect(endBinding.fixedPoint[1]).toBeLessThanOrEqual(1);
|
|
expect(endBinding.mode).toBe("inside");
|
|
|
|
// Move the bindable
|
|
mouse.downAt(100, 150);
|
|
mouse.moveTo(280, 110);
|
|
mouse.up();
|
|
|
|
// Check if the arrow moved
|
|
expect(arrow.x).toBe(290);
|
|
expect(arrow.y).toBe(70);
|
|
|
|
// Restore bindable
|
|
mouse.reset();
|
|
mouse.downAt(280, 110);
|
|
mouse.moveTo(130, 110);
|
|
mouse.up();
|
|
|
|
// Move the start point of the arrow to check if
|
|
// the behavior remains the same for old arrows
|
|
mouse.reset();
|
|
mouse.downAt(110, 110);
|
|
mouse.moveTo(120, 120);
|
|
mouse.up();
|
|
|
|
// Move the bindable again
|
|
mouse.reset();
|
|
mouse.downAt(130, 110);
|
|
mouse.moveTo(280, 110);
|
|
mouse.up();
|
|
|
|
// Check if the arrow moved
|
|
expect(arrow.x).toBe(290);
|
|
expect(arrow.y).toBe(70);
|
|
});
|
|
|
|
it("3+ point arrow should be dragged along with the bindable", () => {
|
|
// Create two rectangles as binding targets
|
|
const rectLeft = API.createElement({
|
|
type: "rectangle",
|
|
x: 0,
|
|
y: 0,
|
|
width: 100,
|
|
height: 100,
|
|
});
|
|
|
|
const rectRight = API.createElement({
|
|
type: "rectangle",
|
|
x: 300,
|
|
y: 0,
|
|
width: 100,
|
|
height: 100,
|
|
});
|
|
|
|
// Create a non-elbowed arrow with inner points bound to different elements
|
|
const arrow = API.createElement({
|
|
type: "arrow",
|
|
x: 100,
|
|
y: 50,
|
|
width: 200,
|
|
height: 0,
|
|
points: [
|
|
pointFrom(0, 0), // start point
|
|
pointFrom(50, -20), // first inner point
|
|
pointFrom(150, 20), // second inner point
|
|
pointFrom(200, 0), // end point
|
|
],
|
|
startBinding: {
|
|
elementId: rectLeft.id,
|
|
fixedPoint: [0.5, 0.5],
|
|
mode: "orbit",
|
|
},
|
|
endBinding: {
|
|
elementId: rectRight.id,
|
|
fixedPoint: [0.5, 0.5],
|
|
mode: "orbit",
|
|
},
|
|
});
|
|
|
|
API.setElements([rectLeft, rectRight, arrow]);
|
|
|
|
// Store original inner point positions
|
|
const originalInnerPoint1 = [...arrow.points[1]];
|
|
const originalInnerPoint2 = [...arrow.points[2]];
|
|
|
|
// Move the right rectangle down by 50 pixels
|
|
mouse.reset();
|
|
mouse.downAt(350, 50); // Click on the right rectangle
|
|
mouse.moveTo(350, 100); // Move it down
|
|
mouse.up();
|
|
|
|
// Verify that inner points did NOT move when bound to different elements
|
|
// The arrow should NOT translate inner points proportionally when only one end moves
|
|
expect(arrow.points[1][0]).toBe(originalInnerPoint1[0]);
|
|
expect(arrow.points[1][1]).toBe(originalInnerPoint1[1]);
|
|
expect(arrow.points[2][0]).toBe(originalInnerPoint2[0]);
|
|
expect(arrow.points[2][1]).toBe(originalInnerPoint2[1]);
|
|
});
|
|
});
|
|
|
|
describe("self-binding (both ends to the same element) single-click finalize", () => {
|
|
// rect spans x:200..400, y:200..400; orbit ring is ~15px outside the outline
|
|
const INSIDE: [number, number] = [250, 250];
|
|
const ORBIT_LEFT: [number, number] = [187, 300];
|
|
const ORBIT_RIGHT: [number, number] = [413, 300];
|
|
const MIDDLE: [number, number] = [550, 100];
|
|
|
|
beforeEach(async () => {
|
|
mouse.reset();
|
|
await act(() => setLanguage(defaultLang));
|
|
await render(<Excalidraw handleKeyboardGlobally={true} />);
|
|
UI.createElement("rectangle", {
|
|
x: 200,
|
|
y: 200,
|
|
width: 200,
|
|
height: 200,
|
|
});
|
|
});
|
|
|
|
const drawSelfArrow = (start: [number, number], end: [number, number]) => {
|
|
UI.clickTool("arrow");
|
|
mouse.reset();
|
|
mouse.clickAt(...start);
|
|
mouse.moveTo(...MIDDLE);
|
|
mouse.clickAt(...MIDDLE); // commit a middle point so it's a multi-point arrow
|
|
mouse.moveTo(...end);
|
|
mouse.clickAt(...end); // single click at the end
|
|
};
|
|
|
|
it("orbit -> orbit finalizes on a single click", () => {
|
|
drawSelfArrow(ORBIT_LEFT, ORBIT_RIGHT);
|
|
|
|
const arrow = h.elements[h.elements.length - 1] as ExcalidrawArrowElement;
|
|
expect(h.state.multiElement).toBe(null);
|
|
expect(h.state.activeTool.type).toBe("selection");
|
|
expect(arrow.startBinding?.elementId).toBe(arrow.endBinding?.elementId);
|
|
expect(arrow.endBinding?.elementId).not.toBe(undefined);
|
|
});
|
|
|
|
it("inside -> orbit finalizes on a single click", () => {
|
|
drawSelfArrow(INSIDE, ORBIT_RIGHT);
|
|
|
|
const arrow = h.elements[h.elements.length - 1] as ExcalidrawArrowElement;
|
|
expect(h.state.multiElement).toBe(null);
|
|
expect(h.state.activeTool.type).toBe("selection");
|
|
expect(arrow.startBinding?.elementId).toBe(arrow.endBinding?.elementId);
|
|
expect(arrow.endBinding?.elementId).not.toBe(undefined);
|
|
});
|
|
|
|
it("inside -> inside keep in multi-point mode (no single-click finalize)", () => {
|
|
drawSelfArrow(INSIDE, [INSIDE[0] + 50, INSIDE[1] + 50]); // end dropped inside the rect
|
|
|
|
// ambiguous → must be confirmed with a second click, so still in progress
|
|
expect(h.state.multiElement).not.toBe(null);
|
|
expect(h.state.activeTool.type).toBe("arrow");
|
|
});
|
|
|
|
it("inside -> inside stays in multi-point mode when the pointer moves on", () => {
|
|
const end: [number, number] = [INSIDE[0] + 50, INSIDE[1] + 50];
|
|
drawSelfArrow(INSIDE, end);
|
|
// nudge within the commit zone of the point just placed
|
|
mouse.moveTo(end[0] + 2, end[1] + 1);
|
|
|
|
expect(h.state.multiElement).not.toBe(null);
|
|
expect(h.state.activeTool.type).toBe("arrow");
|
|
expect(h.state.multiElement!.points.length).toBe(3);
|
|
});
|
|
|
|
it("bend point inside a shape the arrow doesn't start on stays in multi-point mode when the pointer moves on", () => {
|
|
UI.clickTool("arrow");
|
|
mouse.reset();
|
|
mouse.clickAt(...MIDDLE);
|
|
mouse.moveTo(...INSIDE);
|
|
mouse.clickAt(...INSIDE);
|
|
mouse.moveTo(INSIDE[0] + 2, INSIDE[1] + 1);
|
|
|
|
expect(h.state.multiElement).not.toBe(null);
|
|
expect(h.state.activeTool.type).toBe("arrow");
|
|
expect(h.state.multiElement!.points.length).toBe(2);
|
|
});
|
|
});
|
|
|
|
describe("binding to frames", () => {
|
|
// frame spans x:200..600, y:200..600, child rect x:300..400, y:300..400
|
|
beforeEach(async () => {
|
|
mouse.reset();
|
|
await act(() => setLanguage(defaultLang));
|
|
await render(<Excalidraw handleKeyboardGlobally={true} />);
|
|
|
|
const frame = API.createElement({
|
|
id: "frame",
|
|
type: "frame",
|
|
x: 200,
|
|
y: 200,
|
|
width: 400,
|
|
height: 400,
|
|
});
|
|
const child = API.createElement({
|
|
id: "child",
|
|
type: "rectangle",
|
|
x: 300,
|
|
y: 300,
|
|
width: 100,
|
|
height: 100,
|
|
frameId: frame.id,
|
|
});
|
|
API.setElements([frame, child]);
|
|
});
|
|
|
|
const drawArrow = (end: [number, number]) => {
|
|
UI.clickTool("arrow");
|
|
mouse.reset();
|
|
mouse.downAt(50, 50);
|
|
mouse.moveTo(end[0] - 10, end[1] - 10);
|
|
mouse.moveTo(...end);
|
|
mouse.up();
|
|
|
|
return h.elements[h.elements.length - 1] as ExcalidrawArrowElement;
|
|
};
|
|
|
|
it("doesn't bind an arrow ending in the frame's empty interior", () => {
|
|
const arrow = drawArrow([500, 500]);
|
|
|
|
expect(arrow.endBinding).toBe(null);
|
|
});
|
|
|
|
it("binds an arrow ending on a frame child to the child", () => {
|
|
const arrow = drawArrow([350, 350]);
|
|
|
|
expect(arrow.endBinding?.elementId).toBe("child");
|
|
});
|
|
|
|
it("binds an arrow ending just outside the frame to the frame", () => {
|
|
const arrow = drawArrow([500, 610]);
|
|
|
|
expect(arrow.endBinding?.elementId).toBe("frame");
|
|
expect(arrow.endBinding?.mode).toBe("orbit");
|
|
});
|
|
|
|
it("keeps an elbow arrow drawn inside the frame where it was drawn", () => {
|
|
UI.clickTool("arrow");
|
|
UI.clickOnTestId("elbow-arrow");
|
|
mouse.reset();
|
|
mouse.downAt(250, 250);
|
|
mouse.moveTo(400, 450);
|
|
mouse.moveTo(550, 550);
|
|
mouse.up();
|
|
|
|
const arrow = h.elements[h.elements.length - 1] as ExcalidrawArrowElement;
|
|
expect(arrow.elbowed).toBe(true);
|
|
// no self-orbit binding to the frame, which would route the arrow
|
|
// around the frame's outside
|
|
expect(arrow.startBinding).toBe(null);
|
|
expect(arrow.endBinding).toBe(null);
|
|
expect(arrow.frameId).toBe("frame");
|
|
expect([arrow.x, arrow.y]).toEqual([250, 250]);
|
|
expect(arrow.points[arrow.points.length - 1]).toEqual([300, 300]);
|
|
});
|
|
});
|
|
|
|
describe("binding at an ellipse's center", () => {
|
|
beforeEach(async () => {
|
|
mouse.reset();
|
|
await act(() => setLanguage(defaultLang));
|
|
await render(<Excalidraw handleKeyboardGlobally={true} />);
|
|
});
|
|
|
|
it("binds an arrow dropped at a circle's exact center", () => {
|
|
const circle = API.createElement({
|
|
type: "ellipse",
|
|
x: 100,
|
|
y: -100,
|
|
width: 200,
|
|
height: 200,
|
|
});
|
|
API.setElements([circle]);
|
|
|
|
UI.clickTool("arrow");
|
|
mouse.reset();
|
|
mouse.downAt(-100, 0);
|
|
mouse.moveTo(100, 0);
|
|
mouse.moveTo(200, 0);
|
|
mouse.up();
|
|
|
|
const arrow = h.elements[h.elements.length - 1] as ExcalidrawArrowElement;
|
|
expect(arrow.endBinding?.elementId).toBe(circle.id);
|
|
});
|
|
});
|
|
|
|
describe("midpoint snapping on diamonds", () => {
|
|
beforeEach(async () => {
|
|
mouse.reset();
|
|
await act(() => setLanguage(defaultLang));
|
|
await render(<Excalidraw handleKeyboardGlobally={true} />);
|
|
});
|
|
|
|
for (const rounded of [false, true]) {
|
|
for (const elbowed of [false, true]) {
|
|
it(`${
|
|
elbowed ? "elbow" : "simple"
|
|
} arrow ends a binding gap outside the ${
|
|
rounded ? "rounded" : "sharp"
|
|
} left vertex`, () => {
|
|
const diamond = API.createElement({
|
|
type: "diamond",
|
|
x: 100,
|
|
y: -100,
|
|
width: 200,
|
|
height: 200,
|
|
roundness: rounded ? { type: ROUNDNESS.PROPORTIONAL_RADIUS } : null,
|
|
}) as ExcalidrawBindableElement;
|
|
API.setElements([diamond]);
|
|
const [, , left] = getAllMidpoints(diamond, arrayToMap([diamond]));
|
|
|
|
UI.clickTool("arrow");
|
|
if (elbowed) {
|
|
UI.clickOnTestId("elbow-arrow");
|
|
}
|
|
mouse.reset();
|
|
mouse.downAt(-200, left[1]);
|
|
mouse.moveTo(left[0] - 50, left[1]);
|
|
// near (not on) the vertex, so the end snaps to it
|
|
mouse.moveTo(left[0] - 4, left[1] + 2);
|
|
mouse.up();
|
|
|
|
const arrow = h.elements[
|
|
h.elements.length - 1
|
|
] as ExcalidrawArrowElement;
|
|
const [endX, endY] = arrow.points[arrow.points.length - 1];
|
|
|
|
expect(arrow.endBinding?.elementId).toBe(diamond.id);
|
|
expect(arrow.x + endX).toBeCloseTo(
|
|
left[0] - getBindingGap(diamond),
|
|
0,
|
|
);
|
|
expect(arrow.y + endY).toBeCloseTo(left[1], 0);
|
|
});
|
|
}
|
|
|
|
it(`elbow arrow binds above the ${
|
|
rounded ? "rounded" : "sharp"
|
|
} top vertex when the pointer is slightly inside`, () => {
|
|
const diamond = API.createElement({
|
|
type: "diamond",
|
|
x: 100,
|
|
y: -100,
|
|
width: 300,
|
|
height: 300,
|
|
roundness: rounded ? { type: ROUNDNESS.PROPORTIONAL_RADIUS } : null,
|
|
}) as ExcalidrawBindableElement;
|
|
API.setElements([diamond]);
|
|
const [, , , top] = getAllMidpoints(diamond, arrayToMap([diamond]));
|
|
|
|
UI.clickTool("arrow");
|
|
UI.clickOnTestId("elbow-arrow");
|
|
mouse.reset();
|
|
mouse.downAt(top[0] - 300, top[1] - 100);
|
|
mouse.moveTo(top[0] - 50, top[1] - 50);
|
|
// inside the diamond, a bit right of the vertex
|
|
mouse.moveTo(top[0] + 3, top[1] + 10);
|
|
mouse.up();
|
|
|
|
const arrow = h.elements[
|
|
h.elements.length - 1
|
|
] as ExcalidrawArrowElement;
|
|
const points = arrow.points;
|
|
const [endX, endY] = points[points.length - 1];
|
|
|
|
expect(arrow.endBinding?.elementId).toBe(diamond.id);
|
|
expect(arrow.x + endX).toBeCloseTo(top[0], 0);
|
|
expect(arrow.y + endY).toBeCloseTo(top[1] - getBindingGap(diamond), 0);
|
|
// the last segment comes straight down into the vertex
|
|
expect(points[points.length - 2][0]).toBeCloseTo(endX);
|
|
});
|
|
}
|
|
|
|
it("elbow arrow binds next to the tip of a thin rotated diamond", () => {
|
|
const diamond = API.createElement({
|
|
type: "diamond",
|
|
x: 0,
|
|
y: 0,
|
|
width: 600,
|
|
height: 100,
|
|
angle: ((15 * Math.PI) / 180) as Radians,
|
|
roundness: { type: ROUNDNESS.PROPORTIONAL_RADIUS },
|
|
}) as ExcalidrawBindableElement;
|
|
API.setElements([diamond]);
|
|
const [right] = getAllMidpoints(diamond, arrayToMap([diamond]));
|
|
|
|
UI.clickTool("arrow");
|
|
UI.clickOnTestId("elbow-arrow");
|
|
mouse.reset();
|
|
mouse.downAt(right[0] + 300, right[1] + 300);
|
|
mouse.moveTo(right[0] + 50, right[1] + 50);
|
|
// just outside the right tip
|
|
mouse.moveTo(right[0] + 4, right[1] + 1);
|
|
mouse.up();
|
|
|
|
const arrow = h.elements[h.elements.length - 1] as ExcalidrawArrowElement;
|
|
const [endX, endY] = arrow.points[arrow.points.length - 1];
|
|
|
|
expect(arrow.endBinding?.elementId).toBe(diamond.id);
|
|
// a binding gap away, not on another edge of the diamond
|
|
expect(
|
|
Math.hypot(arrow.x + endX - right[0], arrow.y + endY - right[1]),
|
|
).toBeLessThan(getBindingGap(diamond) + 2);
|
|
});
|
|
|
|
it("elbow arrow snaps to a diamond's edge midpoint", () => {
|
|
const diamond = API.createElement({
|
|
type: "diamond",
|
|
x: 100,
|
|
y: -100,
|
|
width: 200,
|
|
height: 200,
|
|
}) as ExcalidrawBindableElement;
|
|
API.setElements([diamond]);
|
|
// midpoint of the top-left edge
|
|
const edgeMidpoint = [150, -50] as const;
|
|
|
|
UI.clickTool("arrow");
|
|
UI.clickOnTestId("elbow-arrow");
|
|
mouse.reset();
|
|
mouse.downAt(-200, -50);
|
|
mouse.moveTo(100, -60);
|
|
// near (not on) the edge midpoint
|
|
mouse.moveTo(edgeMidpoint[0] - 9, edgeMidpoint[1] - 3);
|
|
mouse.up();
|
|
|
|
const arrow = h.elements[h.elements.length - 1] as ExcalidrawArrowElement;
|
|
const [, endY] = arrow.points[arrow.points.length - 1];
|
|
|
|
expect(arrow.endBinding?.elementId).toBe(diamond.id);
|
|
expect(arrow.y + endY).toBeCloseTo(edgeMidpoint[1], 0);
|
|
});
|
|
});
|
|
|
|
describe("when arrow is outside of shape", () => {
|
|
beforeEach(async () => {
|
|
mouse.reset();
|
|
|
|
await act(() => {
|
|
return setLanguage(defaultLang);
|
|
});
|
|
await render(<Excalidraw handleKeyboardGlobally={true} />);
|
|
});
|
|
|
|
it("should handle new arrow start point binding", () => {
|
|
// Create a rectangle
|
|
UI.clickTool("rectangle");
|
|
mouse.downAt(100, 100);
|
|
mouse.moveTo(200, 200);
|
|
mouse.up();
|
|
|
|
const rectangle = API.getSelectedElement();
|
|
|
|
// Create arrow with arrow tool
|
|
UI.clickTool("arrow");
|
|
mouse.downAt(205, 150); // Start close to rectangle
|
|
mouse.moveTo(250, 150); // End outside
|
|
mouse.up();
|
|
|
|
const arrow = API.getSelectedElement() as ExcalidrawLinearElement;
|
|
|
|
// Arrow should have start binding to rectangle
|
|
expect(arrow.startBinding?.elementId).toBe(rectangle.id);
|
|
expect(arrow.startBinding?.mode).toBe("orbit"); // Default is orbit, not inside
|
|
expect(arrow.endBinding).toBeNull();
|
|
});
|
|
|
|
it("should handle new arrow end point binding", () => {
|
|
// Create a rectangle
|
|
UI.clickTool("rectangle");
|
|
mouse.downAt(100, 100);
|
|
mouse.moveTo(200, 200);
|
|
mouse.up();
|
|
|
|
const rectangle = API.getSelectedElement();
|
|
|
|
// Create arrow with end point in binding zone
|
|
UI.clickTool("arrow");
|
|
mouse.downAt(50, 150); // Start outside
|
|
mouse.moveTo(95, 95); // End near rectangle edge (should bind as orbit)
|
|
mouse.up();
|
|
|
|
const arrow = API.getSelectedElement() as ExcalidrawLinearElement;
|
|
|
|
// Arrow should have end binding to rectangle
|
|
expect(arrow.endBinding?.elementId).toBe(rectangle.id);
|
|
expect(arrow.endBinding?.mode).toBe("orbit");
|
|
expect(arrow.startBinding).toBeNull();
|
|
});
|
|
|
|
it.skip("should create orbit binding when one of the cursor is inside rectangle", () => {
|
|
// Create a filled solid rectangle
|
|
UI.clickTool("rectangle");
|
|
mouse.downAt(100, 100);
|
|
mouse.moveTo(200, 200);
|
|
mouse.up();
|
|
|
|
const rect = API.getSelectedElement();
|
|
API.updateElement(rect, {
|
|
fillStyle: "solid",
|
|
backgroundColor: "#a5d8ff",
|
|
});
|
|
|
|
// Draw arrow with endpoint inside the filled rectangle, since only
|
|
// filled bindables bind inside the shape
|
|
UI.clickTool("arrow");
|
|
mouse.downAt(10, 10);
|
|
mouse.moveTo(160, 160);
|
|
mouse.up();
|
|
|
|
const arrow = API.getSelectedElement() as ExcalidrawLinearElement;
|
|
expect(arrow.x).toBe(10);
|
|
expect(arrow.y).toBe(10);
|
|
expect(arrow.width).toBeCloseTo(85.75985931287957);
|
|
expect(arrow.height).toBeCloseTo(85.75985931288186);
|
|
|
|
// Should bind to the rectangle since endpoint is inside
|
|
expect(arrow.startBinding).toBe(null);
|
|
expect(arrow.endBinding?.elementId).toBe(rect.id);
|
|
|
|
const endBinding = arrow.endBinding as FixedPointBinding;
|
|
expect(endBinding.fixedPoint[0]).toBeGreaterThanOrEqual(0);
|
|
expect(endBinding.fixedPoint[0]).toBeLessThanOrEqual(1);
|
|
expect(endBinding.fixedPoint[1]).toBeGreaterThanOrEqual(0);
|
|
expect(endBinding.fixedPoint[1]).toBeLessThanOrEqual(1);
|
|
|
|
mouse.reset();
|
|
|
|
// Move the bindable
|
|
mouse.downAt(130, 110);
|
|
mouse.moveTo(280, 110);
|
|
mouse.up();
|
|
|
|
// Check if the arrow moved
|
|
expect(arrow.x).toBe(10);
|
|
expect(arrow.y).toBe(10);
|
|
expect(arrow.width).toBeCloseTo(234);
|
|
expect(arrow.height).toBeCloseTo(117);
|
|
|
|
// Restore bindable
|
|
mouse.reset();
|
|
mouse.downAt(280, 110);
|
|
mouse.moveTo(130, 110);
|
|
mouse.up();
|
|
|
|
// Move the arrow out
|
|
mouse.reset();
|
|
mouse.click(10, 10);
|
|
mouse.downAt(96.466, 96.466);
|
|
mouse.moveTo(50, 50);
|
|
mouse.up();
|
|
|
|
expect(arrow.startBinding).toBe(null);
|
|
expect(arrow.endBinding).toBe(null);
|
|
|
|
// Re-bind the arrow by moving the cursor inside the rectangle
|
|
mouse.reset();
|
|
mouse.downAt(50, 50);
|
|
mouse.moveTo(150, 150);
|
|
mouse.up();
|
|
|
|
// Check if the arrow is still on the outside
|
|
expect(arrow.width).toBeCloseTo(86, 0);
|
|
expect(arrow.height).toBeCloseTo(86, 0);
|
|
});
|
|
});
|
|
|
|
describe("additional binding behavior", () => {
|
|
beforeEach(async () => {
|
|
mouse.reset();
|
|
|
|
await act(() => {
|
|
return setLanguage(defaultLang);
|
|
});
|
|
await render(<Excalidraw handleKeyboardGlobally={true} />);
|
|
});
|
|
|
|
it(
|
|
"editing arrow and moving its head to bind it to element A, finalizing the" +
|
|
"editing by clicking on element A should end up selecting A",
|
|
async () => {
|
|
UI.createElement("rectangle", {
|
|
y: 0,
|
|
size: 100,
|
|
});
|
|
// Create arrow bound to rectangle
|
|
UI.clickTool("arrow");
|
|
mouse.down(50, -100);
|
|
mouse.up(0, 80);
|
|
|
|
// Edit arrow
|
|
Keyboard.withModifierKeys({ ctrl: true }, () => {
|
|
Keyboard.keyPress(KEYS.ENTER);
|
|
});
|
|
|
|
// move arrow head
|
|
mouse.down();
|
|
mouse.up(0, 10);
|
|
expect(API.getSelectedElement().type).toBe("arrow");
|
|
|
|
expect(h.state.selectedLinearElement?.isEditing).toBe(true);
|
|
mouse.reset();
|
|
mouse.clickAt(-50, -50);
|
|
expect(h.state.selectedLinearElement?.isEditing).toBe(false);
|
|
expect(API.getSelectedElement().type).toBe("arrow");
|
|
|
|
// Edit arrow
|
|
Keyboard.withModifierKeys({ ctrl: true }, () => {
|
|
Keyboard.keyPress(KEYS.ENTER);
|
|
});
|
|
expect(h.state.selectedLinearElement?.isEditing).toBe(true);
|
|
mouse.reset();
|
|
mouse.clickAt(0, 0);
|
|
expect(h.state.selectedLinearElement).toBeNull();
|
|
expect(API.getSelectedElement().type).toBe("rectangle");
|
|
},
|
|
);
|
|
|
|
it("should unbind on bound element deletion", () => {
|
|
const rectangle = UI.createElement("rectangle", {
|
|
x: 60,
|
|
y: 0,
|
|
size: 100,
|
|
});
|
|
|
|
const arrow = UI.createElement("arrow", {
|
|
x: 0,
|
|
y: 5,
|
|
size: 70,
|
|
});
|
|
|
|
expect(arrow.endBinding?.elementId).toBe(rectangle.id);
|
|
|
|
mouse.select(rectangle);
|
|
expect(API.getSelectedElement().type).toBe("rectangle");
|
|
Keyboard.keyDown(KEYS.DELETE);
|
|
expect(arrow.endBinding).toBe(null);
|
|
});
|
|
|
|
it("should unbind arrow when arrow is resized", () => {
|
|
const rectLeft = UI.createElement("rectangle", {
|
|
x: 0,
|
|
width: 200,
|
|
height: 500,
|
|
});
|
|
const rectRight = UI.createElement("rectangle", {
|
|
x: 400,
|
|
width: 200,
|
|
height: 500,
|
|
});
|
|
UI.clickTool("arrow");
|
|
mouse.reset();
|
|
mouse.clickAt(190, 250);
|
|
mouse.moveTo(220, 200);
|
|
mouse.moveTo(300, 200);
|
|
mouse.clickAt(300, 200);
|
|
mouse.moveTo(340, 251);
|
|
mouse.moveTo(410, 251);
|
|
mouse.clickAt(410, 251);
|
|
mouse.clickAt(410, 251);
|
|
const arrow = h.elements[h.elements.length - 1] as any;
|
|
|
|
expect(arrow.startBinding?.elementId).toBe(rectLeft.id);
|
|
expect(arrow.endBinding?.elementId).toBe(rectRight.id);
|
|
|
|
// Drag arrow off of bound rectangle range
|
|
const handles = getTransformHandles(
|
|
arrow,
|
|
h.state.zoom,
|
|
arrayToMap(h.elements),
|
|
"mouse",
|
|
).se!;
|
|
|
|
const elX = handles[0] + handles[2] / 2;
|
|
const elY = handles[1] + handles[3] / 2;
|
|
// move first, as a real pointer would — the hover state from the spot
|
|
// where arrow creation finished must clear before the pointerdown
|
|
mouse.moveTo(elX, elY);
|
|
mouse.downAt(elX, elY);
|
|
mouse.moveTo(300, 400);
|
|
mouse.up();
|
|
|
|
expect(arrow.startBinding).toBe(null);
|
|
expect(arrow.endBinding).toBe(null);
|
|
});
|
|
|
|
it("should unbind arrow when arrow is rotated", () => {
|
|
const rectLeft = UI.createElement("rectangle", {
|
|
x: 0,
|
|
width: 200,
|
|
height: 500,
|
|
});
|
|
const rectRight = UI.createElement("rectangle", {
|
|
x: 400,
|
|
width: 200,
|
|
height: 500,
|
|
});
|
|
|
|
UI.clickTool("arrow");
|
|
mouse.reset();
|
|
mouse.clickAt(190, 250);
|
|
mouse.moveTo(220, 200);
|
|
mouse.moveTo(300, 200);
|
|
mouse.clickAt(300, 200);
|
|
mouse.moveTo(350, 251);
|
|
mouse.moveTo(410, 251);
|
|
mouse.clickAt(410, 251);
|
|
mouse.clickAt(410, 251);
|
|
|
|
const arrow = API.getSelectedElement() as ExcalidrawArrowElement;
|
|
|
|
expect(arrow.startBinding?.elementId).toBe(rectLeft.id);
|
|
expect(arrow.endBinding?.elementId).toBe(rectRight.id);
|
|
|
|
const rotation = getTransformHandles(
|
|
arrow,
|
|
h.state.zoom,
|
|
arrayToMap(h.elements),
|
|
"mouse",
|
|
).rotation!;
|
|
const rotationHandleX = rotation[0] + rotation[2] / 2;
|
|
const rotationHandleY = rotation[1] + rotation[3] / 2;
|
|
mouse.reset();
|
|
mouse.down(rotationHandleX, rotationHandleY);
|
|
mouse.move(300, 400);
|
|
mouse.up();
|
|
expect(arrow.angle).toBeGreaterThan(0.7 * Math.PI);
|
|
expect(arrow.angle).toBeLessThan(1.3 * Math.PI);
|
|
expect(arrow.startBinding).toBeNull();
|
|
expect(arrow.endBinding).toBeNull();
|
|
});
|
|
|
|
it("should not unbind when duplicating via selection group", () => {
|
|
const rectLeft = UI.createElement("rectangle", {
|
|
x: 0,
|
|
width: 200,
|
|
height: 500,
|
|
});
|
|
const rectRight = UI.createElement("rectangle", {
|
|
x: 400,
|
|
y: 200,
|
|
width: 200,
|
|
height: 500,
|
|
});
|
|
const arrow = UI.createElement("arrow", {
|
|
x: 190,
|
|
y: 250,
|
|
width: 217,
|
|
height: 1,
|
|
});
|
|
expect(arrow.startBinding?.elementId).toBe(rectLeft.id);
|
|
expect(arrow.endBinding?.elementId).toBe(rectRight.id);
|
|
|
|
mouse.downAt(-100, -100);
|
|
mouse.moveTo(0, 0);
|
|
mouse.moveTo(650, 750);
|
|
mouse.up(0, 0);
|
|
|
|
expect(API.getSelectedElements().length).toBe(3);
|
|
|
|
mouse.moveTo(5, 5);
|
|
Keyboard.withModifierKeys({ alt: true }, () => {
|
|
mouse.downAt(5, 5);
|
|
mouse.moveTo(1000, 1000);
|
|
mouse.up(0, 0);
|
|
|
|
expect(window.h.elements.length).toBe(6);
|
|
window.h.elements.forEach((element) => {
|
|
if (isLinearElement(element)) {
|
|
expect(element.startBinding).not.toBe(null);
|
|
expect(element.endBinding).not.toBe(null);
|
|
} else {
|
|
expect(element.boundElements).not.toBe(null);
|
|
}
|
|
});
|
|
});
|
|
});
|
|
});
|
|
|
|
describe("to text elements", () => {
|
|
beforeEach(async () => {
|
|
mouse.reset();
|
|
|
|
await act(() => {
|
|
return setLanguage(defaultLang);
|
|
});
|
|
await render(<Excalidraw handleKeyboardGlobally={true} />);
|
|
});
|
|
|
|
it("should update binding when text containerized", async () => {
|
|
const rectangle1 = API.createElement({
|
|
type: "rectangle",
|
|
id: "rectangle1",
|
|
width: 100,
|
|
height: 100,
|
|
boundElements: [
|
|
{ id: "arrow1", type: "arrow" },
|
|
{ id: "arrow2", type: "arrow" },
|
|
],
|
|
});
|
|
|
|
const arrow1 = API.createElement({
|
|
type: "arrow",
|
|
id: "arrow1",
|
|
points: [pointFrom(0, 0), pointFrom(0, -87.45777932247563)],
|
|
startBinding: {
|
|
elementId: "rectangle1",
|
|
fixedPoint: [0.5, 1],
|
|
mode: "orbit",
|
|
},
|
|
endBinding: {
|
|
elementId: "text1",
|
|
fixedPoint: [1, 0.5],
|
|
mode: "orbit",
|
|
},
|
|
});
|
|
|
|
const arrow2 = API.createElement({
|
|
type: "arrow",
|
|
id: "arrow2",
|
|
points: [pointFrom(0, 0), pointFrom(0, -87.45777932247563)],
|
|
startBinding: {
|
|
elementId: "text1",
|
|
fixedPoint: [0.5, 1],
|
|
mode: "orbit",
|
|
},
|
|
endBinding: {
|
|
elementId: "rectangle1",
|
|
fixedPoint: [1, 0.5],
|
|
mode: "orbit",
|
|
},
|
|
});
|
|
|
|
const text1 = API.createElement({
|
|
type: "text",
|
|
id: "text1",
|
|
text: "ola",
|
|
boundElements: [
|
|
{ id: "arrow1", type: "arrow" },
|
|
{ id: "arrow2", type: "arrow" },
|
|
],
|
|
});
|
|
|
|
API.setElements([rectangle1, arrow1, arrow2, text1]);
|
|
|
|
API.setSelectedElements([text1]);
|
|
|
|
expect(h.state.selectedElementIds[text1.id]).toBe(true);
|
|
|
|
API.executeAction(actionWrapTextInContainer);
|
|
|
|
// new text container will be placed before the text element
|
|
const container = h.elements.at(-2)!;
|
|
|
|
expect(container.type).toBe("rectangle");
|
|
expect(container.id).not.toBe(rectangle1.id);
|
|
|
|
expect(container).toEqual(
|
|
expect.objectContaining({
|
|
boundElements: expect.arrayContaining([
|
|
{
|
|
type: "text",
|
|
id: text1.id,
|
|
},
|
|
{
|
|
type: "arrow",
|
|
id: arrow1.id,
|
|
},
|
|
{
|
|
type: "arrow",
|
|
id: arrow2.id,
|
|
},
|
|
]),
|
|
}),
|
|
);
|
|
|
|
expect(arrow1.startBinding?.elementId).toBe(rectangle1.id);
|
|
expect(arrow1.endBinding?.elementId).toBe(container.id);
|
|
expect(arrow2.startBinding?.elementId).toBe(container.id);
|
|
expect(arrow2.endBinding?.elementId).toBe(rectangle1.id);
|
|
});
|
|
|
|
it("should keep binding on text update", async () => {
|
|
const text = API.createElement({
|
|
type: "text",
|
|
text: "ola",
|
|
x: 60,
|
|
y: 0,
|
|
width: 100,
|
|
height: 100,
|
|
});
|
|
|
|
API.setElements([text]);
|
|
|
|
const arrow = UI.createElement("arrow", {
|
|
x: 0,
|
|
y: 0,
|
|
size: 65,
|
|
});
|
|
|
|
expect(arrow.endBinding?.elementId).toBe(text.id);
|
|
|
|
// delete text element by submitting empty text
|
|
// -------------------------------------------------------------------------
|
|
|
|
UI.clickTool("text");
|
|
|
|
mouse.clickAt(text.x + 50, text.y + 50);
|
|
const editor = await getTextEditor();
|
|
|
|
expect(editor).not.toBe(null);
|
|
|
|
fireEvent.change(editor, { target: { value: "asdasdasdasdas" } });
|
|
fireEvent.keyDown(editor, { key: KEYS.ESCAPE });
|
|
|
|
expect(document.querySelector(TEXT_EDITOR_SELECTOR)).toBe(null);
|
|
expect(arrow.endBinding?.elementId).toBe(text.id);
|
|
});
|
|
|
|
it("should unbind on text element deletion by submitting empty text", async () => {
|
|
const text = API.createElement({
|
|
type: "text",
|
|
text: "¡olá!",
|
|
x: 60,
|
|
y: 0,
|
|
width: 100,
|
|
height: 100,
|
|
});
|
|
|
|
API.setElements([text]);
|
|
|
|
const arrow = UI.createElement("arrow", {
|
|
x: 0,
|
|
y: 0,
|
|
size: 65,
|
|
});
|
|
|
|
expect(arrow.endBinding?.elementId).toBe(text.id);
|
|
|
|
// edit text element and submit
|
|
// -------------------------------------------------------------------------
|
|
|
|
UI.clickTool("text");
|
|
|
|
mouse.clickAt(text.x + 50, text.y + 50);
|
|
|
|
const editor = await getTextEditor();
|
|
|
|
fireEvent.change(editor, { target: { value: "" } });
|
|
fireEvent.keyDown(editor, { key: KEYS.ESCAPE });
|
|
|
|
expect(document.querySelector(TEXT_EDITOR_SELECTOR)).toBe(null);
|
|
expect(arrow.endBinding).toBe(null);
|
|
});
|
|
});
|
|
});
|
|
|
|
describe("binding to a point-like (sub-pixel) element", () => {
|
|
beforeEach(async () => {
|
|
mouse.reset();
|
|
await act(() => setLanguage(defaultLang));
|
|
await render(<Excalidraw handleKeyboardGlobally={true} />);
|
|
});
|
|
|
|
// Regression: binding to a zero/near-zero-size element used to yield an
|
|
// enormous fixedPoint ratio (offset / ~0), which exploded into an arrow
|
|
// hundreds of thousands of px wide once the element was resized to a normal
|
|
// size
|
|
it.each([
|
|
["simple", false],
|
|
["elbow", true],
|
|
])(
|
|
"%s arrow binds to the center and stays put when the element grows",
|
|
(_label, elbowed) => {
|
|
const rect = API.createElement({
|
|
type: "rectangle",
|
|
x: 200,
|
|
y: 50,
|
|
width: 0.00005,
|
|
height: 0.00005,
|
|
}) as NonDeleted<ExcalidrawBindableElement>;
|
|
const arrow = API.createElement({
|
|
type: "arrow",
|
|
elbowed,
|
|
x: 0,
|
|
y: 50,
|
|
width: 195,
|
|
height: 0,
|
|
points: [pointFrom(0, 0), pointFrom(195, 0)],
|
|
}) as NonDeleted<ExcalidrawArrowElement>;
|
|
API.setElements([rect, arrow]);
|
|
|
|
bindBindingElement(arrow, rect, "orbit", "end", h.scene, DEFAULT_ZOOM);
|
|
|
|
const endBinding = arrow.endBinding as FixedPointBinding;
|
|
expect(endBinding.elementId).toBe(rect.id);
|
|
// Point-like element => bind to center (0.5 is normalized to 0.5001)
|
|
expect(endBinding.fixedPoint[0]).toBeCloseTo(0.5001);
|
|
expect(endBinding.fixedPoint[1]).toBeCloseTo(0.5001);
|
|
|
|
// Grow the element to a normal size and let bound arrows follow
|
|
h.scene.mutateElement(rect, { width: 300, height: 200 });
|
|
updateBoundElements(rect, h.scene);
|
|
|
|
// The arrow endpoint must track the element (its center), not fly off
|
|
expect(Math.abs(arrow.width)).toBeLessThan(1000);
|
|
expect(Math.abs(arrow.height)).toBeLessThan(1000);
|
|
},
|
|
);
|
|
});
|
|
|
|
describe("updateBoundElements with a render environment", () => {
|
|
it("re-measures bound arrow labels with the given environment", () => {
|
|
const renderEnvironment: RenderEnvironment = {
|
|
createCanvas: () => document.createElement("canvas"),
|
|
createImage: () => ({} as HTMLImageElement),
|
|
textMetrics: { getLineWidth: (text) => text.length * 5 },
|
|
};
|
|
const scene = new Scene(
|
|
convertToExcalidrawElements(
|
|
[
|
|
{ type: "rectangle", id: "A", x: 0, y: 0, width: 100, height: 100 },
|
|
{ type: "rectangle", id: "B", x: 400, y: 0, width: 100, height: 100 },
|
|
{
|
|
type: "arrow",
|
|
x: 100,
|
|
y: 50,
|
|
points: [pointFrom(0, 0), pointFrom(300, 0)],
|
|
start: { id: "A" },
|
|
end: { id: "B" },
|
|
label: { text: "aaaa bbbb cccc dddd eeee ffff" },
|
|
},
|
|
],
|
|
{ regenerateIds: false, renderEnvironment },
|
|
),
|
|
{ skipValidation: true },
|
|
);
|
|
const label = scene
|
|
.getNonDeletedElements()
|
|
.find((element) => element.type === "text") as ExcalidrawTextElement;
|
|
const rectB = scene.getElement(
|
|
"B",
|
|
) as NonDeleted<ExcalidrawBindableElement>;
|
|
|
|
expect(label.text).toBe("aaaa bbbb cccc dddd eeee ffff");
|
|
expect(label.width).toBe(145);
|
|
|
|
// as the drag does: move a bound shape, then its arrows (whose label the
|
|
// default metrics would wrap after "dddd", 190px wide)
|
|
scene.mutateElement(rectB, { x: rectB.x + 1 });
|
|
updateBoundElements(rectB, scene, { renderEnvironment });
|
|
|
|
expect(label.text).toBe("aaaa bbbb cccc dddd eeee ffff");
|
|
expect(label.width).toBe(145);
|
|
});
|
|
});
|