Mirrors/figcraft
1
0 Fork 0
mirror of https://github.com/storytold/figcraft.git synced 2026-11-13 01:11:11 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge main into #2200

Browse Source
This commit is contained in:
bflatastic committed 2026-11-12 09:46:31 +07:00
2 parents accdfbae26 5975f4d4c6
commit 31f014286e
119 files changed
+7247 -253
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

Cargo.lock
Generated
+22 -22
View File
@@ -1785,7 +1785,7 @@ checksum = "b97b65636e5b9ef369943878ac74335ba1c55c1cb6adbf1e2c293c624248d693"
[[package]]
name = "figcraft"
version = "0.18.0"
version = "0.18.1"
dependencies = [
"arboard",
"craft-menu",
@@ -1817,7 +1817,7 @@ dependencies = [
[[package]]
name = "figcraft-cli"
version = "0.18.0"
version = "0.18.1"
dependencies = [
"clap",
"clap_complete",
@@ -1835,7 +1835,7 @@ dependencies = [
[[package]]
name = "figcraft-collab"
version = "0.18.0"
version = "0.18.1"
dependencies = [
"base64 0.22.1",
"chrono",
@@ -1853,7 +1853,7 @@ dependencies = [
[[package]]
name = "figcraft-collab-net"
version = "0.18.0"
version = "0.18.1"
dependencies = [
"base64 0.22.1",
"figcraft-collab",
@@ -1876,7 +1876,7 @@ dependencies = [
[[package]]
name = "figcraft-color"
version = "0.18.0"
version = "0.18.1"
dependencies = [
"kurbo",
"serde",
@@ -1885,7 +1885,7 @@ dependencies = [
[[package]]
name = "figcraft-doc"
version = "0.18.0"
version = "0.18.1"
dependencies = [
"figcraft-color",
"figcraft-geom",
@@ -1898,7 +1898,7 @@ dependencies = [
[[package]]
name = "figcraft-engine"
version = "0.18.0"
version = "0.18.1"
dependencies = [
"base64 0.22.1",
"craft-docpath",
@@ -1932,7 +1932,7 @@ dependencies = [
[[package]]
name = "figcraft-format"
version = "0.18.0"
version = "0.18.1"
dependencies = [
"figcraft-doc",
"figcraft-layout",
@@ -1949,7 +1949,7 @@ dependencies = [
[[package]]
name = "figcraft-geom"
version = "0.18.0"
version = "0.18.1"
dependencies = [
"kurbo",
"serde",
@@ -1957,7 +1957,7 @@ dependencies = [
[[package]]
name = "figcraft-layout"
version = "0.18.0"
version = "0.18.1"
dependencies = [
"figcraft-doc",
"figcraft-geom",
@@ -1965,7 +1965,7 @@ dependencies = [
[[package]]
name = "figcraft-mcp"
version = "0.18.0"
version = "0.18.1"
dependencies = [
"base64 0.22.1",
"figcraft-collab-net",
@@ -1981,7 +1981,7 @@ dependencies = [
[[package]]
name = "figcraft-pathops"
version = "0.18.0"
version = "0.18.1"
dependencies = [
"figcraft-doc",
"figcraft-geom",
@@ -1990,7 +1990,7 @@ dependencies = [
[[package]]
name = "figcraft-pdf"
version = "0.18.0"
version = "0.18.1"
dependencies = [
"figcraft-color",
"figcraft-doc",
@@ -2007,7 +2007,7 @@ dependencies = [
[[package]]
name = "figcraft-plugin"
version = "0.18.0"
version = "0.18.1"
dependencies = [
"figcraft-color",
"serde",
@@ -2020,7 +2020,7 @@ dependencies = [
[[package]]
name = "figcraft-render"
version = "0.18.0"
version = "0.18.1"
dependencies = [
"crc32fast",
"figcraft-color",
@@ -2039,7 +2039,7 @@ dependencies = [
[[package]]
name = "figcraft-server"
version = "0.18.0"
version = "0.18.1"
dependencies = [
"chrono",
"crc32fast",
@@ -2064,7 +2064,7 @@ dependencies = [
[[package]]
name = "figcraft-svg"
version = "0.18.0"
version = "0.18.1"
dependencies = [
"base64 0.22.1",
"figcraft-color",
@@ -2080,7 +2080,7 @@ dependencies = [
[[package]]
name = "figcraft-text"
version = "0.18.0"
version = "0.18.1"
dependencies = [
"core-text",
"craft-font-catalog",
@@ -2098,7 +2098,7 @@ dependencies = [
[[package]]
name = "figcraft-ui-egui"
version = "0.18.0"
version = "0.18.1"
dependencies = [
"base64 0.22.1",
"chrono",
@@ -2126,7 +2126,7 @@ dependencies = [
[[package]]
name = "figcraft-vectordrawable"
version = "0.18.0"
version = "0.18.1"
dependencies = [
"figcraft-color",
"figcraft-doc",
@@ -2140,7 +2140,7 @@ dependencies = [
[[package]]
name = "figcraft-web"
version = "0.18.0"
version = "0.18.1"
dependencies = [
"base64 0.22.1",
"craft-web-api",
@@ -6763,7 +6763,7 @@ checksum = "9440ea3e5aeabb0ac63af70daf835274065238cdd0cec83418f417eae38bacee"
[[package]]
name = "xtask"
version = "0.18.0"
version = "0.18.1"
dependencies = [
"figcraft-engine",
"serde_json",
Cargo.toml
+1 -1
View File
@@ -6,7 +6,7 @@ exclude = ["plugins"]
# default-members = ["crates/*", "apps/figcraft", "apps/figcraft-cli", "xtask"]
[workspace.package]
version = "0.18.0"
version = "0.18.1"
edition = "2024"
license = "MIT OR Apache-2.0"
rust-version = "1.95"
ROADMAP.md
+2 -1
View File
@@ -2,7 +2,7 @@
**Stage: alpha** · next: beta, ~26 points and ~162–292 h away (one Opus 5.5 agent; ~33–67 h wall-clock with 5 agents)
> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-11-07 · **Change:** patch (the handoff mode reads Developer Mode in the interface, its ids and saved fields unchanged; the left rail's and tab strip's icons are larger, 20 pt (#553); Suggest auto layout adds nested auto layout frames by rows and columns and keeps the placement of the design, as the help center describes (#1823); the Local variables window selects several variables (click, Shift+click for a range, Cmd/Ctrl+click to toggle, Escape to clear) and delete, move to a group and scope act on the selected local variables in one undo step (#2002); the desktop UI takes a system face for Ethiopic, Devanagari, Gurmukhi, Gujarati, Tamil, Telugu, Kannada and Malayalam, Sinhala, Lao, Myanmar, Khmer, Armenian and Georgian as it did for Hebrew and Arabic, so a String variable's Amharic value draws in the panels instead of boxes (#2014); a layer's effect binding takes only a field its effect has; ; the boolean operation menu leads each entry with an original icon (#2003); glass takes one sample instead of its dispersion window where the colours split under 1/256 px; glass bends towards its core, and rounded rectangles work it out in closed form; glass's light is a line on its bevel and splay turns the bend towards the centre; glass bends with a thick-lens profile and splits its colours over 8 steps; glass effects take variables and keep their frost within 0–100; web host bridge: `?host=parent` or `data-host="page"` hands a page the app's files, documented in the hosting guide; a connector end moved with Cmd/Ctrl held goes on any part of an object, and stays there as the object moves or resizes; a tap on a plugin panel's button keeps what was typed in its fields; a Dash cap setting (none, round or square) on Dash and Custom strokes, drawn on both ends of every dash; library analytics list how many layers and files use each style and variable; the Controller menu names each button as PlayStation and Switch controllers do; widgets draw lines and SVG pictures (plugin API 6); a connector end dropped along a side of a shape attaches to that side (#1708); regression tests pin a rounded shape's one-sided stroke and SVG ids and font families without XML-forbidden characters (#1351, #1124); a damaged image is refused with a reason instead of showing as an empty box (#1474); an image copied in another app pastes again on the desktop, and in the browser for the first time (#492); SwiftUI and Compose code names a bound variable by its iOS or Android code syntax; the colour picker's Image tab shows a placeholder and Upload from computer, an asset preview, and a file dropped on it replaces the image, keeping the fill mode, crop and position (#1682); the Frame tool's Phone presets have the iPhone 17 family (#1691); Show in folder works in the Flatpak build and selects the file on Linux (#1701); a dashed line starts and ends with a half-length dash, on the canvas and in exports; the Pages, Layers and Assets search fields keep their text in the middle of the field (#1703); a board connector's path can be reshaped by dragging its path handles (#1710); boards have 16 more shapes (arrows, polygons, star, plus and flowchart symbols), in pickers that lay them out in a grid; library analytics count insertions and show insertions and detachments over the past 30 days, 90 days or year; a stroke's Custom style takes a dash pattern of any length as a comma-separated list (#1681); a control request can set its own timeout, up to 10 minutes (`timeoutMs`; `figcraft-cli mcp --attach PORT --timeout SECONDS`) (#1696); gap 6: a widget opens its plugin's panel (plugin API 5), whose callbacks redraw it; the keyboard's Menu key opens the context menu, as Shift+F10 does; an Open link action can open in place of the prototype, with "Open in new tab" off (gap 15); a collection of this file can be extended (Extend collection on its row, `variable.extendCollection`), its extension following its edits at once, and extended collections extend again in the file; the eyedropper with Cmd/Ctrl+Shift makes a colour style or variable of what it picks; a live session's welcome sends the document compressed to clients that read it, about seven times smaller (#1665); a control request that times out says truthfully whether it was dropped or is still running and will take effect, and only screenshots and input blame the window (#1673); a board keeps earlier votes' results, listed newest first in Results and deleted one at a time; the object a stamp will stick to is outlined while the stamp tool is over it or a stamp is dragged over it, and board objects take no drops (gap 24); a server can list the files shared from it now for everyone who reaches it, Home ▸ Online shows them and their links carry no secret (`team_files`, part of #742); team library analytics count detached instances per component and file (gap 10); skipping the Open link notice by command is saved with the preferences at once (gap 15Line truncated
> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-11-10 · **Change:** minor (mind maps, first step: a first node with three children on curved branches, laid out again after every edit (`board.mindMap`, `board.mindMapAdd`, #2226); the handoff mode reads Developer Mode in the interface, its ids and saved fields unchanged; the left rail's and tab strip's icons are larger, 20 pt (#553); Suggest auto layout adds nested auto layout frames by rows and columns and keeps the placement of the design, as the help center describes (#1823); the Local variables window selects several variables (click, Shift+click for a range, Cmd/Ctrl+click to toggle, Escape to clear) and delete, move to a group and scope act on the selected local variables in one undo step (#2002); the desktop UI takes a system face for Ethiopic, Devanagari, Gurmukhi, Gujarati, Tamil, Telugu, Kannada and Malayalam, Sinhala, Lao, Myanmar, Khmer, Armenian and Georgian as it did for Hebrew and Arabic, so a String variable's Amharic value draws in the panels instead of boxes (#2014); a layer's effect binding takes only a field its effect has; ; the boolean operation menu leads each entry with an original icon (#2003); glass takes one sample instead of its dispersion window where the colours split under 1/256 px; glass bends towards its core, and rounded rectangles work it out in closed form; glass's light is a line on its bevel and splay turns the bend towards the centre; glass bends with a thick-lens profile and splits its colours over 8 steps; glass effects take variables and keep their frost within 0–100; web host bridge: `?host=parent` or `data-host="page"` hands a page the app's files, documented in the hosting guide; a connector end moved with Cmd/Ctrl held goes on any part of an object, and stays there as the object moves or resizes; a tap on a plugin panel's button keeps what was typed in its fields; a Dash cap setting (none, round or square) on Dash and Custom strokes, drawn on both ends of every dash; library analytics list how many layers and files use each style and variable; the Controller menu names each button as PlayStation and Switch controllers do; widgets draw lines and SVG pictures (plugin API 6); a connector end dropped along a side of a shape attaches to that side (#1708); regression tests pin a rounded shape's one-sided stroke and SVG ids and font families without XML-forbidden characters (#1351, #1124); a damaged image is refused with a reason instead of showing as an empty box (#1474); an image copied in another app pastes again on the desktop, and in the browser for the first time (#492); SwiftUI and Compose code names a bound variable by its iOS or Android code syntax; the colour picker's Image tab shows a placeholder and Upload from computer, an asset preview, and a file dropped on it replaces the image, keeping the fill mode, crop and position (#1682); the Frame tool's Phone presets have the iPhone 17 family (#1691); Show in folder works in the Flatpak build and selects the file on Linux (#1701); a dashed line starts and ends with a half-length dash, on the canvas and in exports; the Pages, Layers and Assets search fields keep their text in the middle of the field (#1703); a board connector's path can be reshaped by dragging its path handles (#1710); boards have 16 more shapes (arrows, polygons, star, plus and flowchart symbols), in pickers that lay them out in a grid; library analytics count insertions and show insertions and detachments over the past 30 days, 90 days or year; a stroke's Custom style takes a dash pattern of any length as a comma-separated list (#1681); a control request can set its own timeout, up to 10 minutes (`timeoutMs`; `figcraft-cli mcp --attach PORT --timeout SECONDS`) (#1696); gap 6: a widget opens its plugin's panel (plugin API 5), whose callbacks redraw it; the keyboard's Menu key opens the context menu, as Shift+F10 does; an Open link action can open in place of the prototype, with "Open in new tab" off (gap 15); a collection of this file can be extended (Extend collection on its row, `variable.extendCollection`), its extension following its edits at once, and extended collections extend again in the file; the eyedropper with Cmd/Ctrl+Shift makes a colour style or variable of what it picks; a live session's welcome sends the document compressed to clients that read it, about seven times smaller (#1665); a control request that times out says truthfully whether it was dropped or is still running and will take effect, and only screenshots and input blame the window (#1673); a board keeps earlier votes' results, listed newest first in Results and deleted one at a time; the object a stamp will stick to is outlined while the stamp tool is over it or a stamp is dragged over it, and board objects take no drops (gap 24); a server can list the files shared from it now for everyone who reaches it, Home ▸ Online shows them and their links carry no secret (`team_files`, part of #742); team library Line truncated
FigCraft is a clean-room, open-source, pure-Rust reimplementation of the Figma design workflow,
native on macOS, Windows, Linux and FreeBSD and in the browser, fully drivable by agents through
@@ -365,6 +365,7 @@ Ranked; detail and milestones in [`docs/roadmap.md`](docs/roadmap.md).
| Date | Change | Summary |
|---|---|---|
| 2026-11-10 | minor | M12, #2226 (step 1 of 4): mind maps in the document and engine. `board.mindMap` places a first node with three children on curved branches and `board.mindMapAdd` adds a child or a sibling; the normalize pass lays a touched map out again from its first node (88 between columns, 48 between siblings, stacks centred on their parents). No toolbar entry yet; numbers unchanged. |
| 2026-11-03 | minor | Traditional Chinese (Taiwan) (`zh-Hant`, 繁體中文（台灣）) draft catalog: every UI string (1,975), command label (641) and menu wording (31), translated clean-room from the English source; `zh-TW`, `zh-HK`, `zh-MO` and `zh-Hant` read it while an explicit Hans stays Simplified; the desktop UI prefers an installed Noto Sans CJK TC, then Microsoft JhengHei, PingFang TC and Heiti TC; no font is bundled; native review pending. Numbers unchanged |
| 2026-11-06 | patch | M1, #2028: Edit ▸ Set default properties gives new rectangles, ellipses, polygons and stars drawn with the tools (and, set from a text layer, new text) the selected layer's properties; it only copied them for Paste properties. Tests: `default_props_tests` (3). Numbers unchanged |
| 2026-11-06 | patch | M5, #2027: `proto.settings` refuses an unknown device name with the list of devices (it saved any string, and the presenter showed no device), takes known names in any case, and answers the page's prototype settings, so `proto.settings {}` reads them back over MCP. Test: `proto_present_tests::unknown_devices_are_refused_and_settings_read_back`. Numbers unchanged |
contributors/people.toml
+3
View File
@@ -115,3 +115,6 @@ display_name = "Hamza0101"
[people.ashokram-si]
real_name = "Ashok Ram"
[people.GiovanniBot]
sync_github_name = true
crates/collab-net/src/client_cap_tests.rs
+37 -1
View File
@@ -4,7 +4,7 @@
use std::sync::{Arc, Mutex};
use figcraft_collab::message::{Peer, Presence, ServerMsg};
use figcraft_collab::message::{Access, CatchUp, Peer, Presence, Processed, ServerMsg};
use figcraft_engine::live::{Event, MAX_PEERS};
use crate::guest::GuestConfig;
@@ -59,3 +59,39 @@ fn joins_past_the_cap_are_left_out_until_someone_leaves() {
send(joined(over));
assert!(matches!(inbox.drain().as_slice(), [Event::PeerLeft(7), Event::PeerJoined(p)] if p.client_id == over));
}
#[test]
fn a_hosts_long_names_and_colours_are_cut_where_they_are_kept() {
let inbox = inbox();
let cfg = GuestConfig::new(Invite::new("127.0.0.1:47900", "0123456789abcdef", "AbCdEfGhIjKlMnOpQrStUv"), "Ada".into());
let resume = Mutex::new(None);
let mut seen = Seen::default();
let long = "x".repeat(100_000);
take(ServerMsg::PeerJoined(Peer { client_id: 1, name: long.clone(), color: long }), &cfg, &inbox, &mut seen, &resume, &|| {});
match inbox.drain().as_slice() {
[Event::PeerJoined(p)] => assert_eq!((p.name.as_str(), p.color.as_str()), ("x".repeat(256).as_str(), "x".repeat(32).as_str())),
other => panic!("{other:?}"),
}
}
#[test]
fn the_welcome_handed_to_the_sync_client_carries_the_bounded_roster() {
let inbox = inbox();
let cfg = GuestConfig::new(Invite::new("127.0.0.1:47900", "0123456789abcdef", "AbCdEfGhIjKlMnOpQrStUv"), "Ada".into());
let resume = Mutex::new(None);
let long = "y".repeat(100_000);
let welcome = ServerMsg::Welcome {
session: 1,
client_id: 9,
seq: 0,
catch_up: CatchUp::Snapshot(Vec::new()),
processed: Processed::default(),
peers: vec![Peer { client_id: 1, name: long.clone(), color: long }],
access: Access::default(),
secret: 0,
};
take(welcome, &cfg, &inbox, &mut Seen::default(), &resume, &|| {});
let events = inbox.drain();
let Some(Event::Sync(ServerMsg::Welcome { peers, .. })) = events.iter().find(|e| matches!(e, Event::Sync(_))) else { panic!("{events:?}") };
assert_eq!(peers.first().map(|p| (p.name.chars().count(), p.color.chars().count())), Some((256, 32)));
}
crates/collab-net/src/join.rs
+21 -4
View File
@@ -226,6 +226,19 @@ pub(crate) struct Seen {
peers: Vec<Peer>,
}
/// `p` with its name and colour cut to what the UI shows: the host is untrusted, and the roster is
/// copied whenever someone's identity is updated.
fn bounded(mut p: Peer) -> Peer {
p.name = p.name.chars().take(MAX_PEER_NAME).collect();
p.color = p.color.chars().take(MAX_COLOR).collect();
p
}
/// The most characters of a colour (`#rrggbb` and a few spellings more) kept for someone.
const MAX_COLOR: usize = 32;
/// The most characters of a name kept for someone.
const MAX_PEER_NAME: usize = 256;
/// What taking in one message from the host means for the connection.
pub(crate) enum Taken {
Continue,
@@ -251,7 +264,7 @@ pub(crate) fn take(mut m: ServerMsg, cfg: &GuestConfig, inbox: &Inbox, seen: &mu
*r = Some(Resume { session, client_id, seq, secret });
}
// The sync client opens the document (and fills in its name and pages).
let peers: Vec<Peer> = peers.iter().take(MAX_PEERS).cloned().collect();
let peers: Vec<Peer> = peers.iter().take(MAX_PEERS).cloned().map(bounded).collect();
let inv = &cfg.invite;
let info = SessionInfo {
role: Role::Guest,
@@ -268,20 +281,24 @@ pub(crate) fn take(mut m: ServerMsg, cfg: &GuestConfig, inbox: &Inbox, seen: &mu
view: None,
};
seen.peers = peers.clone();
// The sync client keeps the roster of the welcome it is handed: the bounded one.
if let ServerMsg::Welcome { peers: sent, .. } = &mut m {
sent.clone_from(&peers);
}
seen.info = Some(info.clone());
welcomed();
inbox.push(Event::Welcome { info, peers });
inbox.push(Event::Sync(m));
return Taken::Welcomed;
}
ServerMsg::PeerJoined(p) => match seen.info.as_mut() {
ServerMsg::PeerJoined(p) => match (seen.info.as_mut(), bounded(p)) {
// The host tells you how you are shown.
Some(info) if p.client_id == info.me => {
(Some(info), p) if p.client_id == info.me => {
info.name = p.name;
info.color = p.color;
inbox.push(Event::Welcome { info: info.clone(), peers: seen.peers.clone() });
}
_ => {
(_, p) => {
match seen.peers.iter().position(|q| q.client_id == p.client_id) {
Some(i) => {
seen.peers.remove(i);
crates/collab/src/board_sync_tests.rs
+2
View File
@@ -29,6 +29,7 @@ fn a_boards_kind_and_its_objects_metadata_sync() {
to: End::Point { x: 5.0, y: 5.0 },
routing: Routing::Elbow,
path: None,
branch: false,
}));
let mut r = host.clone();
r.apply(&diff(&host, &edited).unwrap().changes, Mode::Strict).unwrap();
@@ -38,6 +39,7 @@ fn a_boards_kind_and_its_objects_metadata_sync() {
to: End::Point { x: 9.0, y: 1.0 },
routing: Routing::Straight,
path: None,
branch: false,
}));
let d = diff(&r, &moved).unwrap();
assert!(matches!(d.changes.as_slice(), [Change::Set { prop: Prop::Board, .. }]), "{:?}", d.changes);
crates/doc/src/board.rs
+19 -4
View File
@@ -37,8 +37,8 @@ impl FileKind {
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(tag = "type", rename_all = "camelCase")]
pub enum BoardItem {
/// A sticky note: a frame whose first text layer is the note (its size shrinks as the note
/// grows) and, below it, who wrote it.
/// A sticky note: a frame whose first text layer is the note (its size stays fixed, the note
/// grows taller) and, below it, who wrote it.
Sticky {
#[serde(default, skip_serializing_if = "String::is_empty")]
author: String,
@@ -62,18 +62,29 @@ pub enum BoardItem {
/// A table: a frame of row frames holding cell frames with text (its column lines are thin
/// rectangles laid over it).
Table,
/// A mind map's node: a frame hugging its text, with no outline. What it hangs from is the
/// branch (a connector with `branch`) arriving at it.
MindNode,
}
impl BoardItem {
/// Objects selected and moved as a whole: a click on their text or outline picks them, and
/// they never take other layers in.
pub fn is_atom(&self) -> bool {
matches!(self, BoardItem::Sticky { .. } | BoardItem::Shape { .. } | BoardItem::Label { .. } | BoardItem::Stamp { .. } | BoardItem::Table)
matches!(
self,
BoardItem::Sticky { .. }
| BoardItem::Shape { .. }
| BoardItem::Label { .. }
| BoardItem::Stamp { .. }
| BoardItem::Table
| BoardItem::MindNode
)
}
/// Objects whose first text layer is their text (a double-click or Enter edits it).
pub fn has_text(&self) -> bool {
matches!(self, BoardItem::Sticky { .. } | BoardItem::Shape { .. } | BoardItem::Label { .. })
matches!(self, BoardItem::Sticky { .. } | BoardItem::Shape { .. } | BoardItem::Label { .. } | BoardItem::MindNode)
}
/// Who made it (stickies and stamps; empty when unknown).
@@ -115,6 +126,7 @@ impl BoardItem {
BoardItem::Stamp { .. } => "stamp",
BoardItem::Ink => "ink",
BoardItem::Table => "table",
BoardItem::MindNode => "mindNode",
}
}
}
@@ -619,4 +631,7 @@ pub struct Connector {
/// Its path as reshaped by hand; `None`: routed by itself.
#[serde(default, skip_serializing_if = "Option::is_none")]
pub path: Option<ConnectorPath>,
/// A mind map's branch: `from` is the parent, `to` the child. The map's shape is read from these.
#[serde(default, skip_serializing_if = "crate::node::is_default")]
pub branch: bool,
}
crates/doc/src/board_mindmap.rs
+138
View File
@@ -0,0 +1,138 @@
//! Mind map layout: where the nodes of a map go, from their sizes and their tree. Pure geometry,
//! like `board_route`; the engine's normalize pass reads the tree from the branches and moves the
//! layers (#2226).
use figcraft_geom::{Point, Rect};
use crate::NodeId;
/// The room between a node's column and its children's column.
pub const MIND_GAP_X: f64 = 88.0;
/// The room between a node (with everything under it) and the next one below.
pub const MIND_GAP_Y: f64 = 48.0;
/// The most nodes one map is laid out with (a larger one is left as it is).
pub const MIND_MAX_NODES: usize = 2000;
/// The deepest level of a map that is laid out (the first node is level 0).
pub const MIND_MAX_DEPTH: usize = 64;
/// One node of a mind map as the layout sees it.
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct MindBox {
pub id: NodeId,
/// Its box on the page now. The root's stays; of the others only the size counts, and the
/// centre's y, which orders siblings.
pub rect: Rect,
/// Its parent's index in the slice (`None`: the root, entry 0). Always a smaller index.
pub parent: Option<usize>,
/// Left of the root. Read on the root's children only: deeper nodes follow their parent.
pub left: bool,
}
fn finite(r: Rect) -> bool {
[r.x0, r.y0, r.x1, r.y1].iter().all(|v| v.is_finite())
}
/// Where every node but the root goes: its box's top-left on the page. Nodes whose parent isn't
/// an earlier entry, that are deeper than [`MIND_MAX_DEPTH`] or that would land off the finite
/// plane are left out; a slice that is empty, longer than [`MIND_MAX_NODES`], whose first entry
/// has a parent or that holds a box that is not finite is left alone altogether.
pub fn mind_layout(nodes: &[MindBox]) -> Vec<(NodeId, Point)> {
let n = nodes.len();
let Some(root) = nodes.first().filter(|r| r.parent.is_none()) else { return Vec::new() };
if n > MIND_MAX_NODES || !nodes.iter().all(|b| finite(b.rect)) {
return Vec::new();
}
// The tree: who is a child of whom, which side of the root it is on, how deep.
let (mut left, mut depth, mut valid) = (vec![false; n], vec![0_usize; n], vec![false; n]);
if let Some(v) = valid.first_mut() {
*v = true;
}
// Children by parent and side (0: right, 1: left; below the root only the parent's side is used).
let mut kids: Vec<[Vec<usize>; 2]> = vec![[Vec::new(), Vec::new()]; n];
for (i, b) in nodes.iter().enumerate().skip(1) {
let Some(p) = b.parent.filter(|p| *p < i && valid.get(*p).copied().unwrap_or(false)) else { continue };
let d = depth.get(p).copied().unwrap_or(0) + 1;
if d > MIND_MAX_DEPTH {
continue;
}
let side = if p == 0 { b.left } else { left.get(p).copied().unwrap_or(false) };
if let (Some(v), Some(l), Some(dp)) = (valid.get_mut(i), left.get_mut(i), depth.get_mut(i)) {
(*v, *l, *dp) = (true, side, d);
}
if let Some(k) = kids.get_mut(p) {
k[usize::from(side)].push(i);
}
}
// Siblings keep the order they are in: by their middles, then by id.
for k in kids.iter_mut().flatten() {
k.sort_by(|a, b| {
let (x, y) = (nodes.get(*a), nodes.get(*b));
match (x, y) {
(Some(x), Some(y)) => x.rect.center().y.total_cmp(&y.rect.center().y).then(x.id.cmp(&y.id)),
_ => std::cmp::Ordering::Equal,
}
});
}
let height = |i: usize| nodes.get(i).map_or(0.0, |b| b.rect.height());
let width = |i: usize| nodes.get(i).map_or(0.0, |b| b.rect.width());
// Span, backward: a node's room is its own height or its children's stack, whichever is more.
let stack = |span: &[f64], list: &[usize]| {
let total: f64 = list.iter().map(|c| span.get(*c).copied().unwrap_or(0.0)).sum();
total + MIND_GAP_Y * list.len().saturating_sub(1) as f64
};
let mut span = vec![0.0_f64; n];
for i in (1..n).rev() {
let own = kids.get(i).map_or(0.0, |k| stack(&span, &k[usize::from(left.get(i).copied().unwrap_or(false))]));
if let Some(s) = span.get_mut(i) {
*s = height(i).max(own);
}
}
// Place, forward. `column[i]`: where node i's children's column begins (its left edge on the
// right side, its right edge on the left side); `centre[i]`: its middle.
let mut column = vec![0.0_f64; n];
let mut centre = vec![0.0_f64; n];
let mut out = Vec::new();
let root_c = root.rect.center().y;
if let Some(c) = centre.first_mut() {
*c = root_c;
}
let mut ok = vec![false; n];
if let Some(o) = ok.first_mut() {
*o = true;
}
for i in 0..n {
if !ok.get(i).copied().unwrap_or(false) {
continue;
}
let Some(k) = kids.get(i) else { continue };
for side in [false, true] {
let list = k[usize::from(side)].as_slice();
if list.is_empty() {
continue;
}
// The column the group starts in: past the widest node of its parent's own group.
let x =
if i == 0 { if side { root.rect.x0 - MIND_GAP_X } else { root.rect.x1 + MIND_GAP_X } } else { column.get(i).copied().unwrap_or(0.0) };
let widest = list.iter().map(|c| width(*c)).fold(0.0, f64::max);
let mut top = centre.get(i).copied().unwrap_or(0.0) - stack(&span, list) / 2.0;
for &c in list {
let s = span.get(c).copied().unwrap_or(0.0);
let mid = top + s / 2.0;
let at = Point::new(if side { x - width(c) } else { x }, mid - height(c) / 2.0);
top += s + MIND_GAP_Y;
if !(at.x.is_finite() && at.y.is_finite() && mid.is_finite()) {
continue;
}
if let (Some(m), Some(col), Some(o)) = (centre.get_mut(c), column.get_mut(c), ok.get_mut(c)) {
*m = mid;
*col = if side { x - widest - MIND_GAP_X } else { x + widest + MIND_GAP_X };
*o = true;
}
if let Some(b) = nodes.get(c) {
out.push((b.id, at));
}
}
}
}
out
}
crates/doc/src/board_mindmap_tests.rs
+99
View File
@@ -0,0 +1,99 @@
//! Mind map layout (`board_mindmap`): columns 88 apart, siblings 48 apart, stacks centred on their
//! parents (#2226).
use figcraft_geom::{Point, Rect};
use crate::NodeId;
use crate::board_mindmap::{MIND_GAP_X, MIND_GAP_Y, MIND_MAX_NODES, MindBox, mind_layout};
/// The first node, always at the origin, 200 x 36.
fn root() -> MindBox {
MindBox { id: NodeId(1), rect: Rect::new(0.0, 0.0, 200.0, 36.0), parent: None, left: false }
}
/// A node `w` x `h` whose current top is `y` (only its middle, which orders siblings, counts).
fn node(id: u64, parent: usize, (w, h): (f64, f64), y: f64) -> MindBox {
MindBox { id: NodeId(id), rect: Rect::new(0.0, y, w, y + h), parent: Some(parent), left: false }
}
fn at(placed: &[(NodeId, Point)], id: u64) -> (f64, f64) {
let p = placed.iter().find(|(n, _)| *n == NodeId(id)).map(|(_, p)| *p).unwrap_or_else(|| panic!("node {id} not placed in {placed:?}"));
(p.x, p.y)
}
/// The root and three children (100, 60 and 80 wide) whose middles are in that order; `middle` is
/// the second child's size.
fn three(middle: (f64, f64)) -> Vec<MindBox> {
vec![root(), node(2, 0, (100.0, 24.0), 0.0), node(3, 0, middle, 22.0 - middle.1 / 2.0), node(4, 0, (80.0, 24.0), 20.0)]
}
/// The root, two children (100 and 60 wide) under it, two more under the first and one under the second.
fn six() -> Vec<MindBox> {
vec![
root(),
node(2, 0, (100.0, 24.0), 0.0),
node(3, 0, (60.0, 24.0), 10.0),
node(4, 1, (40.0, 24.0), 0.0),
node(5, 1, (40.0, 24.0), 10.0),
node(6, 2, (40.0, 24.0), 0.0),
]
}
#[test]
fn three_children_stand_88_right_of_the_root_72_apart_centred_on_it() {
assert_eq!((MIND_GAP_X, MIND_GAP_Y), (88.0, 48.0));
let placed = mind_layout(&three((60.0, 24.0)));
assert_eq!([at(&placed, 2), at(&placed, 3), at(&placed, 4)], [(288.0, -66.0), (288.0, 6.0), (288.0, 78.0)]);
assert!(placed.iter().all(|(n, _)| *n != NodeId(1)), "the first node stays where it is");
}
#[test]
fn a_taller_node_pushes_its_neighbours_half_its_growth_each_way() {
let placed = mind_layout(&three((60.0, 72.0)));
assert_eq!([at(&placed, 2), at(&placed, 3), at(&placed, 4)], [(288.0, -90.0), (288.0, -18.0), (288.0, 102.0)]);
}
#[test]
fn grandchildren_share_a_column_past_the_widest_sibling_and_their_parents_make_room() {
let nodes = six();
let placed = mind_layout(&nodes);
// 476 = 288 + 100 + 88, although B is only 60 wide.
let got: Vec<(f64, f64)> = (2..=6).map(|i| at(&placed, i)).collect();
assert_eq!(got, [(288.0, -30.0), (288.0, 78.0), (476.0, -66.0), (476.0, 6.0), (476.0, 78.0)]);
}
#[test]
fn left_children_mirror_the_right_ones() {
let mut l = node(2, 0, (80.0, 24.0), 0.0);
l.left = true;
let placed = mind_layout(&[root(), l, node(3, 1, (50.0, 24.0), 0.0)]);
assert_eq!((at(&placed, 2), at(&placed, 3)), ((-168.0, 6.0), (-306.0, 6.0)));
}
#[test]
fn the_layout_is_a_fixed_point_ties_go_by_id_and_junk_is_skipped() {
let nodes = six();
let placed = mind_layout(&nodes);
let again: Vec<MindBox> = nodes
.iter()
.map(|b| {
let p = placed.iter().find(|(n, _)| *n == b.id).map_or(b.rect.origin(), |(_, p)| *p);
MindBox { rect: Rect::from_origin_size(p, b.rect.size()), ..*b }
})
.collect();
assert_eq!(mind_layout(&again), placed, "a laid out map is left as it is");
// The same height: the lower id goes first.
let tied = mind_layout(&[root(), node(9, 0, (10.0, 24.0), 5.0), node(7, 0, (10.0, 24.0), 5.0)]);
assert!(at(&tied, 7).1 < at(&tied, 9).1);
// Junk: nothing placed, nothing panics.
assert!(mind_layout(&[]).is_empty());
let mut nan = three((60.0, 24.0));
nan[2].rect = Rect::new(f64::NAN, 0.0, 1.0, 1.0);
assert!(mind_layout(&nan).is_empty());
let mut orphan = three((60.0, 24.0));
orphan.push(node(8, 9, (10.0, 24.0), 0.0));
assert!(!mind_layout(&orphan).iter().any(|(n, _)| *n == NodeId(8)), "a parent that doesn't come first");
let mut huge = vec![root()];
huge.extend((0..MIND_MAX_NODES as u64).map(|i| node(i + 2, 0, (10.0, 24.0), i as f64)));
assert!(mind_layout(&huge).is_empty());
}
crates/doc/src/lib.rs
+4
View File
@@ -9,6 +9,7 @@
#![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)]
pub mod board;
mod board_mindmap;
mod board_route;
pub mod colors;
pub mod comments;
@@ -27,6 +28,7 @@ pub mod vector_faces;
pub mod vector_regions;
pub use board::*;
pub use board_mindmap::{MIND_GAP_X, MIND_GAP_Y, MIND_MAX_DEPTH, MIND_MAX_NODES, MindBox, mind_layout};
pub use board_route::{END_GAP, MAX_RUNS, RouteEnd, attach_points, attached_sides, path_handles, reshaped, route_along, route_points};
pub use colors::*;
pub use comments::*;
@@ -1314,6 +1316,8 @@ fn remap_action(a: &mut proto::Action, map: &BTreeMap<NodeId, NodeId>) {
#[cfg(test)]
mod blur_tests;
#[cfg(test)]
mod board_mindmap_tests;
#[cfg(test)]
mod board_route_tests;
#[cfg(test)]
mod board_shape_tests;
crates/doc/src/props.rs
+4
View File
@@ -1399,6 +1399,10 @@ impl ExportSize {
Some((i, c)) if c.is_ascii_alphabetic() => (s.get(..i)?.trim(), Some(c)),
_ => (s.as_str(), None),
};
// Plain decimal only: no sign, exponent, "inf" or "nan".
if !num.bytes().all(|b| b.is_ascii_digit() || b == b'.') {
return None;
}
let value: f64 = num.parse().ok()?;
match unit {
None | Some('x') => ExportSize::Scale { value },
crates/doc/src/text.rs
+38
View File
@@ -886,6 +886,25 @@ impl TextData {
}
pl.indent = pl.indent.min(MAX_LIST_INDENT);
}
self.fold_paragraph_lists();
}
/// Give paragraphs `a..=b` (by index) no start number of their own, as an item made by Enter
/// has none. Touches nothing else: a plain paragraph keeps its level, a bullet its settings.
/// One pass over the range, and nothing at all when no paragraph carries a start.
pub fn clear_list_starts(&mut self, a: usize, b: usize) {
if self.paragraphs.iter().all(|p| p.start_offset == 0) {
return;
}
self.fill_paragraphs();
for pl in self.paragraphs.get_mut(a..=b).unwrap_or(&mut []) {
pl.start_offset = 0;
}
self.fold_paragraph_lists();
}
/// One style for all paragraphs with no nesting or start folds back into `list`.
fn fold_paragraph_lists(&mut self) {
if let Some(first) = self.paragraphs.first().copied()
&& first == (ParaList { list: first.list, ..ParaList::default() })
&& self.paragraphs.iter().all(|p| *p == first)
@@ -1104,6 +1123,25 @@ mod case_tests {
t.set_para_lists(0, 0, |p| p.list = P);
assert_eq!(t.para_list(0), ParaList::default());
}
#[test]
fn clear_list_starts_touches_only_starts() {
use ListStyle::{None as P, Numbered as N};
let mut t = TextData { characters: "a\nb\nc".into(), ..Default::default() };
t.paragraphs = vec![
ParaList { list: N, start_offset: 4, ..ParaList::default() },
ParaList { list: P, indent: 1, ..ParaList::default() },
ParaList { list: N, indent: 2, start_offset: 7, ..ParaList::default() },
];
t.clear_list_starts(1, 2);
assert_eq!(t.para_list(0).start_offset, 4, "outside the range");
assert_eq!(t.para_list(1), ParaList { list: P, indent: 1, ..ParaList::default() }, "a plain paragraph keeps its level");
assert_eq!(t.para_list(2), ParaList { list: N, indent: 2, start_offset: 0, ..ParaList::default() });
// Out of range and no-start cases leave it alone.
t.clear_list_starts(5, 9);
t.clear_list_starts(0, 0);
assert_eq!(t.para_list(0).start_offset, 0);
}
}
#[cfg(test)]
crates/engine/src/al_drag_tests.rs
+97
View File
@@ -69,3 +69,100 @@ fn grid_drag_takes_the_cell_under_the_pointer() {
let cl = s.doc().unwrap().node(kids[0]).unwrap().child_layout.clone();
assert_eq!((cl.grid_column, cl.grid_row), (None, None), "one undo step");
}
/// Three 60 x 60 rectangles in a row (or column), gap 20, at 0, 80 and 160 along the flow.
fn three(s: &mut Session, mode: &str) -> (NodeId, [NodeId; 3]) {
let f = id(s.execute("frame.create", &json!({"x": 0, "y": 0, "width": 300, "height": 300})).unwrap());
let kids: Vec<NodeId> =
(0..3).map(|_| id(s.execute("shape.rectangle", &json!({"x": 0, "y": 0, "width": 60, "height": 60, "parent": f})).unwrap())).collect();
s.execute("layout.add", &json!({"ids": [f]})).unwrap();
s.execute("node.set", &json!({"id": f, "props": {"layoutMode": mode, "gap": 20, "padding": 0, "sizingH": "fixed", "sizingV": "fixed"}})).unwrap();
s.execute("select.none", &json!({})).unwrap();
(f, [kids[0], kids[1], kids[2]])
}
/// The order after dragging kid `which` by `by` along the flow, grabbed `grab` from its start edge.
fn dragged_order(mode: &str, which: usize, grab: f64, by: f64) -> Vec<usize> {
let mut s = Session::new();
let (f, kids) = three(&mut s, mode);
let vertical = mode == "vertical";
let b = s.doc().unwrap().world_bounds(kids[which]).unwrap();
let from = if vertical { (b.center().x, b.y0 + grab) } else { (b.x0 + grab, b.center().y) };
let to = if vertical { (from.0, from.1 + by) } else { (from.0 + by, from.1) };
drag(&mut s, from, to);
let order = s.doc().unwrap().node(f).unwrap().children.clone();
order.iter().map(|c| kids.iter().position(|k| k == c).unwrap()).collect()
}
#[test]
fn a_child_dragged_right_passes_a_sibling_when_its_leading_edge_reaches_the_siblings_middle() {
assert_eq!(dragged_order("horizontal", 0, 30.0, 49.0), vec![0, 1, 2]);
assert_eq!(dragged_order("horizontal", 0, 30.0, 50.0), vec![1, 0, 2]);
assert_eq!(dragged_order("horizontal", 0, 30.0, 129.0), vec![1, 0, 2]);
assert_eq!(dragged_order("horizontal", 0, 30.0, 130.0), vec![1, 2, 0]);
}
#[test]
fn where_the_child_is_grabbed_does_not_change_its_slot() {
assert_eq!(dragged_order("horizontal", 0, 10.0, 49.0), vec![0, 1, 2]);
assert_eq!(dragged_order("horizontal", 0, 10.0, 50.0), vec![1, 0, 2]);
assert_eq!(dragged_order("horizontal", 0, 10.0, 129.0), vec![1, 0, 2]);
assert_eq!(dragged_order("horizontal", 0, 10.0, 130.0), vec![1, 2, 0]);
}
#[test]
fn a_child_dragged_left_passes_a_sibling_by_its_left_edge() {
assert_eq!(dragged_order("horizontal", 2, 30.0, -49.0), vec![0, 1, 2]);
assert_eq!(dragged_order("horizontal", 2, 30.0, -50.0), vec![0, 2, 1]);
assert_eq!(dragged_order("horizontal", 2, 30.0, -130.0), vec![2, 0, 1]);
}
#[test]
fn a_column_reorders_by_the_bottom_edge() {
assert_eq!(dragged_order("vertical", 0, 30.0, 50.0), vec![1, 0, 2]);
assert_eq!(dragged_order("vertical", 0, 30.0, 130.0), vec![1, 2, 0]);
}
#[test]
fn a_child_dragged_left_passes_the_second_sibling_one_pixel_later() {
assert_eq!(dragged_order("horizontal", 2, 30.0, -129.0), vec![0, 2, 1]);
}
#[test]
fn a_column_reorders_at_the_boundaries_both_ways() {
assert_eq!(dragged_order("vertical", 0, 30.0, 49.0), vec![0, 1, 2]);
assert_eq!(dragged_order("vertical", 0, 30.0, 129.0), vec![1, 0, 2]);
assert_eq!(dragged_order("vertical", 2, 30.0, -49.0), vec![0, 1, 2]);
assert_eq!(dragged_order("vertical", 2, 30.0, -50.0), vec![0, 2, 1]);
assert_eq!(dragged_order("vertical", 2, 30.0, -129.0), vec![0, 2, 1]);
assert_eq!(dragged_order("vertical", 2, 30.0, -130.0), vec![2, 0, 1]);
}
#[test]
fn a_drag_with_no_move_along_the_flow_keeps_the_slot() {
// Back at the start, and a drag across the flow only, with snapping on (the default).
assert_eq!(dragged_order("horizontal", 1, 30.0, 0.0), vec![0, 1, 2]);
assert_eq!(dragged_order("vertical", 1, 30.0, 0.0), vec![0, 1, 2]);
let mut s = Session::new();
let (f, kids) = three(&mut s, "horizontal");
let b = s.doc().unwrap().world_bounds(kids[1]).unwrap();
let from = (b.center().x, b.center().y);
drag(&mut s, from, (from.0, from.1 + 40.0));
let order = s.doc().unwrap().node(f).unwrap().children.clone();
assert_eq!(order, kids.to_vec());
}
#[test]
fn several_dragged_children_use_their_combined_box() {
// Kids 0 and 1 together span 0..140; moved right by 49 the leading edge is at 189, just short of the middle of kid 2 (190).
for (by, expected) in [(49.0, vec![0, 1, 2]), (50.0, vec![2, 0, 1])] {
let mut s = Session::new();
let (f, kids) = three(&mut s, "horizontal");
s.execute("select.set", &json!({"ids": [kids[0], kids[1]]})).unwrap();
let b = s.doc().unwrap().world_bounds(kids[0]).unwrap();
let from = (b.center().x, b.center().y);
drag(&mut s, from, (from.0 + by, from.1));
let order: Vec<usize> = s.doc().unwrap().node(f).unwrap().children.iter().map(|c| kids.iter().position(|k| k == c).unwrap()).collect();
assert_eq!(order, expected, "by {by}");
}
}
crates/engine/src/assets/components.rs
+1 -1
View File
@@ -60,7 +60,7 @@ pub use patch::sync_after_edit;
pub(crate) use patch::{FULL_REBUILD, PATCHED};
#[cfg(test)]
use rebase::RebaseSources;
pub use rebase::rebase_instance;
pub use rebase::{MainPaths, rebase_instance, rebase_instance_with};
pub use sync::keep_text_overrides;
pub use variants::{default_variant, exposed_copies, find_variant, mirror_issues, variant_conflicts, variant_name, variant_options, variant_props};
crates/engine/src/assets/components/rebase.rs
+20 -2
View File
@@ -165,10 +165,28 @@ impl<'a> RebaseSources<'a> {
/// values (after detaching an outer instance, restoring a main, or copying a nested instance out):
/// the look is kept exactly. Values a component property sets aren't overrides.
pub fn rebase_instance(doc: &mut Document, inst: NodeId) {
rebase_instance_with(doc, inst, &mut MainPaths::new());
}
/// The layers of mains by path, kept across several [`rebase_instance_with`] calls. Rebasing only
/// writes instances' `source` and `overrides`, never a main's layers or names, so a main's paths
/// stay right for as long as the caller changes nothing else.
pub type MainPaths = BTreeMap<NodeId, std::rc::Rc<BTreeMap<String, NodeId>>>;
/// [`rebase_instance`], taking each main's path map from `mains` (and adding it there).
pub fn rebase_instance_with(doc: &mut Document, inst: NodeId, mains: &mut MainPaths) {
let Some(NodeKind::Instance { component, .. }) = doc.node(inst).map(|n| n.kind.clone()) else { return };
let mine = path_map(doc, inst, true);
let theirs: BTreeMap<String, NodeId> =
if doc.contains(component) { path_map(doc, component, false).into_iter().map(|(k, v)| (v, k)).collect() } else { BTreeMap::new() };
let theirs = mains
.entry(component)
.or_insert_with(|| {
std::rc::Rc::new(if doc.contains(component) {
path_map(doc, component, false).into_iter().map(|(k, v)| (v, k)).collect()
} else {
BTreeMap::new()
})
})
.clone();
let value_groups = |a: &Node, b: &Node| -> Vec<String> {
diff_groups(a, b).into_iter().filter(|g| !matches!(*g, "size" | "position")).map(str::to_string).collect()
};
crates/engine/src/assets/components/sync.rs
+22 -7
View File
@@ -34,7 +34,7 @@ pub(super) fn sync_instance_depth(doc: &mut Document, inst: NodeId, depth: usize
let nid = doc.alloc_id();
map.insert(s, nid);
}
let Copies { nodes: new_nodes, nested, mut remeasure } = copy_layers(doc, inst, &src, &map, &old, &edited, eff_props);
let Copies { nodes: new_nodes, nested, mut remeasure } = copy_layers(doc, inst, component, &src, &map, &old, &edited, eff_props);
for n in new_nodes {
let (id, parent) = (n.id, n.parent);
if insert_linked(doc, n).is_err()
@@ -132,6 +132,7 @@ struct Copies {
fn copy_layers(
doc: &Document,
inst: NodeId,
component: NodeId,
src: &[NodeId],
map: &BTreeMap<NodeId, NodeId>,
old: &BTreeMap<NodeId, std::sync::Arc<Node>>,
@@ -139,7 +140,7 @@ fn copy_layers(
props: BTreeMap<String, Value>,
) -> Copies {
let mut enclosing: BTreeMap<NodeId, Vec<NodeId>> = BTreeMap::from([(inst, vec![inst])]);
let mut inst_props: BTreeMap<NodeId, BTreeMap<String, Value>> = BTreeMap::from([(inst, props)]);
let mut inst_props: BTreeMap<NodeId, (NodeId, BTreeMap<String, Value>)> = BTreeMap::from([(inst, (component, props))]);
let mut out = Copies { nodes: Vec::new(), nested: Vec::new(), remeasure: Vec::new() };
for s in src {
let Some(orig) = doc.node(*s) else { continue };
@@ -164,12 +165,12 @@ fn copy_layers(
// No longer a slot in the main: it mirrors the main again.
n.overrides.remove(SLOT);
}
// Component properties: the main layer's bindings use this instance's values; layers of
// nested instances use the nested instance's values (one level per source hop).
// Bindings use the enclosing instance of their defining component, even when slot
// content has fewer source hops than enclosing instances.
let enc = enclosing.get(&parent).cloned().unwrap_or_default();
apply_enclosing_props(doc, &mut n, orig, &enc, &inst_props);
if let NodeKind::Instance { component: c, props } = &n.kind {
inst_props.insert(nid, props.clone());
inst_props.insert(nid, (*c, props.clone()));
let mut e = enc;
e.push(nid);
enclosing.insert(nid, e);
@@ -253,14 +254,28 @@ fn rebuild_nested(doc: &mut Document, nested: Vec<NodeId>, old: &BTreeMap<NodeId
}
}
fn apply_enclosing_props(doc: &Document, n: &mut Node, orig: &Node, enc: &[NodeId], inst_props: &BTreeMap<NodeId, BTreeMap<String, Value>>) {
/// Apply bindings from their defining components, preserving explicit overrides and letting
/// nearer source layers take precedence. Slot content need not have one source hop per instance.
fn apply_enclosing_props(
doc: &Document,
n: &mut Node,
orig: &Node,
enc: &[NodeId],
inst_props: &BTreeMap<NodeId, (NodeId, BTreeMap<String, Value>)>,
) {
let mut chain: Vec<&Node> = vec![orig];
while chain.len() < enc.len() {
let Some(next) = chain.last().and_then(|c| c.source).and_then(|x| doc.node(x)) else { break };
chain.push(next);
}
for (j, level) in chain.iter().enumerate().rev() {
let Some(props) = enc.get(j).and_then(|e| inst_props.get(e)) else { continue };
if level.prop_refs.is_empty() {
continue;
}
let Some(owner) = owning_component(doc, level.id) else { continue };
// Instance-owned slot content skips a source hop through the slot's component. Match
// the binding's defining component, not the position in the enclosing instance chain.
let Some((_, props)) = enc.iter().rev().filter_map(|e| inst_props.get(e)).find(|(component, _)| *component == owner) else { continue };
for (field, prop) in &level.prop_refs {
let g = field_group(field);
if n.overrides.contains(g) || (j > 0 && orig.overrides.contains(g)) {
crates/engine/src/automation/file_access.rs
+186 -22
View File
@@ -12,6 +12,11 @@
//! existing folder is resolved and the rest must be plain names. The comparison is by whole
//! components (`/work2` is not inside `/work`), and the I/O uses the resolved path, so what was
//! checked is what is opened.
//!
//! On Windows, resolving a path opens it, and opening a path on another computer contacts that
//! computer and may send it the signed-in user's credentials. So on Windows, before anything is
//! resolved, a path on another computer whose share no root is on, a device path, or one reached
//! through a link that leads to them is refused by how it is spelled (#1094).
#![allow(clippy::disallowed_methods)]
use std::cell::RefCell;
@@ -19,6 +24,8 @@ use std::ffi::{OsStr, OsString};
use std::path::{Component, Path, PathBuf};
use std::sync::Arc;
use craft_docpath::Refused;
use crate::{EngineError, Result};
/// What a command does with a file.
@@ -58,6 +65,19 @@ impl Roots {
Access::Read => ([self.read.as_slice(), self.write.as_slice()].concat(), "read"),
Access::Write => (self.write.clone(), "written"),
};
if cfg!(windows) {
match refused_unresolved(path, &roots) {
Some(Unresolved::Spelled(Refused::Network)) => {
return Err(format!(
"automation path rejected: {asked} is on another computer, and no folder that may be {what} is on its share"
));
}
Some(Unresolved::Spelled(_)) => return Err(format!("automation path rejected: {asked} names a device, not a file")),
// Where a link leads is only told by the usual message: it would say what is there.
Some(Unresolved::Linked) => return Err(outside(asked, &roots, what)),
None => {}
}
}
match resolve(path) {
Ok(resolved) if roots.iter().any(|r| resolved.starts_with(r)) => return Ok(resolved),
Ok(_) => {}
@@ -65,11 +85,7 @@ impl Roots {
Err(why) if inside_as_far_as_it_exists(path, &roots) => return Err(format!("automation path rejected: {asked}: {why}")),
Err(_) => {}
}
if roots.is_empty() {
return Err(format!("automation path rejected: no folder may be {what} (no root for it was given): {asked}"));
}
let shown: Vec<String> = roots.iter().map(|r| shown(r)).collect();
Err(format!("automation path rejected: {asked} is outside the folders that may be {what}: {}", shown.join(", ")))
Err(outside(asked, &roots, what))
}
/// The folders as JSON, resolved: `{read: [every folder that may be read], write: [the write roots]}`.
@@ -79,23 +95,165 @@ impl Roots {
}
}
/// Why `asked` is refused: it is outside every one of `roots`, the folders that may be `what`
/// ("read" or "written"). The message lists those folders, or says that no folder may be `what`
/// when `roots` is empty.
fn outside(asked: std::path::Display<'_>, roots: &[PathBuf], what: &str) -> String {
if roots.is_empty() {
return format!("automation path rejected: no folder may be {what} (no root for it was given): {asked}");
}
let shown: Vec<String> = roots.iter().map(|r| shown(r)).collect();
format!("automation path rejected: {asked} is outside the folders that may be {what}: {}", shown.join(", "))
}
/// Why a path is refused before it is resolved (#1094).
#[derive(Debug, PartialEq, Eq)]
enum Unresolved {
/// Its spelling leads to another computer ([`Refused::Network`]) or a device ([`Refused::Device`]).
Spelled(Refused),
/// A link on the way leads there, or the way there can't be looked at: a link or folder on it
/// can't be read, it has more than [`MAX_LINKS`] links, or the path can't be made absolute.
Linked,
}
/// How many links are followed on the way to a path before it is given up on, as on Linux.
const MAX_LINKS: u8 = 40;
/// Why `path` is refused before anything on the way to it is opened, if it is: resolving it would
/// open a path on another computer, which on Windows contacts that computer and may send it the
/// signed-in user's credentials, or open a device (#1094). That is the case when the path as
/// given or made absolute is refused by its spelling ([`refused_spelling`]), or when a link on
/// the way, or on the way on from where one leads, leads to such a path ([`link_refused`]). A path
/// on the share of one of `roots` goes on to the usual check. A path that can't be made absolute
/// is refused as well, rather than left to what comes next.
fn refused_unresolved(path: &Path, roots: &[PathBuf]) -> Option<Unresolved> {
// Made absolute without looking at the disk (on Windows `GetFullPathNameW`, which also turns a
// bare device name such as `NUL` into `\\.\NUL`, as opening it would). Like opening, it takes
// `..` by name, so `link\..\x` is `x` and never goes through the link.
let Ok(abs) = std::path::absolute(path) else { return Some(Unresolved::Linked) };
if let Some(why) = [path, abs.as_path()].into_iter().find_map(|p| refused_spelling(&p.to_string_lossy(), roots)) {
return Some(Unresolved::Spelled(why));
}
link_refused(&abs, roots, MAX_LINKS, &on_disk).then_some(Unresolved::Linked)
}
/// What is at a path, looked at without following a link there.
#[derive(Debug, Clone, PartialEq, Eq)]
enum Entry {
/// Nothing ([`nothing_there`]): resolving the path meets the same there and goes no further.
Missing,
/// Something that can't be looked at (no permission, for one). It may be a link that resolving
/// the path would still follow, so the path is refused.
Unreadable,
/// A file or a folder.
Plain,
/// A link, with where it leads (`None` when that can't be read).
Link(Option<PathBuf>),
}
/// What is at `p` on disk (see [`Entry`]), looked at with [`std::fs::symlink_metadata`], which
/// doesn't follow a link there; a link's target is read with [`std::fs::read_link`].
fn on_disk(p: &Path) -> Entry {
match std::fs::symlink_metadata(p) {
Ok(m) if m.is_symlink() => Entry::Link(std::fs::read_link(p).ok()),
Ok(_) => Entry::Plain,
Err(e) if nothing_there(&e) => Entry::Missing,
Err(_) => Entry::Unreadable,
}
}
/// Whether looking at a path failed with `e` because nothing is there: no such name, a file where
/// a folder was expected, or a name no file can have. Any other failure says nothing about what is
/// there.
fn nothing_there(e: &std::io::Error) -> bool {
use std::io::ErrorKind::{InvalidFilename, NotADirectory, NotFound};
matches!(e.kind(), NotFound | NotADirectory | InvalidFilename)
}
/// Why path `p` is refused by its spelling alone, if it is (see [`craft_docpath::resolve`], which
/// reads both `/` and `\` as separators and compares names ignoring case):
/// - on another computer (`\\server\share`, `//server/share`, `\\?\UNC\…`, `\\.\UNC\…`, or a
/// server without a share) and on no root's share;
/// - a device path (`\\.\pipe\…`, `\\?\GLOBALROOT\…`, `\\.\C:\…`), other than a local volume's
/// `\\?\Volume{…}\` or `\\.\Volume{…}\`, which a folder can be mounted as;
/// - or with a device name (`CON`, `NUL`, `COM1.png`, `lpt1 `…) as any of its names: each folder on
/// the way is opened in turn while the path is resolved, and the device behind a name such as
/// `LPT1` can be a printer on another computer.
fn refused_spelling(p: &str, roots: &[PathBuf]) -> Option<Refused> {
match craft_docpath::resolve(p, None) {
// With a root passed as the document path (what a link would be relative to), a path on
// that root's share is allowed.
Err(Refused::Network) if !roots.iter().any(|r| craft_docpath::resolve(p, Some(r)) != Err(Refused::Network)) => {
return Some(Refused::Network);
}
Err(Refused::Device) if !is_volume(p) => return Some(Refused::Device),
_ => {}
}
// `craft_docpath` stops at the first name it refuses, which may not be the device's.
p.split(['\\', '/']).any(device_name).then_some(Refused::Device)
}
/// Whether `p` is in a local volume by its `\\?\Volume{…}` (or `\\.\Volume{…}`) name.
fn is_volume(p: &str) -> bool {
let mut names = p.split(['\\', '/']);
let (Some(""), Some(""), Some("?" | "."), Some(volume)) = (names.next(), names.next(), names.next(), names.next()) else {
return false;
};
volume.get(..7).is_some_and(|v| v.eq_ignore_ascii_case("Volume{")) && volume.ends_with('}')
}
/// Whether a link on the way to `abs` (an absolute path) leads to a path [`refused_spelling`]
/// refuses, following at most `links` links: one that leads to another, or on through further
/// links, is followed too, as resolving the path would. A link that can't be read, a name on the
/// way that can't be looked at ([`Entry::Unreadable`]), or more links than that, are refused as
/// well. Each name on the way is looked at with `look` ([`on_disk`]), which doesn't follow a
/// link: where a link leads is looked at only once its spelling is known not to be refused.
fn link_refused(abs: &Path, roots: &[PathBuf], links: u8, look: &dyn Fn(&Path) -> Entry) -> bool {
let mut at = PathBuf::new();
let mut rest = abs.components();
while let Some(c) = rest.next() {
at.push(c);
if !matches!(c, Component::Normal(_)) {
continue;
}
let target = match look(&at) {
Entry::Plain => continue,
// Nothing is below what isn't there, so no link either.
Entry::Missing => return false,
Entry::Unreadable => return true,
Entry::Link(target) => target,
};
let (Some(links), Some(target)) = (links.checked_sub(1), target) else { return true };
// A relative target is relative to the link's folder; an absolute one replaces it.
let next = lexical(&at.parent().unwrap_or(&at).join(target).join(rest.as_path()));
return refused_spelling(&next.to_string_lossy(), roots).is_some() || link_refused(&next, roots, links, look);
}
false
}
/// `p` with its `.` and `..` taken by name, as Windows takes them.
fn lexical(p: &Path) -> PathBuf {
let mut out = PathBuf::new();
for c in p.components() {
match c {
Component::ParentDir => {
out.pop();
}
Component::CurDir => {}
c => out.push(c),
}
}
out
}
/// Whether `path` lies in one of `roots` once made absolute with its `.` and `..` taken by name and
/// its longest leading part that exists resolved, so links on the way are followed as the roots'
/// were (`/tmp/work/x` is inside root `/private/tmp/work`, a link out of a root leads out of it).
fn inside_as_far_as_it_exists(path: &Path, roots: &[PathBuf]) -> bool {
let Ok(abs) = std::path::absolute(path) else { return false };
let mut lexical = PathBuf::new();
for c in abs.components() {
match c {
Component::ParentDir => {
lexical.pop();
}
Component::CurDir => {}
c => lexical.push(c),
}
}
let folded = lexical(&abs);
let mut rest: Vec<&OsStr> = Vec::new();
let mut at = lexical.as_path();
let mut at = folded.as_path();
let resolved = loop {
if let Ok(mut base) = std::fs::canonicalize(at) {
base.extend(rest.iter().rev());
@@ -169,18 +327,24 @@ fn resolve(path: &Path) -> std::result::Result<PathBuf, String> {
fn plain_name(name: &OsStr) -> std::result::Result<(), String> {
if cfg!(windows) {
let n = name.to_string_lossy();
let stem = n.split('.').next().unwrap_or_default().trim_end().to_ascii_uppercase();
let device = matches!(stem.as_str(), "CON" | "PRN" | "AUX" | "NUL" | "CONIN$" | "CONOUT$")
|| ((stem.starts_with("COM") || stem.starts_with("LPT"))
&& stem.chars().count() == 4
&& stem.chars().last().is_some_and(|c| c.is_ascii_digit() || matches!(c, '¹' | '²' | '³')));
if device || n.contains(':') {
if device_name(&n) || n.contains(':') {
return Err(format!("`{n}` is a device or stream name, not a file"));
}
}
Ok(())
}
/// Whether Windows opens a device for file or folder name `n`: `CON`, `PRN`, `AUX`, `NUL`,
/// `CONIN$`, `CONOUT$`, `COM1`…`COM9` and `LPT1`…`LPT9` (also with `¹`, `²` or `³`), in any case,
/// and with anything after a dot or a colon or trailing spaces (`nul.txt`, `COM1 .png`, `con:x`).
fn device_name(n: &str) -> bool {
let stem = n.split(['.', ':']).next().unwrap_or_default().trim_end().to_ascii_uppercase();
matches!(stem.as_str(), "CON" | "PRN" | "AUX" | "NUL" | "CONIN$" | "CONOUT$")
|| ((stem.starts_with("COM") || stem.starts_with("LPT"))
&& stem.chars().count() == 4
&& stem.chars().last().is_some_and(|c| c.is_ascii_digit() || matches!(c, '¹' | '²' | '³')))
}
thread_local! {
static ROOTS: RefCell<Option<Arc<Roots>>> = const { RefCell::new(None) };
}
crates/engine/src/automation/file_access/tests.rs
+277
View File
@@ -191,6 +191,283 @@ fn windows_case_devices_and_streams() {
assert!(!e.contains(r"\\?\"), "{e}");
}
/// How each spelling of a path on another computer or of a device is told apart from a local path
/// (#1094), on every system: only Windows checks them, but they are spelled the same everywhere.
#[test]
fn spellings_of_other_computers_and_devices_are_refused() {
use super::refused_spelling;
use craft_docpath::Refused::{Device, Network};
let local = [PathBuf::from(r"C:\work")];
// On `\\192.0.2.1\share`.
let on_the_share = [
r"\\192.0.2.1\share\x.png",
"//192.0.2.1/share/x.png",
r"\/192.0.2.1/share\x.png",
r"\\?\UNC\192.0.2.1\share\x.png",
r"\\?\unc\192.0.2.1\share\x.png",
"//?/UNC/192.0.2.1/share/x.png",
r"\\.\UNC\192.0.2.1\share\x.png",
];
let elsewhere = [
// A server without a share is contacted too.
r"\\192.0.2.1",
r"\\192.0.2.1\",
r"\\SERVER.\share \x.png",
];
let network = [&on_the_share[..], &elsewhere[..]].concat();
let device = [
r"\\.\pipe\figcraft",
r"\\?\GLOBALROOT\Device\Mup\192.0.2.1\share\x.png",
r"\\.\C:\work\x.png",
r"\\.\COM1",
r"\??\UNC\192.0.2.1\share\x.png",
// A device name anywhere: each folder on the way is opened as the path is resolved.
r"C:\work\COM1",
r"C:\work\nul.txt",
r"C:\work\Com1 .png",
r"C:\work\lpt1.\x.png",
r"C:\work\LPT³\x.png",
r"C:\work\conout$",
r"C:\work\aux:stream",
// After a name `craft_docpath` refuses for another reason.
r"C:\work\a:b\prn.png",
];
let fine = [
r"C:\work\x.png",
r"\\?\C:\work\x.png",
r"C:\work\console.png",
r"C:\work\com10.png",
r"C:\work\lpt.png",
r"C:\work\nul-ish.txt",
r"\\?\Volume{0b3b1c63-0000-0000-0000-100000000000}\x.png",
r"\\.\Volume{0b3b1c63-0000-0000-0000-100000000000}\x.png",
"/home/u/work/x.png",
"x.png",
r"..\x.png",
];
for (paths, want) in [(&network[..], Some(Network)), (&device[..], Some(Device)), (&fine[..], None)] {
for p in paths {
assert_eq!(refused_spelling(p, &[]), want, "{p}");
assert_eq!(refused_spelling(p, &local), want, "{p} with a local root");
}
}
// A root on a share lets the paths on that share through, in any case and spelling, and only them:
// every spelling above of a path on `\\192.0.2.1\share`, but not the server without a share
// or another server.
for root in [r"\\?\UNC\192.0.2.1\share", r"\\192.0.2.1\share\work"] {
let on_share = [PathBuf::from(root)];
for p in on_the_share {
assert_eq!(refused_spelling(p, &on_share), None, "{p} with root {root}");
}
for p in elsewhere {
assert_eq!(refused_spelling(p, &on_share), Some(Network), "{p} with root {root}");
}
}
let shared = [PathBuf::from(r"\\?\UNC\Server\Share\work")];
for p in [r"\\server\SHARE\work\x.png", r"\\?\UNC\SERVER\share\elsewhere\x.png", "//Server/Share/work/x.png"] {
assert_eq!(refused_spelling(p, &shared), None, "{p}");
}
for p in [r"\\server\other\x.png", r"\\other\share\x.png", r"\\server", r"\\server.\share\x.png"] {
assert_eq!(refused_spelling(p, &shared), Some(Network), "{p}");
}
assert_eq!(refused_spelling(r"\\server\share\work\COM1", &shared), Some(Device));
}
/// The links on the way to a path are followed by their spelling before anything they lead to is
/// opened (#1094). The links are made up here, so this runs where tests may not make links.
#[test]
fn links_on_the_way_are_followed_by_their_spelling_first() {
use super::{Entry, MAX_LINKS, link_refused};
use std::cell::RefCell;
use std::collections::HashMap;
let base = std::env::temp_dir().join("figcraft-links");
let at = |rel: &str| base.join(rel);
let mut links: HashMap<PathBuf, Option<PathBuf>> = HashMap::from([
// Relative to the link's folder, to a device name.
(at("root/dev"), Some(PathBuf::from("../outside/nul"))),
// To another link.
(at("root/hop"), Some(at("root/dev"))),
// Within the root.
(at("root/alias"), Some(PathBuf::from("sub"))),
(at("root/loop"), Some(at("root/loop"))),
(at("root/unreadable"), None),
// Below a name that isn't there: never looked at.
(at("missing/dev"), Some(PathBuf::from("nul"))),
]);
if cfg!(windows) {
links.insert(at("root/remote"), Some(PathBuf::from(r"\\192.0.2.1\share")));
links.insert(at("root/far"), Some(at("root/remote/work")));
}
// Chains of `n` links, `root/<n>-1` to `root/<n>-2` and so on, the last one to `root/sub`.
for n in [MAX_LINKS - 1, MAX_LINKS, MAX_LINKS + 1] {
for i in 1..=n {
let next = if i == n { at("root/sub") } else { at(&format!("root/{n}-{}", i + 1)) };
links.insert(at(&format!("root/{n}-{i}")), Some(next));
}
}
let plain = [at("root"), at("root/sub"), at("outside")];
// What can't be looked at (no permission, say) may be a link, so it isn't taken for nothing.
let unreadable = at("root/locked");
let looked = RefCell::new(Vec::new());
let look = |p: &Path| {
looked.borrow_mut().push(p.to_path_buf());
match links.get(p) {
Some(target) => Entry::Link(target.clone()),
None if base.starts_with(p) || plain.iter().any(|q| q == p) => Entry::Plain,
None if p == unreadable => Entry::Unreadable,
None => Entry::Missing,
}
};
let refused = |rel: &str, roots: &[PathBuf]| link_refused(&at(rel), roots, MAX_LINKS, &look);
for rel in ["root/dev/x.png", "root/hop/x.png", "root/loop/x.png", "root/unreadable/x.png", "root/locked/x.png", "root/locked"] {
assert!(refused(rel, &[]), "{rel}");
}
for rel in ["root/alias/x.png", "root/sub/x.png", "root/x.png", "missing/dev/x.png"] {
assert!(!refused(rel, &[]), "{rel}");
}
// As many links as are followed lead on; one more is refused.
assert!(!refused(&format!("root/{}-1/x.png", MAX_LINKS - 1), &[]));
assert!(!refused(&format!("root/{MAX_LINKS}-1/x.png"), &[]));
assert!(refused(&format!("root/{}-1/x.png", MAX_LINKS + 1), &[]));
// A refused target isn't looked at, nor is anything below what isn't there.
let looked = looked.take();
assert!(!looked.contains(&at("outside/nul")) && !looked.contains(&at("missing/dev")), "{looked:?}");
if cfg!(windows) {
for rel in ["root/remote/x.png", "root/far/x.png"] {
assert!(refused(rel, &[]), "{rel}");
// Unless a root is on that share.
assert!(!refused(rel, &[PathBuf::from(r"\\?\UNC\192.0.2.1\share")]), "{rel}");
}
}
}
/// A path that can't be looked at is refused rather than taken for one with nothing there (#1094):
/// only a failure that says nothing is there lets the walk stop, and a path that can't even be
/// made absolute isn't left to the checks after it.
#[test]
fn what_cannot_be_looked_at_is_refused() {
use super::{Unresolved, nothing_there, refused_unresolved};
use std::io::{Error, ErrorKind};
for kind in [ErrorKind::NotFound, ErrorKind::NotADirectory, ErrorKind::InvalidFilename] {
assert!(nothing_there(&Error::from(kind)), "{kind:?}");
}
for kind in [ErrorKind::PermissionDenied, ErrorKind::ResourceBusy, ErrorKind::Interrupted, ErrorKind::Other] {
assert!(!nothing_there(&Error::from(kind)), "{kind:?}");
}
assert_eq!(refused_unresolved(Path::new(""), &[]), Some(Unresolved::Linked));
}
/// On Windows a path is classified as Windows opens it (#1094): with `..` taken by name before
/// anything is opened (so a link followed by `..` is never gone through), and with names that
/// aren't Unicode (a lone surrogate) still read for the parts that are spelled in ASCII.
#[cfg(windows)]
#[test]
fn paths_are_classified_as_windows_opens_them() {
use super::{Unresolved, refused_unresolved};
use craft_docpath::Refused::{Device, Network};
use std::ffi::OsString;
use std::os::windows::ffi::OsStringExt;
assert_eq!(std::path::absolute(r"C:\work\remote\..\x.png").unwrap(), PathBuf::from(r"C:\work\x.png"));
// `before`, a lone surrogate, then `after`.
let odd = |before: &str, after: &str| {
let wide: Vec<u16> = before.encode_utf16().chain([0xD800]).chain(after.encode_utf16()).collect();
PathBuf::from(OsString::from_wide(&wide))
};
assert_eq!(refused_unresolved(&odd(r"\\192.0.2.1\share\", ".png"), &[]), Some(Unresolved::Spelled(Network)));
assert_eq!(refused_unresolved(&odd(r"C:\figcraft-no-such-folder\", r"\nul"), &[]), Some(Unresolved::Spelled(Device)));
assert_eq!(refused_unresolved(&odd(r"C:\figcraft-no-such-folder\", ".png"), &[]), None);
// A NUL can't be passed to Windows at all, so the path can't be made absolute.
assert_eq!(refused_unresolved(Path::new("C:\\work\\a\0b.png"), &[]), Some(Unresolved::Linked));
}
/// `..` after a link is taken by name, by the check and by Windows when it opens the path, so
/// `root\j\..\in.txt` is `root\in.txt` and the link `j` is never gone through (#1094). Shown with
/// a junction, a link any account can make: `j` leads out of the root to `outside`, and beside
/// `outside` is another `in.txt`, which is what `..` would reach through the link.
#[cfg(windows)]
#[test]
fn a_parent_after_a_link_is_taken_by_name() {
use super::{Entry, on_disk};
let f = Fixture::new("parent");
let r = f.rw();
std::fs::write(f.0.join("in.txt"), b"beside").unwrap();
let made = std::process::Command::new("cmd").args(["/C", "mklink", "/J"]).arg(f.0.join(r"root\j")).arg(f.0.join("outside")).output();
assert!(made.is_ok_and(|o| o.status.success()), "a junction can be made");
// The junction is a link to the check, and what is through it is outside.
assert!(matches!(on_disk(&f.0.join(r"root\j")), Entry::Link(Some(_))));
assert!(r.check(Path::new(&f.p(r"root\j\secret.txt")), Access::Read).is_err());
let through = f.p(r"root\j\..\in.txt");
assert_eq!(r.check(Path::new(&through), Access::Read), r.check(Path::new(&f.p(r"root\in.txt")), Access::Read));
assert!(r.check(Path::new(&through), Access::Read).is_ok());
assert_eq!(std::fs::read(&through).unwrap(), b"in", "Windows opens the file in the root");
}
/// A path on another computer and a device path are refused before anything is opened: resolving
/// them made Windows contact the server, which may send it the signed-in user's credentials
/// (#1094). Each is refused with a message that only the check before resolving gives: had the
/// path been resolved, 192.0.2.1 (an address for documentation, where nothing answers) would have
/// been contacted and the message would be the one for a path that can't be resolved.
#[cfg(windows)]
#[test]
fn other_computers_and_devices_are_refused_before_anything_is_opened() {
let f = Fixture::new("network");
let r = f.rw();
let read_only = Roots::new(&[f.p("root")], &[]).unwrap();
let refused = |roots: &Roots, p: &str, access: Access| roots.check(Path::new(p), access).expect_err(p);
for p in
[r"\\192.0.2.1\share\x.png", "//192.0.2.1/share/x.png", r"\\?\UNC\192.0.2.1\share\x.png", r"\\.\UNC\192.0.2.1\share\x.png", r"\\192.0.2.1"]
{
for access in [Access::Read, Access::Write] {
let e = refused(&r, p, access);
assert!(e.contains("is on another computer, and no folder that may be"), "{p}: {e}");
}
let e = refused(&read_only, p, Access::Write);
assert!(e.ends_with("is on another computer, and no folder that may be written is on its share"), "{p}: {e}");
}
for p in [r"\\.\pipe\figcraft-roots", r"\\?\GLOBALROOT\Device\Mup\192.0.2.1\share\x.png", &f.p(r"root\COM1\x.png"), "nul"] {
for access in [Access::Read, Access::Write] {
let e = refused(&r, p, access);
assert!(e.ends_with("names a device, not a file"), "{p}: {e}");
}
}
// Local paths, in either spelling, are checked as before.
let inside = std::fs::canonicalize(f.p("root")).unwrap().join("in.txt");
assert!(r.check(&inside, Access::Read).is_ok());
assert!(r.check(Path::new(&f.p(r"root\in.txt")), Access::Read).is_ok());
}
/// A link in a root to another computer is refused before it is followed (#1094), also through
/// another link, and with the message any path outside gets: it doesn't tell where the link
/// leads. Had the link been followed, the message would be the one for a path that can't be
/// resolved. This needs real links, which Windows lets only some accounts make: elsewhere it
/// says so and checks nothing (`links_on_the_way_are_followed_by_their_spelling_first` covers the
/// same walk with made-up links on every system).
#[cfg(windows)]
#[test]
fn links_to_other_computers_are_refused_before_they_are_followed() {
let f = Fixture::new("network-links");
let r = f.rw();
if !symlink_dir(Path::new(r"\\192.0.2.1\share"), &f.0.join("root/remote")) || !symlink_dir(&f.0.join("root/remote/work"), &f.0.join("root/hop")) {
eprintln!("skipped: this system doesn't let tests make symbolic links");
return;
}
// Relative to the link's folder.
assert!(symlink_dir(Path::new(r"..\remote"), &f.0.join("root/sub/up")));
assert!(symlink_file(Path::new(r"\\.\pipe\figcraft-roots"), &f.0.join("root/pipe")));
let standard = |p: &str| format!("automation path rejected: {p} is outside the folders that may be");
for p in [f.p("root/remote/x.png"), f.p("root/hop/x.png"), f.p("root/sub/up/x.png"), f.p("root/pipe")] {
for access in [Access::Read, Access::Write] {
let e = r.check(Path::new(&p), access).expect_err(&p);
assert!(e.starts_with(&standard(&p)), "{p}: {e}");
}
}
// `..` after the link is taken by name, so the link isn't gone through.
assert!(r.check(Path::new(&f.p(r"root\remote\..\in.txt")), Access::Read).is_ok());
// A link to a folder in the root still leads there.
assert!(symlink_dir(&f.0.join("root/sub"), &f.0.join("root/alias")));
assert!(r.check(Path::new(&f.p("root/alias/x.png")), Access::Write).is_ok());
}
#[test]
fn a_scope_confines_the_thread_and_ends_with_it() {
let f = Fixture::new("scope");
crates/engine/src/board_mindmap_tests.rs
+385
View File
@@ -0,0 +1,385 @@
//! Mind maps (#2226): `board.mindMap` and `board.mindMapAdd` make nodes and branches, and the
//! normalize pass lays a touched map out again from its first node after every edit.
use figcraft_color::{Color, Paint};
use figcraft_doc::{BoardItem, Connector, Document, END_GAP, End, LetterSpacing, LineHeight, NodeId, NodeKind, Routing, Side, StrokeCap};
use figcraft_geom::{Point, Rect};
use serde_json::{Value, json};
use crate::Session;
use crate::board::text_of;
use crate::board_tests::{board, connector, drawn, id, near, node};
use crate::collab_live_tests::Room;
fn bx(s: &Session, id: NodeId) -> Rect {
s.doc().unwrap().world_bounds(id).unwrap()
}
fn same(a: f64, b: f64) -> bool {
(a - b).abs() < 1e-6
}
/// `board.mindMap` at (100, 200): the first node, its three children and their branches.
fn map(s: &mut Session) -> (NodeId, [NodeId; 3], [NodeId; 3]) {
let out = s.execute("board.mindMap", &json!({"x": 100, "y": 200})).unwrap();
let kids: Vec<Value> = out["children"].as_array().unwrap().clone();
let (c, k): (Vec<NodeId>, Vec<NodeId>) = kids.iter().map(|v| (id(v, "id"), id(v, "connector"))).unzip();
(id(&out, "id"), [c[0], c[1], c[2]], [k[0], k[1], k[2]])
}
fn text_data(s: &Session, n: NodeId) -> figcraft_doc::TextData {
let t = text_of(s.doc().unwrap(), n).unwrap();
match node(s, t).kind {
NodeKind::Text(td) => td,
other => panic!("not text: {other:?}"),
}
}
fn is_mind_node(s: &Session, n: NodeId) -> bool {
node(s, n).board == Some(BoardItem::MindNode)
}
/// The nodes hanging off `parent`, top to bottom, in `doc`.
fn kids(doc: &Document, parent: NodeId) -> Vec<NodeId> {
let mut v: Vec<(f64, NodeId)> = doc
.nodes()
.filter_map(|n| match &n.board {
Some(BoardItem::Connector(Connector { from: End::Node { node, .. }, to: End::Node { node: to, .. }, branch: true, .. }))
if *node == parent =>
{
doc.world_bounds(*to).map(|b| (b.center().y, *to))
}
_ => None,
})
.collect();
v.sort_by(|a, b| a.0.total_cmp(&b.0));
v.into_iter().map(|p| p.1).collect()
}
fn places(s: &Session, ids: &[NodeId]) -> Vec<Rect> {
ids.iter().map(|i| bx(s, *i)).collect()
}
fn branches(s: &Session) -> Vec<NodeId> {
s.doc().unwrap().nodes().filter(|n| matches!(&n.board, Some(BoardItem::Connector(c)) if c.branch)).map(|n| n.id).collect()
}
/// Starter child `i` (`k`, on branch `line`) of the first node: its text, its place and its branch.
fn check_child(s: &Session, root: NodeId, (k, line): (NodeId, NodeId), i: usize) {
let r = bx(s, root);
let td = text_data(s, k);
assert_eq!(td.characters, ["Idea 1", "Idea 2", "Idea 3"][i]);
assert_eq!((td.style.font_size, td.style.font_style.as_str()), (16.0, "Medium"));
assert_eq!((td.style.line_height, td.style.letter_spacing), (LineHeight::Percent(150.0), LetterSpacing::Percent(-1.1)));
let b = bx(s, k);
assert!(same(b.x0, r.x1 + 88.0), "child {i}: 88 right of the root");
assert_eq!(b.height(), 24.0);
let t = bx(s, text_of(s.doc().unwrap(), k).unwrap());
assert!(same(b.width(), t.width()), "child {i}: the node is its text, no padding");
assert!(is_mind_node(s, k));
let want = Connector {
from: End::Node { node: root, side: Side::Right, at: None },
to: End::Node { node: k, side: Side::Left, at: None },
routing: Routing::Curved,
path: None,
branch: true,
};
assert_eq!(connector(s, line), want);
let l = node(s, line);
assert_eq!((l.stroke.cap_start, l.stroke.cap_end), (StrokeCap::Round, StrokeCap::Round));
assert_eq!((l.stroke.weight, l.strokes), (4.0, vec![Paint::solid(Color::from_rgb8_const(0x75, 0x75, 0x75))]));
let pts = drawn(s, line);
assert!(near(pts[0], Point::new(r.x1 + END_GAP, r.center().y)), "{pts:?}");
assert!(near(*pts.last().unwrap(), Point::new(b.x0 - END_GAP, b.center().y)), "{pts:?}");
}
#[test]
fn a_mind_map_is_a_first_node_with_three_children_on_branches() {
let mut s = board();
let before = s.doc().unwrap().ids().count();
let depth = s.undo_depth().0;
let (root, kids, lines) = map(&mut s);
assert_eq!(node(&s, root).board, Some(BoardItem::MindNode));
assert!(node(&s, root).is_board_atom());
let r = bx(&s, root);
assert_eq!((r.x0, r.y0), (100.0, 200.0));
let td = text_data(&s, root);
assert_eq!((td.characters.as_str(), td.style.font_size, td.style.font_style.as_str()), ("Topic", 24.0, "Bold"));
assert_eq!((td.style.line_height, td.style.letter_spacing), (LineHeight::Percent(150.0), LetterSpacing::Percent(-1.9)));
assert_eq!(r.height(), 36.0, "one line at 150%");
let text = text_of(s.doc().unwrap(), root).unwrap();
assert_eq!(node(&s, text).fills, vec![Paint::solid(Color::from_rgb8_const(0x1E, 0x1E, 0x1E))]);
for (i, pair) in kids.into_iter().zip(lines).enumerate() {
check_child(&s, root, pair, i);
}
let h = bx(&s, kids[0]).height();
assert!(same(bx(&s, kids[1]).center().y, r.center().y));
assert!(same(bx(&s, kids[0]).center().y, r.center().y - h - 48.0));
assert!(same(bx(&s, kids[2]).center().y, r.center().y + h + 48.0));
assert_eq!(s.selection(), vec![root]);
assert_eq!(s.undo_depth().0, depth + 1);
s.execute("edit.undo", &json!({})).unwrap();
assert_eq!(s.doc().unwrap().ids().count(), before);
}
#[test]
fn a_new_child_goes_below_its_siblings_and_the_stack_stays_centred() {
let mut s = board();
let (root, kids3, _) = map(&mut s);
let h = bx(&s, kids3[0]).height();
let was = places(&s, &kids3);
s.ui_requests.clear();
let out = s.execute("board.mindMapAdd", &json!({"id": root, "text": "Four", "edit": true})).unwrap();
let new = id(&out, "id");
assert!(is_mind_node(&s, new));
assert_eq!(text_data(&s, new).style.font_size, 16.0);
let order = kids(s.doc().unwrap(), root);
assert_eq!(order, [kids3[0], kids3[1], kids3[2], new]);
let cy: Vec<f64> = order.iter().map(|n| bx(&s, *n).center().y).collect();
assert!(cy.windows(2).all(|w| same(w[1] - w[0], h + 48.0)), "{cy:?}");
assert!(same((cy[0] + cy[3]) / 2.0, bx(&s, root).center().y));
assert!(same(bx(&s, kids3[0]).y0, was[0].y0 - (h + 48.0) / 2.0), "the first one moved up 36");
assert_eq!(s.selection(), vec![new]);
assert!(s.ui_requests.iter().any(|q| q.kind == "board.editText" && q.data["id"] == json!(new)));
s.execute("edit.undo", &json!({})).unwrap();
assert_eq!(places(&s, &kids3), was, "the three are back exactly");
// Without an id the selected first node is the one.
s.execute("select.set", &json!({"ids": [root]})).unwrap();
s.execute("board.mindMapAdd", &json!({})).unwrap();
assert_eq!(kids(s.doc().unwrap(), root).len(), 4);
}
#[test]
fn a_childs_child_starts_the_next_column_and_a_sibling_goes_right_after() {
let mut s = board();
let (root, [c0, c1, c2], _) = map(&mut s);
let h = bx(&s, c0).height();
let g1 = id(&s.execute("board.mindMapAdd", &json!({"id": c0})).unwrap(), "id");
let g2 = id(&s.execute("board.mindMapAdd", &json!({"id": c0})).unwrap(), "id");
let column = [c0, c1, c2].iter().map(|n| bx(&s, *n).x1).fold(f64::MIN, f64::max) + 88.0;
assert!(same(bx(&s, g1).x0, column) && same(bx(&s, g2).x0, column), "past the widest of the three");
assert!(same(bx(&s, g2).center().y - bx(&s, g1).center().y, h + 48.0));
assert!(same((bx(&s, g1).center().y + bx(&s, g2).center().y) / 2.0, bx(&s, c0).center().y));
for g in [g1, g2] {
let line = s.doc().unwrap().nodes().find(|n| matches!(&n.board, Some(BoardItem::Connector(c)) if c.to.node() == Some(g))).unwrap().id;
assert!(matches!(connector(&s, line).from, End::Node { node, side: Side::Right, .. } if node == c0));
}
assert!(same(bx(&s, c1).center().y - bx(&s, c0).center().y, (2.0 * h + 48.0) / 2.0 + 48.0 + h / 2.0), "108 below");
let new = id(&s.execute("board.mindMapAdd", &json!({"id": c1, "relation": "sibling"})).unwrap(), "id");
let line = s.doc().unwrap().nodes().find(|n| matches!(&n.board, Some(BoardItem::Connector(c)) if c.to.node() == Some(new))).unwrap().id;
assert!(matches!(connector(&s, line).from, End::Node { node, .. } if node == root));
assert_eq!(kids(s.doc().unwrap(), root), [c0, c1, new, c2]);
}
#[test]
fn more_lines_push_the_siblings_apart() {
let mut s = board();
let (root, [c0, c1, c2], _) = map(&mut s);
let (h, was) = (bx(&s, c1).height(), places(&s, &[c0, c1, c2]));
let t = text_of(s.doc().unwrap(), c1).unwrap();
s.execute("node.set", &json!({"id": t, "props": {"characters": "one\ntwo\nthree"}})).unwrap();
let h3 = bx(&s, c1).height();
assert_eq!((h, h3), (24.0, 72.0));
assert!(same(bx(&s, c1).center().y, bx(&s, root).center().y));
for k in [c0, c2] {
assert!(same((bx(&s, k).center().y - bx(&s, c1).center().y).abs(), (h + h3) / 2.0 + 48.0));
}
assert!(same(bx(&s, c0).y0, was[0].y0 - (h3 - h) / 2.0), "24 up");
s.execute("edit.undo", &json!({})).unwrap();
assert_eq!(places(&s, &[c0, c1, c2]), was);
}
#[test]
fn the_first_node_carries_the_map_and_a_child_moved_by_hand_goes_back_or_swaps() {
let mut s = board();
let (root, kids3, lines) = map(&mut s);
let was = places(&s, &kids3);
s.execute("transform.move", &json!({"ids": [root], "dx": 50, "dy": 30})).unwrap();
for (k, w) in kids3.iter().zip(&was) {
let b = bx(&s, *k);
assert!(same(b.x0, w.x0 + 50.0) && same(b.y0, w.y0 + 30.0), "{b:?} from {w:?}");
}
for l in lines {
assert!(near(drawn(&s, l)[0], Point::new(bx(&s, root).x1 + END_GAP, bx(&s, root).center().y)));
}
let now = places(&s, &kids3);
s.execute("transform.move", &json!({"ids": [kids3[2]], "dx": 300, "dy": 5})).unwrap();
assert_eq!(places(&s, &kids3), now, "it goes back");
s.execute("transform.move", &json!({"ids": [kids3[0]], "dx": 0, "dy": 100})).unwrap();
assert_eq!(kids(s.doc().unwrap(), root), [kids3[1], kids3[0], kids3[2]], "past the middle one's middle: they swap");
assert!(same(bx(&s, kids3[1]).center().y, bx(&s, root).center().y - 72.0));
}
#[test]
fn a_deleted_node_leaves_its_children_in_place_and_takes_its_branches() {
let mut s = board();
let (root, [c0, c1, c2], _) = map(&mut s);
let h = bx(&s, c0).height();
let g = id(&s.execute("board.mindMapAdd", &json!({"id": c1})).unwrap(), "id");
let at = bx(&s, g);
let (undo, _) = s.undo_depth();
s.execute("edit.delete", &json!({"ids": [c1]})).unwrap();
let left = branches(&s);
assert_eq!(left.len(), 2, "the root's two others");
for l in &left {
assert!(!matches!(connector(&s, *l).to, End::Node { node, .. } if node == c1 || node == g), "none to the gone node or its child");
}
assert_eq!(bx(&s, g), at, "the child stays where it was");
assert!(is_mind_node(&s, g));
let r = bx(&s, root).center().y;
assert!(same(bx(&s, c0).center().y, r - (h + 48.0) / 2.0) && same(bx(&s, c2).center().y, r + (h + 48.0) / 2.0));
let line = s.doc().unwrap().nodes().find(|n| matches!(&n.board, Some(BoardItem::Connector(c)) if c.to.node() == Some(c2))).unwrap().id;
let spot = bx(&s, c2);
s.execute("edit.delete", &json!({"ids": [line]})).unwrap();
assert_eq!(bx(&s, c2), spot, "a detached node stays");
assert!(same(bx(&s, c0).center().y, r));
assert_eq!(branches(&s).len(), 1);
s.execute("edit.undo", &json!({})).unwrap();
s.execute("edit.undo", &json!({})).unwrap();
assert_eq!(s.undo_depth().0, undo);
assert_eq!(branches(&s).len(), 4);
assert!(s.doc().unwrap().contains(c1));
}
#[test]
fn two_people_adding_at_once_end_with_one_layout() {
let mut s = board();
let (root, [c0, ..], _) = map(&mut s);
let h = bx(&s, c0).height();
let mut room = Room::new(s.doc().unwrap().clone(), 2, 7);
for i in 0..2 {
room.s(i).execute("board.mindMapAdd", &json!({"id": root})).unwrap();
}
room.settle();
room.check();
let doc = room.server.document();
let order = kids(doc, root);
assert_eq!(order.len(), 5);
let centres = |doc: &Document, order: &[NodeId]| order.iter().map(|n| doc.world_bounds(*n).unwrap().center().y).collect::<Vec<f64>>();
let cy = centres(doc, &order);
assert!(cy.windows(2).all(|w| w[1] > w[0] && same(w[1] - w[0], h + 48.0)), "{cy:?}");
assert!(same((cy[0] + cy[4]) / 2.0, doc.world_bounds(root).unwrap().center().y));
// One makes a child three lines tall while the other adds one.
let t = text_of(doc, order[1]).unwrap();
room.s(0).execute("node.set", &json!({"id": t, "props": {"characters": "one\ntwo\nthree"}})).unwrap();
room.s(1).execute("board.mindMapAdd", &json!({"id": root})).unwrap();
room.settle();
room.check();
let doc = room.server.document();
let order = kids(doc, root);
assert_eq!(order.len(), 6);
let (boxes, mut gap_ok) = (order.iter().map(|n| doc.world_bounds(*n).unwrap()).collect::<Vec<Rect>>(), true);
for w in boxes.windows(2) {
gap_ok &= same(w[1].y0 - w[0].y1, 48.0);
}
assert!(gap_ok, "48 between every pair: {boxes:?}");
assert!(boxes.iter().any(|b| same(b.height(), 3.0 * h)));
let (top, bottom) = (boxes[0].y0, boxes[5].y1);
assert!(same((top + bottom) / 2.0, doc.world_bounds(root).unwrap().center().y));
}
#[test]
fn refusals_saved_files_and_a_second_pass_changes_nothing() {
let mut d = Session::new();
d.execute("file.new", &json!({})).unwrap();
for cmd in ["board.mindMap", "board.mindMapAdd"] {
assert!(matches!(d.execute(cmd, &json!({})), Err(crate::EngineError::Disabled(..))), "{cmd} on a design file");
}
let mut s = board();
let (root, ..) = map(&mut s);
let sticky = id(&s.execute("board.sticky", &json!({"x": 900, "y": 0})).unwrap(), "id");
for p in [json!({"id": sticky}), json!({"id": root, "relation": "cousin"}), json!({"id": root, "relation": "sibling"})] {
assert!(s.execute("board.mindMapAdd", &p).is_err(), "{p}");
}
s.execute("select.none", &json!({})).unwrap();
assert!(s.execute("board.mindMapAdd", &json!({})).is_err(), "nothing selected");
let twenty_one: Vec<String> = (0..21).map(|i| format!("n{i}")).collect();
assert!(s.execute("board.mindMap", &json!({"children": twenty_one})).is_err());
assert!(s.execute("board.mindMap", &json!({"children": "x"})).is_err());
let doc = s.doc().unwrap();
let (back, _) = figcraft_format::from_json(&figcraft_format::to_json(doc).unwrap().to_string()).unwrap();
assert_eq!(back.nodes().filter(|n| n.board == Some(BoardItem::MindNode)).count(), 4);
assert_eq!(back.nodes().filter(|n| matches!(&n.board, Some(BoardItem::Connector(c)) if c.branch)).count(), 3);
// An ordinary connector writes no `branch`; a file without it reads `false`.
let mut plain = board();
let a = id(&plain.execute("board.sticky", &json!({"x": 0, "y": 0})).unwrap(), "id");
let b = id(&plain.execute("board.sticky", &json!({"x": 400, "y": 0})).unwrap(), "id");
plain.execute("board.connector", &json!({"from": a, "to": b})).unwrap();
assert!(!figcraft_format::to_json(plain.doc().unwrap()).unwrap().to_string().contains("\"branch\""));
let item: BoardItem = serde_json::from_value(json!({"type": "connector", "from": {"x": 0, "y": 0}, "to": {"x": 1, "y": 1}})).unwrap();
assert!(matches!(item, BoardItem::Connector(c) if !c.branch));
// Every layer touched again: a laid out map is not an edit.
let mut again = doc.clone();
again.mark_dirty(doc.ids().collect::<Vec<_>>());
crate::normalize(&mut again, doc);
assert!(again == *doc, "a second pass changes nothing");
}
/// Every layer touched again on a copy of `s`'s document: a map in place is left as it is.
fn second_pass_is_a_no_op(s: &Session) {
let doc = s.doc().unwrap();
let mut again = doc.clone();
again.mark_dirty(doc.ids().collect::<Vec<_>>());
crate::normalize(&mut again, doc);
assert!(again == *doc, "a second pass changes nothing");
}
#[test]
fn a_map_around_its_own_container_stays_put() {
let mut s = board();
let sec = id(&s.execute("node.create", &json!({"type": "section", "x": 0, "y": 0, "width": 800, "height": 600})).unwrap(), "id");
let out = s.execute("board.mindMap", &json!({"parent": sec, "x": 40, "y": 40})).unwrap();
let line = id(&out["children"][1], "connector");
s.execute("board.reattach", &json!({"id": line, "end": "to", "target": sec})).unwrap();
let was = bx(&s, sec);
second_pass_is_a_no_op(&s);
s.execute("node.set", &json!({"id": id(&out, "id"), "props": {"name": "again"}})).unwrap();
assert_eq!(bx(&s, sec), was, "the section stays where it is");
second_pass_is_a_no_op(&s);
}
#[test]
fn a_branch_moved_by_its_start_leaves_no_gap_and_odd_structures_settle() {
let mut s = board();
let (root, [c0, c1, c2], lines) = map(&mut s);
let (h, at) = (bx(&s, c1).height(), bx(&s, c1));
s.execute("board.reattach", &json!({"id": lines[1], "end": "from", "target": {"x": 900, "y": 900}})).unwrap();
assert_eq!(branches(&s).len(), 2, "one branch fewer");
assert_eq!(bx(&s, c1), at, "that child stays where it was");
let r = bx(&s, root).center().y;
assert!(same(bx(&s, c0).center().y, r - (h + 48.0) / 2.0), "{:?}", bx(&s, c0));
assert!(same(bx(&s, c2).center().y, r + (h + 48.0) / 2.0), "{:?}", bx(&s, c2));
second_pass_is_a_no_op(&s);
// Two branches arrive at one node: the lower connector id stays its parent.
let mut s = board();
let (root, [c0, c1, _], lines) = map(&mut s);
let g = id(&s.execute("board.mindMapAdd", &json!({"id": c0})).unwrap(), "id");
let gl = branches(&s).into_iter().find(|b| !lines.contains(b)).unwrap();
s.execute("board.reattach", &json!({"id": gl, "end": "to", "target": c1})).unwrap();
assert_eq!(kids(s.doc().unwrap(), root).len(), 3);
assert!(same(bx(&s, c1).x0, bx(&s, root).x1 + 88.0), "c1 stays in the root's column");
assert!(is_mind_node(&s, g));
second_pass_is_a_no_op(&s);
// A cycle: nothing in it moves, and nothing changes after.
let mut s = board();
let (_, [c0, ..], lines) = map(&mut s);
let g = id(&s.execute("board.mindMapAdd", &json!({"id": c0})).unwrap(), "id");
let gg = id(&s.execute("board.mindMapAdd", &json!({"id": g})).unwrap(), "id");
s.execute("board.reattach", &json!({"id": lines[0], "end": "from", "target": gg})).unwrap();
let ring = places(&s, &[c0, g, gg]);
second_pass_is_a_no_op(&s);
assert_eq!(places(&s, &[c0, g, gg]), ring);
}
#[test]
fn the_caps_refuse_what_is_too_far_and_cut_what_is_too_long() {
let mut s = board();
assert!(s.execute("board.mindMap", &json!({"x": 2.0e9})).is_err());
assert!(s.execute("board.mindMap", &json!({"y": -2.0e9})).is_err());
let long = "x".repeat(600);
let out = s.execute("board.mindMap", &json!({"text": long, "children": [long]})).unwrap();
assert_eq!(text_data(&s, id(&out, "id")).characters.chars().count(), 500);
assert_eq!(text_data(&s, id(&out["children"][0], "id")).characters.chars().count(), 500);
}
crates/engine/src/board_tests.rs
+66 -8
View File
@@ -7,7 +7,7 @@ use figcraft_doc::{
use figcraft_geom::Point;
use serde_json::{Value, json};
use crate::board::{route, sticky_font_size};
use crate::board::{STICKY_TEXT_SIZE, route};
use crate::collab_live_tests::Room;
use crate::tools::{PointerEvent, PointerKind, ToolId};
use crate::{EngineError, Session};
@@ -77,7 +77,7 @@ fn board_commands_refuse_on_design_files_and_prototyping_refuses_on_boards() {
}
#[test]
fn a_sticky_is_a_square_frame_whose_note_shrinks_as_it_grows() {
fn a_sticky_is_a_square_frame_whose_note_grows_taller_as_it_fills() {
let mut s = board();
s.prefs.user_name = "Ada".into();
let r = s.execute("board.sticky", &json!({"x": 10, "y": 20, "text": "Hi", "color": "blue"})).unwrap();
@@ -88,19 +88,75 @@ fn a_sticky_is_a_square_frame_whose_note_shrinks_as_it_grows() {
assert_eq!(n.fills[0].solid_color(), board_color("blue"));
assert!(n.layout.is_some() && !n.effects.is_empty());
assert_eq!(n.children.len(), 2, "the note and its author");
assert_eq!(node(&s, note).kind.text().unwrap().style.font_size, 24.0);
assert_eq!(node(&s, note).kind.text().unwrap().style.font_size, 18.0);
// A click on the note picks the sticky whole.
let doc = s.doc().unwrap();
assert_eq!(figcraft_doc::geometry::select_target(doc, note, &[], false), st);
// A long note takes a smaller size; a very long one grows the sticky past its square.
// A long note keeps the size; a very long one grows the sticky past its square.
let long = "word ".repeat(120);
s.execute("node.set", &json!({"id": note, "props": {"characters": long}})).unwrap();
assert_eq!(node(&s, note).kind.text().unwrap().style.font_size, sticky_font_size(&long));
assert!(sticky_font_size(&long) < 16.0);
assert_eq!(node(&s, note).kind.text().unwrap().style.font_size, STICKY_TEXT_SIZE);
assert!(node(&s, st).width == 200.0 && node(&s, st).height >= 200.0);
// Undo puts the short note and its size back.
// Undo puts the short note back.
s.execute("edit.undo", &json!({})).unwrap();
assert_eq!(node(&s, note).kind.text().unwrap().style.font_size, 24.0);
assert_eq!(node(&s, note).kind.text().unwrap().style.font_size, 18.0);
}
#[test]
fn a_new_sticky_starts_at_18() {
let mut s = board();
for (cmd, p) in [("board.sticky", json!({"x": 0, "y": 0, "text": "Hi"})), ("board.sticky", json!({"x": 300, "y": 0}))] {
let note = id(&s.execute(cmd, &p).unwrap(), "text");
assert_eq!(node(&s, note).kind.text().unwrap().style.font_size, 18.0);
}
let next = id(&s.execute("board.nextSticky", &json!({})).unwrap(), "text");
assert_eq!(node(&s, next).kind.text().unwrap().style.font_size, 18.0);
assert_eq!(STICKY_TEXT_SIZE, 18.0);
}
#[test]
fn a_sticky_keeps_its_text_size_as_text_is_added() {
// The note's growth needs text measured: without craft-fonts that is with a system font,
// scanned here rather than by whichever test happens to run first (#333).
figcraft_text::scan_system_fonts();
let mut s = board();
let r = s.execute("board.sticky", &json!({"x": 0, "y": 0, "text": "one"})).unwrap();
let (st, note) = (id(&r, "id"), id(&r, "text"));
let (height, text_height) = (node(&s, st).height, node(&s, note).height);
// Typing in the note: each step is a real edit that runs the normalize pass.
crate::board::edit_text(&mut s, st).unwrap();
for _ in 0..9 {
crate::textedit::key(&mut s, "Enter", false, false, false).unwrap();
crate::textedit::insert(&mut s, "another line").unwrap();
}
let ten = node(&s, note).kind.text().unwrap().clone();
assert_eq!(ten.characters.matches('\n').count(), 9, "ten lines");
assert_eq!(ten.style.font_size, 18.0);
assert!(node(&s, note).height > text_height, "ten lines make the text taller");
assert!(node(&s, st).height > height, "and the note");
assert_eq!(node(&s, st).child_layout.sizing_v, figcraft_doc::Sizing::Hug, "the note hugs its text");
let (w, h10) = (node(&s, st).width, node(&s, st).height);
crate::textedit::insert(&mut s, &"a long paragraph ".repeat(15)).unwrap();
crate::textedit::end(&mut s).unwrap();
let t = node(&s, note).kind.text().unwrap().clone();
assert!(t.characters.chars().count() >= 250);
assert_eq!(t.style.font_size, 18.0);
assert!(t.runs.iter().all(|r| r.style.font_size == 18.0));
assert_eq!(node(&s, st).width, w, "the note keeps its width");
assert!(node(&s, st).height > h10, "and grows taller");
}
#[test]
fn a_sticky_saved_with_another_text_size_keeps_it() {
let mut s = board();
let r = s.execute("board.sticky", &json!({"x": 0, "y": 0, "text": "old"})).unwrap();
let (st, note) = (id(&r, "id"), id(&r, "text"));
s.execute("node.set", &json!({"id": note, "props": {"fontSize": 11}})).unwrap();
assert_eq!(node(&s, note).kind.text().unwrap().style.font_size, 11.0);
s.execute("node.set", &json!({"id": note, "props": {"characters": "old and now much longer than it was"}})).unwrap();
assert_eq!(node(&s, note).kind.text().unwrap().style.font_size, 11.0, "an edit");
s.execute("node.set", &json!({"id": st, "props": {"x": 40}})).unwrap();
assert_eq!(node(&s, note).kind.text().unwrap().style.font_size, 11.0, "a move");
}
#[test]
@@ -206,6 +262,7 @@ fn routes_are_the_same_for_the_same_document() {
to: End::Point { x: 300.0, y: 500.0 },
routing: Routing::Elbow,
path: None,
branch: false,
};
let doc = s.doc().unwrap();
let r = route(doc, &c).unwrap();
@@ -357,6 +414,7 @@ fn board_commands_survive_junk() {
json!({"path": "M0 0 L 1e308 1e308", "points": [[0, 0], [1e308, 1]]}),
json!({"end": "from", "target": {"x": 1e308, "y": -1e308}, "side": "inside", "style": "curved"}),
json!({"id": 99_999, "end": 7, "target": [1], "style": "wavy"}),
json!({"id": 99_999, "relation": 7, "children": "x", "text": [1], "x": "NaN", "y": 1e308}),
];
let ids: Vec<&str> = crate::cmd::all_commands()
.iter()
crates/engine/src/board_tools_tests.rs
+12 -3
View File
@@ -96,7 +96,8 @@ fn routes_take_named_sides_and_free_points() {
let a = id(&s.execute("board.shape", &json!({"x": 0, "y": 0, "width": 100, "height": 100})).unwrap(), "id");
let b = id(&s.execute("board.shape", &json!({"x": 300, "y": 300, "width": 100, "height": 100})).unwrap(), "id");
let doc = s.doc().unwrap();
let elbow = |from, to| route(doc, &figcraft_doc::Connector { from, to, routing: figcraft_doc::Routing::Elbow, path: None }).unwrap();
let elbow =
|from, to| route(doc, &figcraft_doc::Connector { from, to, routing: figcraft_doc::Routing::Elbow, path: None, branch: false }).unwrap();
let side = |n, side| End::Node { node: n, side, at: None };
let p = |x, y| End::Point { x, y };
let pt = Point::new;
@@ -109,8 +110,16 @@ fn routes_take_named_sides_and_free_points() {
assert_eq!(elbow(p(0.0, 0.0), p(100.0, 40.0)), vec![pt(0.0, 0.0), pt(50.0, 0.0), pt(50.0, 40.0), pt(100.0, 40.0)]);
assert_eq!(elbow(p(0.0, 0.0), p(100.0, 0.0)), vec![pt(0.0, 0.0), pt(100.0, 0.0)]);
// An automatic side faces the other end.
let straight =
route(doc, &figcraft_doc::Connector { from: side(a, Side::Auto), to: p(50.0, 500.0), routing: figcraft_doc::Routing::Straight, path: None });
let straight = route(
doc,
&figcraft_doc::Connector {
from: side(a, Side::Auto),
to: p(50.0, 500.0),
routing: figcraft_doc::Routing::Straight,
path: None,
branch: false,
},
);
assert_eq!(straight.unwrap(), vec![pt(50.0, 104.0), pt(50.0, 500.0)]);
assert_eq!(Side::from_id("TOP"), Some(Side::Top));
assert_eq!(Side::from_id("inside"), None);
crates/engine/src/boards/board.rs
+17 -1
View File
@@ -25,6 +25,7 @@ mod connectors;
mod derived;
mod edit;
mod items;
mod mindmap;
mod reshape;
mod tools;
@@ -68,8 +69,9 @@ pub(crate) use edit::{copied_items, copy_map, rejoin};
use edit::{label_cmd, set_color, set_style};
pub(crate) use items::add_text;
pub use items::{CONNECTED_GAP, connected_place};
pub use items::{STICKY_TEXT_SIZE, edit_text, owner_of_text, text_of};
use items::{add_connected, ink_cmd, next_sticky, shape_cmd, stamp_cmd, sticky_cmd};
pub use items::{edit_text, owner_of_text, sticky_font_size, text_of};
pub(crate) use mindmap::settle_mind_maps;
pub(crate) use reshape::path_handle_at;
pub use reshape::selected_connector_handles;
@@ -176,6 +178,20 @@ pub fn specs() -> Vec<CommandSpec> {
true,
reshape::reshape
),
spec!(
"board.mindMap",
"Mind map",
"{x?, y? (the first node's top-left in the parent; default the middle of the view), text? (default Topic), children? (their texts, at most 20; default Idea 1, Idea 2, Idea 3), parent?, edit? (start typing in the first node; default false)} → {id, text, children: [{id, text, connector}...]} a first node with children on its right, joined by branches; the map lays itself out",
true,
mindmap::mind_map_cmd
),
spec!(
"board.mindMapAdd",
"Add mind map node",
"{id? (a mind map node; default the selected or edited one), relation?: child|sibling (default child), text?, edit? (start typing in it; default false)} → {id, text, connector} a child below the node's other children, or a sibling right after it; the map lays itself out again",
true,
mindmap::mind_map_add
),
spec!("board.label", "Connector label", "{id (a connector; default the selection), text (empty removes it)} → {id, label}", true, label_cmd),
spec!(
"board.stamp",
crates/engine/src/boards/board/connectors.rs
+1 -1
View File
@@ -65,7 +65,7 @@ pub(super) fn connector_cmd(s: &mut Session, p: &Value) -> Result<Value> {
let end = cap_of(cmd, p, "endCap")?.unwrap_or(CAPS.1);
let page = s.page()?;
let doc = s.doc_mut()?;
let id = make(doc, page, Connector { from, to, routing, path: None }, (start, end))?;
let id = make(doc, page, Connector { from, to, routing, path: None, branch: false }, (start, end))?;
let mut out = json!({"id": id});
if let Some(text) = string(p, "label").filter(|t| !t.trim().is_empty()) {
out["label"] = json!(set_label(doc, id, &text)?);
crates/engine/src/boards/board/derived.rs
+3 -16
View File
@@ -1,7 +1,6 @@
use figcraft_doc::RouteEnd;
use super::edit::set_font_size;
use super::items::{owner_of_text, shape_padding, sticky_font_size, text_of};
use super::items::shape_padding;
use super::{
Affine, BTreeSet, BezPath, BoardItem, Connector, Document, End, NodeId, NodeKind, PathEl, Point, Rect, Routing, Shape, VectorNetwork, is_board,
};
@@ -9,26 +8,14 @@ use super::{
// ---------------------------------------------------------------------------------------------
// Derived data (the normalize pass).
/// Before text is measured: a sticky's note takes the size its length calls for, and a resized
/// shape keeps its text inside its outline.
/// Before text is measured: a resized shape keeps its text inside its outline. A sticky's text
/// keeps whatever size it has (FigJam's size is the note's own setting).
pub(crate) fn settle_text(doc: &mut Document, before: &Document, touched: &BTreeSet<NodeId>) {
if !is_board(doc) {
return;
}
for &id in touched {
let Some(n) = doc.node(id) else { continue };
if let Some(owner) =
owner_of_text(doc, id).or(Some(id)).filter(|o| doc.node(*o).is_some_and(|k| matches!(k.board, Some(BoardItem::Sticky { .. }))))
&& let Some(t) = text_of(doc, owner)
&& let Some(NodeKind::Text(td)) = doc.node(t).map(|k| &k.kind)
{
let size = sticky_font_size(&td.characters);
let off = td.style.font_size != size || td.runs.iter().any(|r| r.style.font_size != size);
if off && let Some(NodeKind::Text(td)) = doc.node_mut(t).map(|k| &mut k.kind) {
set_font_size(td, size);
}
continue;
}
if let Some(BoardItem::Shape { shape }) = n.board
&& before.node(id).is_none_or(|b| (b.width, b.height) != (n.width, n.height))
{
crates/engine/src/boards/board/edit.rs
+2 -2
View File
@@ -84,7 +84,7 @@ pub(super) fn set_color(s: &mut Session, p: &Value) -> Result<Value> {
n.strokes = vec![Paint::solid(line_shade(color))];
}
BoardItem::Connector(_) | BoardItem::Ink => doc.get_mut(id)?.strokes = vec![Paint::solid(line_shade(color))],
BoardItem::Label { .. } | BoardItem::Stamp { .. } | BoardItem::Table => continue,
BoardItem::Label { .. } | BoardItem::Stamp { .. } | BoardItem::Table | BoardItem::MindNode => continue,
}
changed.push(id);
}
@@ -132,7 +132,7 @@ impl Restyle {
};
// Text sizes: shapes' and labels' text (stickies size theirs to fit).
let sized = match (self.size, &item) {
(Some(size), BoardItem::Shape { .. } | BoardItem::Label { .. }) => resize_text(doc, id, size),
(Some(size), BoardItem::Shape { .. } | BoardItem::Label { .. } | BoardItem::MindNode) => resize_text(doc, id, size),
_ => false,
};
Ok(changed || sized)
crates/engine/src/boards/board/items.rs
+5 -13
View File
@@ -57,18 +57,9 @@ pub(crate) fn add_text(doc: &mut Document, parent: NodeId, text: &str, size: f64
Ok(id)
}
/// The text size a sticky's note gets: smaller the more it holds (by characters and lines, so
/// every copy of the file picks the same size whatever fonts it has).
pub fn sticky_font_size(text: &str) -> f64 {
let weight = text.chars().count() + 24 * text.matches('\n').count();
match weight {
0..=24 => 24.0,
25..=64 => 20.0,
65..=140 => 16.0,
141..=280 => 13.0,
_ => 11.0,
}
}
/// The text size of a new sticky's note, FigJam's "Small" default (measured in the web app,
/// 2026-11-09): it never changes as the note fills, the note grows taller instead.
pub const STICKY_TEXT_SIZE: f64 = 18.0;
/// A sticky note's layers: the frame, the note and (when known) its author.
fn make_sticky(doc: &mut Document, parent: NodeId, at: (f64, f64), text: &str, color: Color, author: &str) -> Result<(NodeId, NodeId)> {
@@ -89,7 +80,7 @@ fn make_sticky(doc: &mut Document, parent: NodeId, at: (f64, f64), text: &str, c
n.board = Some(BoardItem::Sticky { author: author.to_string() });
})?;
let inner = STICKY - 2.0 * STICKY_PAD;
let note = add_text(doc, id, text, sticky_font_size(text), INK, TextAlignH::Left, inner)?;
let note = add_text(doc, id, text, STICKY_TEXT_SIZE, INK, TextAlignH::Left, inner)?;
if !author.is_empty() {
let a = add_text(doc, id, author, 10.0, AUTHOR_INK, TextAlignH::Left, inner)?;
if let Some(n) = doc.node_mut(a) {
@@ -250,6 +241,7 @@ pub(super) fn add_connected(s: &mut Session, p: &Value) -> Result<Value> {
to: End::Node { node: id, side: to_side, at: None },
routing,
path: None,
branch: false,
};
let line = make(doc, page, connector, CAPS)?;
s.set_selection(vec![id]);
crates/engine/src/boards/board/mindmap.rs
+380
View File
@@ -0,0 +1,380 @@
//! Mind maps (#2226): a node is a frame hugging one text ([`BoardItem::MindNode`]) and a branch is
//! a connector with `branch` set, from the parent to the child. The tree is read from the branches
//! and from nothing else; [`settle_mind_maps`] lays a touched map out again in the normalize pass,
//! so the commands only make nodes and branches.
use std::collections::{BTreeMap, BTreeSet};
use figcraft_color::{Color, Paint};
use figcraft_doc::{
AutoLayout, BoardItem, Connector, Document, End, LetterSpacing, LineHeight, MIND_GAP_X, MIND_GAP_Y, MIND_MAX_DEPTH, MIND_MAX_NODES, MindBox,
NodeId, NodeKind, Routing, Side, Sizing, StrokeCap, TextAlignH, TextAutoResize, mind_layout,
};
use figcraft_geom::{Affine, Point, Rect};
use serde_json::{Value, json};
use super::connectors::make;
use super::items::{add, add_text, owner_of_text};
use super::{INK, Result, Session, bad, boolean, get, id, is_board, num_or, parent_of, require, string, textedit};
use crate::EngineError;
/// The first node's text size and the other nodes'.
const MIND_ROOT_SIZE: f64 = 24.0;
const MIND_NODE_SIZE: f64 = 16.0;
/// The line height of every node's text, in percent, and the letter spacing of the first node's
/// and the others' (percent of the size).
const MIND_LINE_HEIGHT: f64 = 150.0;
const MIND_ROOT_TRACKING: f64 = -1.9;
const MIND_NODE_TRACKING: f64 = -1.1;
/// A node's least width: an emptied one stays clickable.
const MIND_MIN_W: f64 = 8.0;
/// What `board.mindMap` puts in the first node and its children when it isn't told.
const MIND_ROOT_TEXT: &str = "Topic";
const MIND_STARTERS: [&str; 3] = ["Idea 1", "Idea 2", "Idea 3"];
/// The most children `board.mindMap` makes, and the longest text it puts in a node.
const MIND_MAX_STARTERS: usize = 20;
const MIND_MAX_TEXT: usize = 500;
/// How far from the page's middle a first node may be put.
const MIND_MAX_COORD: f64 = 1.0e9;
/// Branches' look.
const BRANCH: Color = Color::from_rgb8_const(0x75, 0x75, 0x75);
const BRANCH_WEIGHT: f64 = 4.0;
/// A node's frame and its text, `text` at `size`: the frame hugs the text with no padding, and the
/// text grows on one line.
fn make_node(doc: &mut Document, parent: NodeId, at: (f64, f64), text: &str, root: bool) -> Result<(NodeId, NodeId)> {
let size = if root { MIND_ROOT_SIZE } else { MIND_NODE_SIZE };
let line = size * MIND_LINE_HEIGHT / 100.0;
let frame = add(doc, parent, NodeKind::Frame, "Mind map node", at, (MIND_MIN_W, line), |n| {
n.fills.clear();
n.clip = false;
n.layout = Some(AutoLayout { padding: [0.0; 4], ..AutoLayout::default() });
n.child_layout.sizing_h = Sizing::Hug;
n.child_layout.sizing_v = Sizing::Hug;
n.child_layout.min_w = Some(MIND_MIN_W);
n.child_layout.min_h = Some(line);
n.board = Some(BoardItem::MindNode);
})?;
let label = add_text(doc, frame, text, size, INK, TextAlignH::Left, 1.0)?;
if let Some(n) = doc.node_mut(label) {
n.child_layout.sizing_h = Sizing::Hug;
if let NodeKind::Text(td) = &mut n.kind {
td.auto_resize = TextAutoResize::WidthAndHeight;
td.style.line_height = LineHeight::Percent(MIND_LINE_HEIGHT);
td.style.letter_spacing = LetterSpacing::Percent(if root { MIND_ROOT_TRACKING } else { MIND_NODE_TRACKING });
if root {
td.style.font_style = "Bold".into();
} else {
td.style.font_style = "Medium".into();
}
}
}
Ok((frame, label))
}
/// The branch from `parent` to `child` (on its left side when `left`), on `page`.
fn branch(doc: &mut Document, page: NodeId, parent: NodeId, child: NodeId, left: bool) -> Result<NodeId> {
let (out, back) = if left { (Side::Left, Side::Right) } else { (Side::Right, Side::Left) };
let c = Connector {
from: End::Node { node: parent, side: out, at: None },
to: End::Node { node: child, side: back, at: None },
routing: Routing::Curved,
path: None,
branch: true,
};
let line = make(doc, page, c, (StrokeCap::Round, StrokeCap::Round))?;
let n = doc.get_mut(line)?;
n.strokes = vec![Paint::solid(BRANCH)];
n.stroke.weight = BRANCH_WEIGHT;
Ok(line)
}
/// A branch of a map as the tree reads it.
#[derive(Clone, Copy)]
struct Branch {
line: NodeId,
parent: NodeId,
child: NodeId,
left: bool,
}
/// The branches of `doc` that join two different layers of their own page, by id. (Others are
/// the normalize pass's to remove.)
fn branches(doc: &Document) -> Vec<Branch> {
let mut v: Vec<Branch> = doc
.nodes()
.filter_map(|n| match &n.board {
Some(BoardItem::Connector(Connector { from: End::Node { node: a, side, .. }, to: End::Node { node: b, .. }, branch: true, .. }))
if a != b && doc.contains(*a) && doc.contains(*b) && doc.page_of(*a) == doc.page_of(n.id) && doc.page_of(*b) == doc.page_of(n.id) =>
{
Some(Branch { line: n.id, parent: *a, child: *b, left: *side == Side::Left })
}
_ => None,
})
.collect();
v.sort_by_key(|b| b.line);
v
}
/// The branch arriving at `node`: the one with the lowest connector id, when it has several.
fn arriving(bs: &[Branch], node: NodeId) -> Option<Branch> {
bs.iter().find(|b| b.child == node).copied()
}
/// The children of `node` on one side, in layout order (by their middles, then id).
fn map_children(doc: &Document, bs: &[Branch], node: NodeId, left: bool) -> Vec<NodeId> {
let mut v: Vec<(f64, NodeId)> = bs
.iter()
.filter(|b| b.parent == node && b.left == left && arriving(bs, b.child).is_some_and(|a| a.line == b.line))
.filter_map(|b| doc.world_bounds(b.child).map(|r| (r.center().y, b.child)))
.collect();
v.sort_by(|a, b| a.0.total_cmp(&b.0).then(a.1.cmp(&b.1)));
v.into_iter().map(|p| p.1).collect()
}
/// Whether `node` is on the left of its map (a first node: no).
fn map_side(bs: &[Branch], node: NodeId) -> bool {
let (mut at, mut left) = (node, false);
for _ in 0..MIND_MAX_DEPTH {
let Some(b) = arriving(bs, at) else { break };
(at, left) = (b.parent, b.left);
}
left
}
/// The text `p` gives for `key`, a node's at most [`MIND_MAX_TEXT`] characters.
fn text_param(p: &Value, key: &str) -> String {
string(p, key).unwrap_or_default().chars().take(MIND_MAX_TEXT).collect()
}
/// A coordinate from the params, finite and within [`MIND_MAX_COORD`] of the origin.
fn coord(cmd: &str, p: &Value, key: &str, default: f64) -> Result<f64> {
let v = num_or(p, key, default);
if v.is_finite() && v.abs() <= MIND_MAX_COORD { Ok(v) } else { Err(bad(cmd, format!("`{key}` is a position within a billion of the origin"))) }
}
/// `children?` of `board.mindMap`: the starter texts.
fn starters(cmd: &str, p: &Value) -> Result<Vec<String>> {
match get(p, "children") {
None => Ok(MIND_STARTERS.iter().map(|t| (*t).to_string()).collect()),
Some(Value::Array(a)) if a.len() <= MIND_MAX_STARTERS => {
a.iter().map(|v| v.as_str().map(|t| t.chars().take(MIND_MAX_TEXT).collect()).ok_or_else(|| bad(cmd, "`children` holds texts"))).collect()
}
_ => Err(bad(cmd, format!("`children` is a list of at most {MIND_MAX_STARTERS} texts"))),
}
}
pub(super) fn mind_map_cmd(s: &mut Session, p: &Value) -> Result<Value> {
let cmd = "board.mindMap";
require(s, cmd)?;
let parent = parent_of(cmd, s, p)?;
let (vx, vy) = {
let v = &s.ds()?.view;
(v.cx, v.cy)
};
let (x, y) = (coord(cmd, p, "x", vx)?, coord(cmd, p, "y", vy)?);
let texts = starters(cmd, p)?;
let root_text = string(p, "text").map_or_else(|| MIND_ROOT_TEXT.to_string(), |_| text_param(p, "text"));
let page = s.page()?;
let doc = s.doc_mut()?;
let (root, label) = make_node(doc, parent, (x, y), &root_text, true)?;
let mut made = Vec::new();
// Anywhere below one another will do: the normalize pass puts them right, in this order.
let line = MIND_NODE_SIZE * MIND_LINE_HEIGHT / 100.0 + MIND_GAP_Y;
for (i, t) in texts.iter().enumerate() {
let (k, text) = make_node(doc, parent, (x + MIND_MIN_W + MIND_GAP_X, y + i as f64 * line), t, false)?;
let b = branch(doc, page, root, k, false)?;
made.push(json!({"id": k, "text": text, "connector": b}));
}
s.set_selection(vec![root]);
if boolean(p, "edit") == Some(true) {
s.request_ui("board.editText", json!({"id": root}));
}
Ok(json!({"id": root, "text": label, "children": made}))
}
pub(super) fn mind_map_add(s: &mut Session, p: &Value) -> Result<Value> {
let cmd = "board.mindMapAdd";
require(s, cmd)?;
let editing = s.ds()?.text_edit.as_ref().map(|t| t.id);
let doc = s.doc()?;
let from = id(p, "id")
.or_else(|| editing.and_then(|t| owner_of_text(doc, t)))
.or_else(|| s.selection().first().copied().map(|i| owner_of_text(doc, i).unwrap_or(i)))
.ok_or_else(|| EngineError::Disabled(cmd.into(), "select a mind map node first".into()))?;
let n = doc.get(from)?;
if n.board != Some(BoardItem::MindNode) {
return Err(bad(cmd, "that isn't a mind map node"));
}
let sibling = match string(p, "relation").as_deref() {
None | Some("child") => false,
Some("sibling") => true,
Some(other) => return Err(bad(cmd, format!("`relation` is child or sibling, not `{other}`"))),
};
let (page, container) = (s.page()?, n.parent.ok_or_else(|| bad(cmd, "that node has no parent"))?);
if doc.page_of(from) != Some(page) {
return Err(bad(cmd, "that node is on another page"));
}
let bs = branches(doc);
let at = doc.world_bounds(from).ok_or_else(|| bad(cmd, "that node has no place"))?;
let new_h = MIND_NODE_SIZE * MIND_LINE_HEIGHT / 100.0;
// The parent, the side, and where the new node's top-left goes on the page.
let (parent, left, top_left) = if sibling {
let a = arriving(&bs, from).ok_or_else(|| bad(cmd, "the first node has no siblings: add a child"))?;
// Its middle lands between this node and the next sibling, so the order puts it right after.
(a.parent, a.left, Point::new(at.x0, at.y1 + MIND_GAP_Y / 2.0 - new_h / 2.0))
} else {
let left = map_side(&bs, from);
let last = map_children(doc, &bs, from, left).last().and_then(|l| doc.world_bounds(*l));
let top = last.map_or(at.center().y - new_h / 2.0, |l| l.y1 + MIND_GAP_Y);
(from, left, Point::new(if left { at.x0 - MIND_GAP_X - MIND_MIN_W } else { at.x1 + MIND_GAP_X }, top))
};
let local = doc.world_transform(container).inverse() * top_left;
if !(local.x.is_finite() && local.y.is_finite()) {
return Err(bad(cmd, "the new node can't be placed there"));
}
let text = text_param(p, "text");
if editing.is_some() {
textedit::end(s)?;
}
let doc = s.doc_mut()?;
let (node, label) = make_node(doc, container, (local.x, local.y), &text, false)?;
let line = branch(doc, page, parent, node, left)?;
s.set_selection(vec![node]);
if boolean(p, "edit") == Some(true) {
s.request_ui("board.editText", json!({"id": node}));
}
Ok(json!({"id": node, "text": label, "connector": line}))
}
/// The tree of a document's branches: for each layer its arriving branch (the lowest connector
/// id), and each parent's children by it.
type Children = BTreeMap<NodeId, Vec<Branch>>;
fn children_of(bs: &[Branch]) -> (BTreeSet<NodeId>, Children) {
let mut arrived = BTreeSet::new();
let mut kids: Children = BTreeMap::new();
for b in bs {
if arrived.insert(b.child) {
kids.entry(b.parent).or_default().push(*b);
}
}
(arrived, kids)
}
/// Every branch that no longer joins two layers of its own page is removed, and the layers it
/// joined that are still there count as stirred (so do the old ends of a touched branch: one that
/// is gone, or that was moved to join something else).
fn prune_branches(doc: &mut Document, before: &Document, touched: &BTreeSet<NodeId>) -> BTreeSet<NodeId> {
let mut stirred = BTreeSet::new();
let ends = |c: &Connector| [c.from.node(), c.to.node()].into_iter().flatten().collect::<Vec<NodeId>>();
for id in touched {
if let Some(BoardItem::Connector(c)) = before.node(*id).and_then(|n| n.board.as_ref())
&& c.branch
{
stirred.extend(ends(c));
}
}
let mut gone = Vec::new();
for n in doc.nodes() {
let Some(BoardItem::Connector(c)) = &n.board else { continue };
let page = doc.page_of(n.id);
let joins = |e: &End| matches!(e, End::Node { node, .. } if doc.contains(*node) && page.is_some() && doc.page_of(*node) == page);
if c.branch && !(joins(&c.from) && joins(&c.to) && c.from.node() != c.to.node()) {
gone.push((n.id, ends(c)));
}
}
for (line, joined) in gone {
stirred.extend(joined);
let _ = doc.remove(line);
}
stirred.retain(|i| doc.contains(*i));
stirred
}
/// The boxes of the map under `root`, breadth first (so a parent always comes before its
/// children), and the connectors that hold it together. `None`: a box is missing, or the map has
/// more than [`MIND_MAX_NODES`] nodes (it is left as it is).
fn map_boxes(doc: &Document, root: NodeId, kids: &Children) -> Option<(Vec<MindBox>, Vec<NodeId>)> {
let first = doc.world_bounds(root)?;
let mut boxes = vec![MindBox { id: root, rect: first, parent: None, left: false }];
let (mut lines, mut seen) = (Vec::new(), BTreeSet::from([root]));
let (mut at, mut depths) = (0, vec![0_usize]);
while let Some(b) = boxes.get(at).copied() {
let depth = depths.get(at).copied().unwrap_or(MIND_MAX_DEPTH);
for k in kids.get(&b.id).filter(|_| depth < MIND_MAX_DEPTH).into_iter().flatten() {
if !seen.insert(k.child) {
continue;
}
if boxes.len() >= MIND_MAX_NODES {
return None;
}
boxes.push(MindBox { id: k.child, rect: doc.world_bounds(k.child)?, parent: Some(at), left: k.left });
depths.push(depth + 1);
lines.push(k.line);
}
at += 1;
}
Some((boxes, lines))
}
/// Move layer `id` by `d` on the page.
fn shift(doc: &mut Document, id: NodeId, d: Point) {
let parent = doc.node(id).and_then(|n| n.parent).map_or(Affine::IDENTITY, |p| doc.world_transform(p));
let inverse = parent.inverse();
if !inverse.as_coeffs().iter().all(|v| v.is_finite()) {
return;
}
if let Some(n) = doc.node_mut(id) {
let moved = inverse * Affine::translate((d.x, d.y)) * parent * n.transform;
if moved.as_coeffs().iter().all(|v| v.is_finite()) {
n.transform = moved;
}
}
}
/// After layout and before connectors follow: the maps an edit touched are laid out again from
/// their first nodes (a map that is already in place is not written to, so the pass is idempotent).
/// A branch that no longer joins two layers of its page is removed first: the only structural
/// write, and what makes a deleted node's children float free and a detached node stay detached.
pub(crate) fn settle_mind_maps(doc: &mut Document, before: &Document, touched: &BTreeSet<NodeId>) {
if !is_board(doc) || touched.is_empty() {
return;
}
// One look at every layer: a board without a branch (nearly all) goes no further.
if !doc.nodes().any(|n| matches!(&n.board, Some(BoardItem::Connector(c)) if c.branch)) {
return;
}
let stirred = prune_branches(doc, before, touched);
let bs = branches(doc);
if bs.is_empty() {
return;
}
let hit = |doc: &Document, id: NodeId| touched.contains(&id) || doc.ancestors(id).iter().any(|a| touched.contains(a));
let (arrived, kids) = children_of(&bs);
let roots: Vec<NodeId> = kids.keys().copied().filter(|p| !arrived.contains(p)).collect();
for root in roots {
let Some((boxes, lines)) = map_boxes(doc, root, &kids) else { continue };
if boxes.iter().any(|b| !(b.rect.x0.is_finite() && b.rect.y0.is_finite() && b.rect.x1.is_finite() && b.rect.y1.is_finite())) {
continue;
}
// A map holding a layer and something inside it would move that layer with its own
// children: leave it as it is.
let ids: BTreeSet<NodeId> = boxes.iter().map(|b| b.id).collect();
if boxes.iter().any(|b| doc.ancestors(b.id).iter().any(|a| ids.contains(a))) {
continue;
}
let stale = boxes.iter().any(|b| stirred.contains(&b.id) || hit(doc, b.id)) || lines.iter().any(|l| hit(doc, *l));
if !stale {
continue;
}
let now: BTreeMap<NodeId, Rect> = boxes.iter().map(|b| (b.id, b.rect)).collect();
for (id, to) in mind_layout(&boxes) {
let Some(was) = now.get(&id) else { continue };
let d = to - was.origin();
if d.x.is_finite() && d.y.is_finite() && d.hypot() > 1e-6 {
shift(doc, id, Point::new(d.x, d.y));
}
}
}
}
crates/engine/src/boards/board/reshape.rs
+1 -1
View File
@@ -26,7 +26,7 @@ fn moved(doc: &Document, c: &Connector, portion: usize, p: Point) -> Option<Conn
let (from, to) = route_ends(doc, c)?;
let path = reshaped(from, to, c.routing, c.path.as_ref(), portion, p)?;
let (s0, s1) = attached_sides(from, to);
Some(Connector { from: pinned(c.from, s0), to: pinned(c.to, s1), routing: c.routing, path: Some(path) })
Some(Connector { from: pinned(c.from, s0), to: pinned(c.to, s1), routing: c.routing, path: Some(path), branch: c.branch })
}
/// Write `c` into connector `id` and run it along its new route.
crates/engine/src/boards/board/tools.rs
+1 -1
View File
@@ -171,7 +171,7 @@ impl Session {
/// or free point under the pointer.
pub(crate) fn connect_drag(&mut self, ev: &PointerEvent, from: End, start: Point) {
self.tool.gesture = Gesture::Connect { from, start };
let c = self.drag_end(ev, from, start).map(|to| Connector { from, to, routing: self.tool.board.routing, path: None });
let c = self.drag_end(ev, from, start).map(|to| Connector { from, to, routing: self.tool.board.routing, path: None, branch: false });
if let Ok(page) = self.page() {
// One that can't be placed shows nothing, as none would be made.
let _ = self.preview(|d, _| {
crates/engine/src/brush_tests.rs
+66
View File
@@ -8,6 +8,7 @@ use crate::params::id_of;
use crate::tools::{PointerEvent, PointerKind, pressure_profile};
use figcraft_doc::{NodeId, NodeKind};
use figcraft_geom::Point;
use figcraft_geom::kurbo::PathEl;
fn id(v: Value) -> NodeId {
id_of(&v["id"]).unwrap()
@@ -149,3 +150,68 @@ fn the_pencil_draws_white_on_a_dark_background() {
assert_eq!(stroke(&mut s, 0.0, 600.0).0, want, "on {bg}");
}
}
/// A Pencil stroke stays where it was drawn: the fitted curve shot far off the stroke, a spike
/// (#1741, its second point), where the stroke went out and back to the very point it left and
/// where samples ran on nearly straight. Pointer pixels become fractional page points, so going
/// back to a pixel lands on exactly the same point. Both sample runs are ones kurbo's fit took
/// hundreds of units off.
///
/// Each stroke is drawn in a fresh session, with the Pencil and with the Marker and Highlighter
/// of a board, whose ink comes from the same fit. Every point along the stroke drawn must lie
/// within 1.5 (twice the fit's accuracy) of the polyline through the samples.
#[test]
fn the_pencil_keeps_its_stroke_where_it_was_drawn() {
let (p, q) = ((86.043_565_719_086_97, -173.744_402_349_100_94), (87.851_850_739_335_35, -179.202_846_445_954_52));
let back = [(80.0, -160.0), p, q, p, (95.0, -185.0)];
let straight = [
(204.0, -198.0),
(209.598_690_794_015_5, -204.909_328_119_739_88),
(211.277_914_263_870_97, -207.190_974_020_753_4),
(214.246_506_828_720_84, -211.228_827_590_623_24),
(218.0, -214.0),
];
for tool in ["pencil", "marker", "highlighter"] {
for (what, samples) in [("out and back", &back[..]), ("nearly straight", &straight[..])] {
let what = format!("{tool}, {what}");
let mut s = if tool == "pencil" { Session::new() } else { crate::board_tests::board() };
s.execute("tool.set", &json!({"tool": tool})).unwrap();
let before: Vec<NodeId> = s.doc().unwrap().nodes().map(|n| n.id).collect();
let (first, last) = (samples[0], samples[samples.len() - 1]);
s.pointer(&PointerEvent::at(PointerKind::Down, first.0, first.1, 1.0)).unwrap();
for (x, y) in &samples[1..] {
s.pointer(&PointerEvent::at(PointerKind::Move, *x, *y, 1.0)).unwrap();
}
s.pointer(&PointerEvent::at(PointerKind::Up, last.0, last.1, 1.0)).unwrap();
// The layer the stroke made, and only it.
let doc = s.doc().unwrap();
let made: Vec<&figcraft_doc::Node> =
doc.nodes().filter(|n| !before.contains(&n.id) && matches!(n.kind, NodeKind::Vector { .. })).collect();
let [n] = made[..] else { panic!("{what}: {} vectors made", made.len()) };
let NodeKind::Vector { network } = &n.kind else { panic!("{what}: not a vector") };
let drawn = doc.world_transform(n.id) * network.stroke_path();
let polyline = figcraft_geom::BezPath::from_vec(
samples
.iter()
.enumerate()
.map(|(k, (x, y))| if k == 0 { PathEl::MoveTo(Point::new(*x, *y)) } else { PathEl::LineTo(Point::new(*x, *y)) })
.collect(),
);
let d = crate::vector_behaviour_tests::strays(&drawn, &polyline);
assert!(d <= 1.5, "{what}: the stroke strays {d} from the samples: {}", drawn.to_svg());
let samples_box = figcraft_geom::points_bounds(samples.iter().map(|(x, y)| Point::new(*x, *y))).unwrap();
let node_box = doc.world_bounds(n.id).unwrap();
if tool == "pencil" {
assert!(samples_box.inflate(1.5, 1.5).contains_rect(node_box), "{what}: the layer {node_box:?}, the samples {samples_box:?}");
}
// The turn is a point of the stroke, where it was drawn.
if samples == back {
let xf = doc.world_transform(n.id);
assert!(
network.vertices.iter().any(|v| (xf * Point::new(v.x, v.y) - Point::new(q.0, q.1)).hypot() < 1e-6),
"{what}: no point at the turn"
);
}
}
}
}
crates/engine/src/canvas/drop.rs
+37 -5
View File
@@ -20,6 +20,32 @@ pub struct DropSlot {
/// placed child whose centre is past the pointer, and the line to draw there. Hidden children and
/// those ignoring auto layout don't take part.
pub fn auto_layout_slot(doc: &Document, parent: NodeId, p: Point, exclude: &[NodeId]) -> Option<(usize, Option<[f64; 4]>)> {
slot_in(doc, parent, p, exclude, None)
}
/// [`auto_layout_slot`] for layers dragged within their own frame (measured in Figma's web app,
/// 2026-11-09): the slot follows the leading edge of `moved` in the direction of `delta`. The caller
/// passes `moved` as the layers' combined start bounds plus the raw (unsnapped) drag, and `delta`
/// as that same drag on the page; only its sign along the flow axis matters, and a zero delta uses
/// the low edge. Wrapping layouts keep the pointer rule.
pub fn auto_layout_slot_within(
doc: &Document,
parent: NodeId,
p: Point,
exclude: &[NodeId],
moved: figcraft_geom::Rect,
delta: Point,
) -> Option<(usize, Option<[f64; 4]>)> {
slot_in(doc, parent, p, exclude, Some((moved, delta)))
}
fn slot_in(
doc: &Document,
parent: NodeId,
p: Point,
exclude: &[NodeId],
dragged: Option<(figcraft_geom::Rect, Point)>,
) -> Option<(usize, Option<[f64; 4]>)> {
let pn = doc.node(parent)?;
let layout = pn.layout.as_ref()?;
let vertical = layout.mode == LayoutMode::Vertical;
@@ -34,11 +60,17 @@ pub fn auto_layout_slot(doc: &Document, parent: NodeId, p: Point, exclude: &[Nod
let (k, line) = wrap_slot(doc, &flow_ids, p, vertical);
return Some((index(k), line));
}
let pos = if vertical { p.y } else { p.x };
let k = flow_ids
.iter()
.position(|c| doc.world_bounds(*c).is_some_and(|b| pos < if vertical { b.center().y } else { b.center().x }))
.unwrap_or(flow_ids.len());
let mid = |c: &NodeId| doc.world_bounds(*c).map(|b| if vertical { b.center().y } else { b.center().x });
let k = if let Some((r, d)) = dragged {
let (lo, hi, dd) = if vertical { (r.y0, r.y1, d.y) } else { (r.x0, r.x1, d.x) };
// Forward: past every sibling whose middle the leading (high) edge has reached; backward: past
// every one whose middle lies before the leading (low) edge. A zero delta (no move along the
// flow) takes the backward rule, which leaves the layers where they were.
flow_ids.iter().position(|c| mid(c).is_some_and(|m| if dd > 0.0 { m > hi } else { m >= lo })).unwrap_or(flow_ids.len())
} else {
let pos = if vertical { p.y } else { p.x };
flow_ids.iter().position(|c| mid(c).is_some_and(|m| pos < m)).unwrap_or(flow_ids.len())
};
let line = flow_ids.get(k).and_then(|c| doc.world_bounds(*c)).map(|b| line_before(b, vertical, 2.0)).or_else(|| {
flow_ids
.last()
crates/engine/src/canvas/textedit.rs
+30 -5
View File
@@ -284,32 +284,57 @@ fn insert_model(s: &mut Session, text: &str, ime_commit: bool) -> Result<ImeInse
let text = normalized;
edit(s, |t, te| {
let (a, b) = range(te);
// "- ", "* ", "1. " or "1) " typed at the start of a plain paragraph starts a list (the
// creation characters of Create bulleted and numbered lists).
// "- ", "* ", "<number>. " or "1) " typed at the start of a plain paragraph starts a list
// (the creation characters of Create bulleted and numbered lists). As measured in Figma
// (2026-11-11), a typed "5. " starts the numbered list at 5 (there is no start-number
// field). "0. " and a bracket after a number other than 1 are not measured: plain text.
if text == " " && a == b && t.para_list(t.para_of(a)).list == ListStyle::None {
let chars: Vec<char> = t.characters.chars().collect();
let start = line_start(&chars, a);
let typed: String = chars.get(start..a).unwrap_or(&[]).iter().collect();
let mut first = 1_u32;
let list = match typed.as_str() {
"-" | "*" => ListStyle::Bulleted,
"1." | "1)" => ListStyle::Numbered,
_ => ListStyle::None,
"1)" => ListStyle::Numbered,
_ => match typed.strip_suffix('.').filter(|d| !d.is_empty() && d.bytes().all(|b| b.is_ascii_digit())) {
Some(d) => match d.parse::<u32>() {
Ok(n) if (1..=MAX_TYPED_LIST_START).contains(&n) => {
first = n;
ListStyle::Numbered
}
_ => ListStyle::None,
},
None => ListStyle::None,
},
};
if list != ListStyle::None {
t.replace_range(start, a, "");
t.set_para_lists(start, start, |pl| pl.list = list);
t.set_para_lists(start, start, |pl| {
pl.list = list;
pl.start_offset = first - 1;
});
(te.caret, te.anchor) = (start, start);
outcome = ImeInsertion::Transformed;
return;
}
}
t.replace_range(a, b, &text);
// As measured in Figma (2026-11-11): an item made by Enter has no start of its own, so
// unlisting the item before it makes it restart at 1 rather than at the copied start.
// Every paragraph after the first that the insertion made loses the start it was copied.
if text.contains('\n') {
let end = a + text.chars().count();
t.clear_list_starts(t.para_of(a) + 1, t.para_of(end));
}
te.caret = a + text.chars().count();
te.anchor = te.caret;
})?;
Ok(outcome)
}
/// The largest number a typed `N. ` can start a numbered list at.
const MAX_TYPED_LIST_START: u32 = 9999;
/// What a list key does to the selected items.
#[derive(Clone, Copy, PartialEq, Eq)]
enum ListMove {
crates/engine/src/canvas/tools/drag.rs
+14 -2
View File
@@ -216,6 +216,8 @@ impl Session {
}
}
// Cmd/Ctrl (and Control on macOS) held while dragging suspends snapping.
// The pointer's own drag, before snapping: a reorder in auto layout follows it.
let raw = d;
let snap_on = self.ds().map(|ds| ds.view.snap_objects).unwrap_or(true) && !ev.cmd && !ev.ctrl;
let mut guides = Vec::new();
if self.ds().map(|ds| ds.view.snap_pixel).unwrap_or(true) {
@@ -268,8 +270,18 @@ impl Session {
// cell) under the pointer, as the frame shows it now. A frame other than the
// one they come from is outlined too.
let cell = if mode == LayoutMode::Grid { crate::drop::grid_cell_at(doc, target, p) } else { None };
let idx =
if mode == LayoutMode::Grid { 0 } else { crate::drop::auto_layout_slot(doc, target, p, &moving).map_or(0, |(i, _)| i) };
// Within the frame they came from, the slot follows the leading edge of the
// box they would fill (their combined start bounds moved by the drag), not
// the pointer. The preview starts from the document as the drag began.
let within = moving.iter().all(|m| doc.node(*m).is_some_and(|n| n.parent == Some(target)));
let idx = if mode == LayoutMode::Grid {
0
} else if let (true, Some(b)) = (within, doc.bounds_of(&moving)) {
let moved = Rect::new(b.x0 + raw.x, b.y0 + raw.y, b.x1 + raw.x, b.y1 + raw.y);
crate::drop::auto_layout_slot_within(doc, target, p, &moving, moved, Point::new(raw.x, raw.y)).map_or(0, |(i, _)| i)
} else {
crate::drop::auto_layout_slot(doc, target, p, &moving).map_or(0, |(i, _)| i)
};
for m in &moving {
if doc.get(*m)?.parent != Some(target) {
doc.reparent(*m, target, None)?;
crates/engine/src/canvas/tools/keys.rs
+4 -16
View File
@@ -1,4 +1,4 @@
use super::{Document, Gesture, Node, NodeId, Overlay, Point, PointerEvent, PointerKind, Result, Session, ShapeHandle, ToolId, json, textedit};
use super::{Document, Gesture, NodeId, Overlay, Point, PointerEvent, PointerKind, Result, Session, ShapeHandle, ToolId, json, textedit};
impl Session {
/// Keys the current mode handles before menu shortcuts (vector edit mode's tools and point
@@ -146,21 +146,9 @@ impl Session {
self.ds_mut()?.focus = None;
return Ok(());
}
// Escape selects the parent, then nothing.
let doc = self.doc()?;
let parents: Vec<NodeId> =
sel.iter().filter_map(|i| doc.node(*i).and_then(|n| n.parent)).filter(|p| !doc.node(*p).is_some_and(Node::is_page)).collect();
if !parents.is_empty() {
let mut uniq = Vec::new();
for p in parents {
if !uniq.contains(&p) {
uniq.push(p);
}
}
self.set_selection(uniq);
} else {
self.set_selection(vec![]);
}
// Escape clears the selection whatever its nesting (measured in Figma: it never selects the
// parent).
self.set_selection(vec![]);
Ok(())
}
crates/engine/src/canvas/tools/pen.rs
+3 -2
View File
@@ -313,7 +313,8 @@ impl Session {
if points.len() < 2 {
return Ok(());
}
// Smooth: fit a curve through the samples.
// Smooth: fit a curve through the samples, kept from shooting past them where the stroke
// turns back or runs nearly straight (#1741).
let mut poly = figcraft_geom::BezPath::new();
for (k, p) in points.iter().enumerate() {
if k == 0 {
@@ -322,7 +323,7 @@ impl Session {
poly.line_to(*p);
}
}
let fitted = figcraft_geom::kurbo::simplify::simplify_bezpath(poly.iter(), 0.75, &Default::default());
let fitted = figcraft_geom::simplify_path(&poly, 0.75);
let d = fitted.to_svg();
if matches!(self.tool.tool, ToolId::Marker | ToolId::Highlighter) {
return self.ink_finish(&d);
crates/engine/src/cmd/component.rs
+9 -2
View File
@@ -24,8 +24,8 @@ use instance::{detach, make_slot, push_changes, remove_slot, reset_instance, res
pub(crate) use instance::{swap_at, swap_instance};
use props::{add_prop, bind_prop, delete_prop, edit_prop, set_props};
pub(crate) use props::{apply_prop_bindings, check_prop_binding, describe_props};
use variants::{add_variant, combine};
pub use variants::{can_add_variant, can_combine_variants};
use variants::{add_variant, combine, create_set};
pub use variants::{can_add_variant, can_combine_variants, can_create_set};
/// `component.hideWhenPublishing`: the leading `.` of the names of this file's components and
/// sets (those `ids` are or are in), put on or taken off.
@@ -72,6 +72,13 @@ pub fn specs() -> Vec<CommandSpec> {
s.set_selection(out.iter().filter_map(id_of).collect());
Ok(json!({"ids": out}))
}),
spec!(
"component.createSet",
"Create component set",
"{ids? (layers, not components, sets or instances)} (each becomes a component, wrapped in place in a component set: variants \"Property 1=<name>\" left to right, 20 px around)",
true,
create_set
),
spec!(
"component.combineVariants",
"Combine as variants",
crates/engine/src/cmd/component/variants.rs
+71 -2
View File
@@ -1,6 +1,6 @@
use super::{
BTreeMap, BTreeSet, Document, EngineError, Node, NodeId, NodeKind, Result, Session, Value, bad, inside_instance, json, owning_instance,
req_targets, roots, set_name_from, string, targets, variant_name, variant_options, variant_props, variant_set, z_sorted,
BTreeMap, BTreeSet, Document, EngineError, Node, NodeId, NodeKind, Result, Session, Value, bad, create, id_of, inside_instance, json,
owning_instance, req_targets, roots, set_name_from, string, targets, variant_name, variant_options, variant_props, variant_set, z_sorted,
};
/// Wrap components in a new component set (named after the first) placed around them.
@@ -94,6 +94,75 @@ pub(super) fn combine(s: &mut Session, p: &Value) -> Result<Value> {
Ok(json!({"id": set}))
}
/// Why `ids` (distinct) can't each become a component of a new set (`component.createSet`), or
/// `None` when they can: layers inside an instance, library copies, instances, components and
/// component sets, and a layer inside another one of `ids`.
fn create_set_refusal(doc: &Document, ids: &[NodeId]) -> Option<&'static str> {
if ids.iter().any(|i| inside_instance(doc, *i)) {
Some("layers inside an instance can't become components")
} else if ids.iter().any(|i| doc.is_remote(*i)) {
Some(crate::library::READ_ONLY)
} else if ids.iter().any(|i| {
doc.node(*i).is_some_and(|n| matches!(n.kind, NodeKind::Instance { .. } | NodeKind::Component { .. } | NodeKind::ComponentSet { .. }))
}) {
Some("select layers that aren't components, component sets or instances")
} else if roots(doc, ids).len() != ids.len() {
Some("a layer can't be in a set with one inside it")
} else {
None
}
}
/// Whether "Create component set" is on offer for `ids`: at least one layer that
/// [`create_set_refusal`] lets through.
pub fn can_create_set(doc: &Document, ids: &[NodeId]) -> bool {
let distinct: Vec<NodeId> = ids.iter().copied().collect::<BTreeSet<_>>().into_iter().collect();
!distinct.is_empty() && distinct.iter().all(|i| doc.contains(*i)) && create_set_refusal(doc, &distinct).is_none()
}
/// `component.createSet`: each target becomes a component (as `component.createMultiple` makes
/// them) and all are wrapped in place in a component set, 20 px around, named as Figma names them:
/// variants "Property 1=<layer name>" in left-to-right order (a name holding `=` is kept); layers
/// that all share a name give a set of that name with "Property 1=Default" variants; otherwise the
/// set is "Component N".
pub(super) fn create_set(s: &mut Session, p: &Value) -> Result<Value> {
let cmd = "component.createSet";
let mut seen = BTreeSet::new();
let ids: Vec<NodeId> = req_targets(cmd, s, p)?.into_iter().filter(|i| seen.insert(*i)).collect();
let doc = s.doc()?;
if let Some(why) = create_set_refusal(doc, &ids) {
return Err(EngineError::Disabled(cmd.into(), why.into()));
}
let mut made = Vec::new();
for i in roots(doc, &ids) {
let r = create(s, &json!({"ids": [i]}))?;
made.push(id_of(&r["id"]).ok_or_else(|| bad(cmd, "component creation failed"))?);
}
let doc = s.doc_mut()?;
// Left to right by world x, ties by y: the variants' order, and the values' order.
let mut by_x: Vec<(NodeId, f64, f64)> = made.iter().map(|i| doc.world_bounds(*i).map_or((*i, 0.0, 0.0), |b| (*i, b.x0, b.y0))).collect();
by_x.sort_by(|a, b| a.1.total_cmp(&b.1).then(a.2.total_cmp(&b.2)));
let names: Vec<String> = by_x.iter().map(|(i, ..)| doc.node(*i).map(|n| n.name.clone()).unwrap_or_default()).collect();
let same = names.windows(2).all(|w| w.first() == w.get(1)) && names.first().is_some_and(|n| !n.is_empty() && !n.contains('='));
let set_name = match names.first() {
Some(n) if same => n.clone(),
_ => doc.next_name("Component"),
};
for ((i, ..), name) in by_x.iter().zip(&names) {
let node = doc.get_mut(*i)?;
if same {
node.name = "Property 1=Default".into();
} else if !name.contains('=') {
node.name = format!("Property 1={name}");
}
}
let ordered = z_sorted(doc, &made);
let set = wrap_in_set(cmd, doc, &ordered)?;
doc.get_mut(set)?.name = set_name;
s.set_selection(vec![set]);
Ok(json!({"id": set}))
}
/// Grow a component set so it wraps its variants with 20 px of padding (right and bottom).
pub(super) fn fit_set(doc: &mut Document, set: NodeId) {
let Some(kids) = doc.node(set).map(|n| n.children.clone()) else { return };
crates/engine/src/cmd/edit/props.rs
+1 -1
View File
@@ -254,7 +254,7 @@ pub(super) fn stroke_brush(s: &mut Session, p: &Value) -> Result<Value> {
pub(super) fn reparent(s: &mut Session, p: &Value) -> Result<Value> {
let ids = req_targets("node.reparent", s, p)?;
let parent = req_id("node.reparent", p, "parent")?;
let index = num(p, "index").map(|i| i.max(0.0) as usize);
let index = opt_index("node.reparent", p, "index")?;
let doc = s.doc_mut()?;
let ids = z_sorted(doc, &roots(doc, &ids));
// `index` is where the first moved layer ends up among the parent's children (bottom first),
crates/engine/src/cmd/file/export.rs
+14 -3
View File
@@ -1,7 +1,7 @@
use super::load::{ext, write};
use super::save::thumbnail;
use super::*;
use crate::params::f64_of;
use crate::params::{f64_of, req_targets};
/// Encode `ids` (or the page) in `format` at `scale`.
pub fn export_bytes(doc: &Document, ids: &[NodeId], format: ExportFormat, scale: f64) -> Result<Vec<u8>> {
@@ -86,7 +86,7 @@ pub(super) fn export(s: &mut Session, p: &Value) -> Result<Value> {
_ => {}
}
let doc = s.doc()?;
let mut ids = targets(s, p);
let mut ids = export_targets(cmd, s, p)?;
if ids.is_empty() {
ids = doc.get(s.page()?)?.children.clone();
}
@@ -325,11 +325,22 @@ pub fn exportable_layers(doc: &Document, page: NodeId) -> Vec<NodeId> {
doc.subtree(page).into_iter().skip(1).filter(|i| doc.node(*i).is_some_and(|n| !n.exports.is_empty())).collect()
}
/// Named layers (`ids` / `id`), checked like other commands; empty when none are named, so the
/// caller can fall back to its default instead of silently dropping a bad id.
fn export_targets(cmd: &str, s: &Session, p: &Value) -> Result<Vec<NodeId>> {
let named = match get(p, "ids") {
Some(Value::Array(a)) if !a.is_empty() => true,
Some(Value::Array(_) | Value::Null) | None => get(p, "id").is_some_and(|v| !v.is_null()),
Some(_) => true,
};
if named { req_targets(cmd, s, p) } else { Ok(targets(s, p)) }
}
pub(super) fn export_layers(s: &mut Session, p: &Value) -> Result<Value> {
let cmd = "file.exportLayers";
let doc = s.doc()?;
let assets = boolean(p, "assets").unwrap_or(false);
let mut ids = targets(s, p);
let mut ids = export_targets(cmd, s, p)?;
if ids.is_empty() {
ids = if assets { vec![s.page()?] } else { exportable_layers(doc, s.page()?) };
}
crates/engine/src/cmd/file/load.rs
+110 -21
View File
@@ -399,11 +399,19 @@ pub(crate) fn load_fig(bytes: &[u8], name: &str) -> Option<Result<figcraft_forma
}))
}
/// The most layers all of a Penpot file's raw SVG placeholders may expand to together.
const MAX_PENPOT_SVG_LAYERS: usize = 100_000;
/// Turn Penpot raw SVG placeholders into editable FigCraft SVG content, using the
/// normal SVG importer. The parser (figcraft-format) only stores bounded XML so it
/// does not need to depend on the SVG crate; the engine does this second pass.
/// Any failure leaves the original placeholder and XML data intact for later use.
fn expand_penpot_raw_svgs(doc: &mut Document, notes: &mut Vec<String>) {
expand_penpot_raw_svgs_within(doc, notes, MAX_PENPOT_SVG_LAYERS);
}
/// [`expand_penpot_raw_svgs`] with at most `room` layers made in all.
fn expand_penpot_raw_svgs_within(doc: &mut Document, notes: &mut Vec<String>, mut room: usize) {
let layers = doc
.nodes()
.filter_map(|node| {
@@ -413,12 +421,24 @@ fn expand_penpot_raw_svgs(doc: &mut Document, notes: &mut Vec<String>) {
})
.collect::<Vec<_>>();
let mut ok_count = 0usize;
// The SVG importer caps its own layers per file; `room` is the cap over all of a file's placeholders.
for (id, name, width, height, xml, empty) in layers {
if room == 0 {
if let Some(n) = doc.node_mut(id) {
n.plugin_data.insert("penpot.svgRawStatus".into(), "not-expanded".into());
}
if notes.len() < 100 {
notes.push(format!("Penpot SVG '{name}': not converted, the file's SVG layers are over the limit; the original markup is preserved"));
}
continue;
}
if !empty {
notes.push(format!("Penpot SVG '{name}': has separate child layers; the original tree was preserved to prevent duplicate rendering"));
continue;
}
match figcraft_svg::import_svg_with_notes(doc, xml.as_bytes(), id, 0.0, 0.0, &name) {
let before = doc.node_count();
let imported = figcraft_svg::import_svg_with_notes(doc, xml.as_bytes(), id, 0.0, 0.0, &name);
match imported {
Ok(imported) => {
// An SVG can be syntactically valid yet contain no supported drawable
// elements. Do not claim success or leave an empty extra frame.
@@ -432,6 +452,21 @@ fn expand_penpot_raw_svgs(doc: &mut Document, notes: &mut Vec<String>) {
}
continue;
}
// Charged once the empty ones are gone; one that doesn't fit is taken out again.
let added = doc.node_count().saturating_sub(before);
if added > room {
let _ = doc.remove(imported.frame);
if let Some(n) = doc.node_mut(id) {
n.plugin_data.insert("penpot.svgRawStatus".into(), "not-expanded".into());
}
if notes.len() < 100 {
notes.push(format!(
"Penpot SVG '{name}': not converted, the file's SVG layers are over the limit; the original markup is preserved"
));
}
continue;
}
room -= added;
let size = doc.node(imported.frame).map(|n| (n.width, n.height));
if let Some((svg_w, svg_h)) = size
&& svg_w.is_finite()
@@ -470,6 +505,28 @@ fn expand_penpot_raw_svgs(doc: &mut Document, notes: &mut Vec<String>) {
}
}
/// Whether some of the first `len` characters are in none of `runs`. Where runs start and stop
/// covering is summed once, so runs overlapping any number of times cost no more than their count.
fn has_uncovered(len: usize, runs: &[figcraft_doc::StyleRun]) -> bool {
let mut change = vec![0i64; len + 1];
for run in runs {
let (start, end) = (run.start.min(len), run.end.min(len));
if start < end {
if let Some(c) = change.get_mut(start) {
*c += 1;
}
if let Some(c) = change.get_mut(end) {
*c -= 1;
}
}
}
let mut open = 0i64;
change.iter().take(len).any(|c| {
open += c;
open <= 0
})
}
/// Non-destructive font diagnostic for the action palette, CLI and control API.
/// Includes styled runs, not just the default typeface of each text layer.
pub(super) fn font_report(doc: &Document) -> Value {
@@ -485,21 +542,15 @@ fn font_report_with_families(doc: &Document, installed: &[String]) -> Value {
if text.characters.is_empty() {
continue;
}
let mut covered = vec![false; text.characters.chars().count().min(100_000)];
let len = text.characters.chars().count().min(100_000);
let mut used = BTreeSet::new();
for run in &text.runs {
let start = run.start.min(covered.len());
let end = run.end.min(covered.len());
if start < end {
if !run.style.font_family.trim().is_empty() {
used.insert(run.style.font_family.clone());
}
for entry in covered.iter_mut().take(end).skip(start) {
*entry = true;
}
if run.start.min(len) < run.end.min(len) && !run.style.font_family.trim().is_empty() {
used.insert(run.style.font_family.clone());
}
}
if covered.iter().any(|entry| !entry) {
let uncovered = has_uncovered(len, &text.runs);
if uncovered {
used.insert(text.style.font_family.clone());
}
for family in used {
@@ -599,19 +650,14 @@ fn missing_penpot_font_warnings(doc: &Document, families: &[String]) -> Vec<Stri
if text_len == 0 {
continue;
}
let mut covered = vec![false; text_len.min(100_000)];
let len = text_len.min(100_000);
let mut used = BTreeSet::new();
for run in &text.runs {
let start = run.start.min(covered.len());
let end = run.end.min(covered.len());
if start < end {
if run.start.min(len) < run.end.min(len) {
used.insert(run.style.font_family.clone());
for flag in covered.iter_mut().take(end).skip(start) {
*flag = true;
}
}
}
if covered.iter().any(|present| !present) {
if has_uncovered(len, &text.runs) {
used.insert(text.style.font_family.clone());
}
for family in used {
@@ -652,8 +698,10 @@ fn link_instances(doc: &mut Document) {
let mut insts: Vec<(usize, NodeId)> =
doc.nodes().filter(|n| matches!(n.kind, NodeKind::Instance { .. })).map(|n| (doc.ancestors(n.id).len(), n.id)).collect();
insts.sort_by_key(|a| std::cmp::Reverse(a.0));
// Rebasing leaves the mains alone, so each main's layer paths are worked out once.
let mut mains = crate::components::MainPaths::new();
for (_, i) in insts {
crate::components::rebase_instance(doc, i);
crate::components::rebase_instance_with(doc, i, &mut mains);
}
}
@@ -790,6 +838,47 @@ mod penpot_svg_v10_tests {
use super::*;
use figcraft_doc::TextData;
#[test]
fn placeholders_share_one_layer_allowance() {
let mut doc = Document::new("Two SVGs");
let page = doc.first_page().unwrap();
let svg = r#"<svg xmlns="http://www.w3.org/2000/svg" width="10" height="10"><rect width="5" height="5" fill="red"/><rect x="5" width="5" height="5" fill="blue"/></svg>"#;
let ids: Vec<NodeId> = (0..2)
.map(|i| {
let id = doc.create(page, NodeKind::Frame, &format!("S{i}"), 0.0, 0.0, 10.0, 10.0).unwrap();
let layer = doc.node_mut(id).unwrap();
layer.plugin_data.insert("penpot.svgRawXml".into(), svg.into());
layer.plugin_data.insert("penpot.svgRawStatus".into(), "pending".into());
id
})
.collect();
let mut warnings = Vec::new();
let nodes = doc.node_count();
expand_penpot_raw_svgs_within(&mut doc, &mut warnings, 4);
assert!(doc.node_count() - nodes <= 4, "never more layers than the allowance");
let status = |i: usize| doc.node(ids[i]).unwrap().plugin_data.get("penpot.svgRawStatus").cloned();
assert_eq!(status(0).as_deref(), Some("expanded"), "the first uses the allowance");
assert_eq!(status(1).as_deref(), Some("not-expanded"));
assert!(doc.node(ids[1]).unwrap().children.is_empty());
assert!(warnings.iter().any(|w| w.contains("over the limit")), "{warnings:?}");
}
#[test]
fn many_overlapping_style_runs_are_summed_once() {
use figcraft_doc::StyleRun;
let mut doc = Document::new("Runs");
let page = doc.first_page().unwrap();
let mut t = TextData::new("x".repeat(100_000));
t.style.font_family = "Unused Base".into();
let mut run = t.style.clone();
run.font_family = "Run Font".into();
t.runs = (0..50_000).map(|_| StyleRun { start: 0, end: 100_000, style: run.clone() }).collect();
doc.create(page, NodeKind::Text(t), "Long", 0.0, 0.0, 100.0, 30.0).unwrap();
let report = font_report_with_families(&doc, &[]);
assert_eq!(report["fonts"].as_array().map(Vec::len), Some(1), "{report}");
assert_eq!(report["fonts"][0]["family"], "Run Font");
}
#[test]
fn expands_inline_svg_into_editable_shapes_without_discarding_source() {
let mut doc = Document::new("SVG fixture");
crates/engine/src/cmd/image.rs
+5 -2
View File
@@ -5,7 +5,7 @@ use figcraft_doc::{Document, ImagePreset, Node};
use serde_json::{Value, json};
use super::{CommandSpec, ok};
use crate::params::{f64_of, get, num, req_index, req_string, req_targets, string, targets};
use crate::params::{f64_of, get, req_index, req_string, req_targets, string, targets};
use crate::{EngineError, Result, Session, bad, spec};
pub fn specs() -> Vec<CommandSpec> {
@@ -236,7 +236,10 @@ fn save_preset(s: &mut Session, p: &Value) -> Result<Value> {
Some(v) => with_values(cmd, ImageFilters::NONE, v)?,
None => {
let stroke = strokes(cmd, p)?;
let index = num(p, "index").filter(|k| k.is_finite() && *k >= 0.0).map(|k| k as usize);
let index = match get(p, "index") {
None | Some(Value::Null) => None,
Some(_) => Some(req_index(cmd, p, "index")?),
};
let doc = s.doc()?;
targets(s, p)
.iter()
crates/engine/src/cmd/structure.rs
+4 -4
View File
@@ -799,7 +799,7 @@ fn simplify(s: &mut Session, p: &Value) -> Result<Value> {
WindingRule::NonZero
};
let path = drawn.fill_path();
let path = figcraft_geom::kurbo::simplify::simplify_bezpath(path.iter(), tol, &Default::default());
let path = figcraft_geom::simplify_path(&path, tol);
let (path, output_winding) = match figcraft_pathops::simplify_with_rule(&path, winding == WindingRule::EvenOdd) {
Ok(path) => (path, WindingRule::EvenOdd),
Err(_) => (path, winding),
@@ -809,7 +809,7 @@ fn simplify(s: &mut Session, p: &Value) -> Result<Value> {
} else {
for (index, region) in source.regions.iter().enumerate() {
let Some(path) = drawn.region_path(index) else { continue };
let path = figcraft_geom::kurbo::simplify::simplify_bezpath(path.iter(), tol, &Default::default());
let path = figcraft_geom::simplify_path(&path, tol);
let path = figcraft_pathops::simplify_with_rule(&path, region.winding == WindingRule::EvenOdd).unwrap_or(path);
append_region_path(&mut net, &path, region, region.winding);
}
@@ -826,7 +826,7 @@ fn simplify(s: &mut Session, p: &Value) -> Result<Value> {
open.regions.clear();
if !open.segments.is_empty() {
let path = open.stroke_path();
let simplified = figcraft_geom::kurbo::simplify::simplify_bezpath(path.iter(), tol, &Default::default());
let simplified = figcraft_geom::simplify_path(&path, tol);
let mut loose = VectorNetwork::from_path(&simplified);
loose.regions.clear();
append_network(&mut net, loose);
@@ -834,7 +834,7 @@ fn simplify(s: &mut Session, p: &Value) -> Result<Value> {
}
if source.regions.is_empty() {
let path = source.stroke_path();
let simplified = figcraft_geom::kurbo::simplify::simplify_bezpath(path.iter(), tol, &Default::default());
let simplified = figcraft_geom::simplify_path(&path, tol);
net = VectorNetwork::from_path(&simplified);
net.regions.clear();
}
crates/engine/src/components_behaviour_tests.rs
+243
View File
@@ -7,6 +7,7 @@
use serde_json::{Value, json};
use crate::Session;
use crate::automation::params::id_of;
use crate::components::tests::{chars, copy_of, ex, fill, healthy, idv, kids, node};
use figcraft_doc::*;
@@ -1000,3 +1001,245 @@ fn deleting_a_layer_inside_an_instance_hides_it_instead() {
s.execute("edit.delete", &json!({"ids": [k.inst]})).unwrap();
assert!(s.doc().unwrap().node(k.inst).is_none());
}
/// Create multiple components (#2088): each selected layer becomes its own component in place,
/// keeping its name and position; all stay selected and one undo reverts them all.
#[test]
fn create_multiple_components_keeps_names_and_places_and_is_one_undo_step() {
let mut s = Session::new();
let mut frames = Vec::new();
for (i, name) in ["Card", "Badge", "Tile"].into_iter().enumerate() {
let x = 150.0 * i as f64;
let v = s.execute("frame.create", &json!({"x": x, "y": 20, "width": 100, "height": 60})).unwrap();
let f = id_of(&v["id"]).unwrap();
s.execute("object.rename", &json!({"ids": [f], "name": name})).unwrap();
frames.push(f);
}
let before = undo_len(&s);
let out = s.execute("component.createMultiple", &json!({"ids": frames})).unwrap();
assert_eq!(undo_len(&s), before + 1, "one undo step");
let made: Vec<NodeId> = out["ids"].as_array().unwrap().iter().filter_map(id_of).collect();
assert_eq!(made.len(), 3);
assert_eq!(s.selection(), made, "all of them stay selected");
let doc = s.doc().unwrap();
for (i, (c, name)) in made.iter().zip(["Card", "Badge", "Tile"]).enumerate() {
let n = doc.node(*c).unwrap();
assert!(matches!(n.kind, NodeKind::Component { .. }), "{name} is a component");
assert_eq!(n.name, name);
let b = doc.world_bounds(*c).unwrap();
assert_eq!((b.x0, b.y0), (150.0 * i as f64, 20.0), "{name} stays in place");
}
s.undo().unwrap();
let doc = s.doc().unwrap();
assert!(frames.iter().all(|f| matches!(doc.node(*f).map(|n| &n.kind), Some(NodeKind::Frame))), "one undo restores the frames");
}
/// Frames named `names` at x = 150 * i (mirrored when `reverse`), y 20, 100 x 60.
fn named_frames(s: &mut Session, names: &[&str], reverse: bool) -> Vec<NodeId> {
let n = names.len();
names
.iter()
.enumerate()
.map(|(i, name)| {
let x = 150.0 * if reverse { n - 1 - i } else { i } as f64;
let v = s.execute("frame.create", &json!({"x": x, "y": 20, "width": 100, "height": 60})).unwrap();
let f = id_of(&v["id"]).unwrap();
s.execute("object.rename", &json!({"ids": [f], "name": name})).unwrap();
f
})
.collect()
}
/// The set's name and its children's names in layer order.
fn set_names(s: &Session, set: NodeId) -> (String, Vec<String>) {
let doc = s.doc().unwrap();
let n = doc.node(set).unwrap();
(n.name.clone(), n.children.iter().map(|c| doc.node(*c).unwrap().name.clone()).collect())
}
/// The set's variant names ordered by world x.
fn names_by_x(s: &Session, set: NodeId) -> Vec<String> {
let doc = s.doc().unwrap();
let mut v: Vec<(f64, String)> =
doc.node(set).unwrap().children.iter().map(|c| (doc.world_bounds(*c).unwrap().x0, doc.node(*c).unwrap().name.clone())).collect();
v.sort_by(|a, b| a.0.total_cmp(&b.0));
v.into_iter().map(|(_, n)| n).collect()
}
/// Create component set (#2088, measured in Figma): variants "Property 1=<name>" in left-to-right
/// order, the set "Component 1", wrapped in place 20 px around, selected, one undo step.
#[test]
fn create_set_names_variants_by_layer_name_and_wraps_in_place() {
let mut s = Session::new();
let frames = named_frames(&mut s, &["Primary", "Secondary", "Ghost"], false);
let before = undo_len(&s);
let out = s.execute("component.createSet", &json!({"ids": frames})).unwrap();
assert_eq!(undo_len(&s), before + 1, "one undo step");
let set = id_of(&out["id"]).unwrap();
assert_eq!(s.selection(), vec![set], "the set is selected");
assert_eq!(set_names(&s, set).0, "Component 1");
assert_eq!(names_by_x(&s, set), ["Property 1=Primary", "Property 1=Secondary", "Property 1=Ghost"]);
let doc = s.doc().unwrap();
for (i, c) in doc.node(set).unwrap().children.iter().enumerate() {
assert!(matches!(doc.node(*c).unwrap().kind, NodeKind::Component { .. }));
let b = doc.world_bounds(*c).unwrap();
assert_eq!((b.x0, b.y0), (150.0 * i as f64, 20.0), "frames stay put");
}
let sb = doc.world_bounds(set).unwrap();
assert_eq!((sb.x0, sb.y0, sb.x1, sb.y1), (-20.0, 0.0, 420.0, 100.0), "20 px on every side");
s.undo().unwrap();
let doc = s.doc().unwrap();
assert!(doc.node(set).is_none());
assert!(frames.iter().all(|f| matches!(doc.node(*f).map(|n| &n.kind), Some(NodeKind::Frame))), "one undo restores the frames");
}
#[test]
fn create_set_orders_left_to_right_whatever_the_selection_order() {
let mut s = Session::new();
let frames = named_frames(&mut s, &["A", "B", "C"], true);
let out = s.execute("component.createSet", &json!({"ids": frames})).unwrap();
let set = id_of(&out["id"]).unwrap();
assert_eq!(names_by_x(&s, set), ["Property 1=C", "Property 1=B", "Property 1=A"]);
let (_, kids) = set_names(&s, set);
assert_eq!(kids.len(), 3);
}
#[test]
fn create_set_keeps_names_already_in_prop_value_form() {
let mut s = Session::new();
let frames = named_frames(&mut s, &["Size=Small", "Size=Large", "Size=Medium"], false);
let out = s.execute("component.createSet", &json!({"ids": frames})).unwrap();
let set = id_of(&out["id"]).unwrap();
assert_eq!(set_names(&s, set).0, "Component 1");
assert_eq!(names_by_x(&s, set), ["Size=Small", "Size=Large", "Size=Medium"]);
}
#[test]
fn create_set_with_one_shared_name_names_the_set_and_makes_default_variants() {
let mut s = Session::new();
let frames = named_frames(&mut s, &["Card", "Card", "Card"], false);
let out = s.execute("component.createSet", &json!({"ids": frames})).unwrap();
let set = id_of(&out["id"]).unwrap();
let (name, kids) = set_names(&s, set);
assert_eq!(name, "Card");
assert_eq!(kids, ["Property 1=Default", "Property 1=Default", "Property 1=Default"]);
}
#[test]
fn create_set_refuses_instances_and_leaves_the_document_alone() {
let mut s = Session::new();
let frames = named_frames(&mut s, &["A", "B"], false);
let c = s.execute("component.create", &json!({"ids": [frames[0]]})).unwrap();
let comp = id_of(&c["id"]).unwrap();
let inst = s.execute("instance.create", &json!({"component": comp})).unwrap();
let inst = id_of(&inst["id"]).unwrap();
let before = undo_len(&s);
let e = s.execute("component.createSet", &json!({"ids": [inst, frames[1]]})).unwrap_err();
assert!(matches!(e, crate::EngineError::Disabled(..)), "{e:?}");
assert_eq!(undo_len(&s), before);
assert!(matches!(s.doc().unwrap().node(frames[1]).unwrap().kind, NodeKind::Frame));
}
#[test]
fn create_set_refuses_a_target_inside_another_target_and_leaves_the_document_alone() {
let mut s = Session::new();
let frames = named_frames(&mut s, &["Outer", "Inner"], false);
s.execute("node.reparent", &json!({"ids": [frames[1]], "parent": frames[0]})).unwrap();
let before = undo_len(&s);
let e = s.execute("component.createSet", &json!({"ids": [frames[0], frames[1]]})).unwrap_err();
assert!(matches!(e, crate::EngineError::Disabled(..)), "{e:?}");
assert_eq!(undo_len(&s), before);
let doc = s.doc().unwrap();
assert!(matches!(doc.node(frames[0]).unwrap().kind, NodeKind::Frame));
assert!(matches!(doc.node(frames[1]).unwrap().kind, NodeKind::Frame));
}
/// Every node's id, parent, name and kind, to compare a document before and after a refused command.
fn snapshot(s: &Session) -> Vec<String> {
s.doc().unwrap().nodes().map(|n| format!("{:?}|{:?}|{}|{:?}", n.id, n.parent, n.name, n.kind)).collect()
}
/// A refused `component.createSet`: `Disabled`, no undo step, the document and the selection as they were.
fn assert_create_set_refused(s: &mut Session, ids: &[NodeId]) {
let (before, undo, selection) = (snapshot(s), undo_len(s), s.selection());
let e = s.execute("component.createSet", &json!({"ids": ids})).unwrap_err();
assert!(matches!(e, crate::EngineError::Disabled(..)), "{e:?}");
assert_eq!(undo_len(s), undo, "no undo step");
assert_eq!(snapshot(s), before, "the document is unchanged");
assert_eq!(s.selection(), selection, "the selection is unchanged");
}
/// Nothing to wrap is refused before anything is created.
#[test]
fn create_set_refuses_no_layers_and_leaves_the_document_alone() {
let mut s = Session::new();
named_frames(&mut s, &["A"], false);
s.execute("select.set", &json!({"ids": []})).unwrap();
assert_create_set_refused(&mut s, &[]);
}
/// One layer is allowed: a set of one variant, as many layers would make.
#[test]
fn create_set_with_one_layer_makes_a_one_variant_set() {
let mut s = Session::new();
let frames = named_frames(&mut s, &["Solo"], false);
let before = undo_len(&s);
let out = s.execute("component.createSet", &json!({"ids": frames})).unwrap();
assert_eq!(undo_len(&s), before + 1, "one undo step");
let set = id_of(&out["id"]).unwrap();
let doc = s.doc().unwrap();
assert_eq!(doc.node(set).unwrap().children.len(), 1);
assert_eq!(names_by_x(&s, set), ["Property 1=Default"], "a lone layer shares its name with itself");
assert!(matches!(doc.node(doc.node(set).unwrap().children[0]).unwrap().kind, NodeKind::Component { .. }));
s.undo().unwrap();
assert!(matches!(s.doc().unwrap().node(frames[0]).unwrap().kind, NodeKind::Frame));
}
/// Each refusal branch of `create_set`, with `can_create_set` agreeing with it.
#[test]
fn create_set_refuses_every_ineligible_selection_and_leaves_the_document_alone() {
use crate::cmd::component::can_create_set;
let mut s = Session::new();
let frames = named_frames(&mut s, &["A", "B", "C"], false);
let comp = id_of(&s.execute("component.create", &json!({"ids": [frames[0]]})).unwrap()["id"]).unwrap();
let inst = id_of(&s.execute("instance.create", &json!({"component": comp})).unwrap()["id"]).unwrap();
let set_frames = named_frames(&mut s, &["V1", "V2"], false);
let set = id_of(&s.execute("component.createSet", &json!({"ids": set_frames})).unwrap()["id"]).unwrap();
// A layer inside the instance (its copy of the card's content).
let in_inst = s.doc().unwrap().node(inst).unwrap().children.first().copied();
// A library copy.
let remote = {
let doc = s.doc_mut().unwrap();
let store = doc.ensure_library_store();
let remote = doc.alloc_id();
doc.insert(Node::new(remote, NodeKind::Frame, "Remote", 10.0, 10.0), store, None).unwrap();
remote
};
let ok = frames[1];
assert!(can_create_set(s.doc().unwrap(), &[ok, frames[2]]));
assert!(!can_create_set(s.doc().unwrap(), &[]));
let mut cases = vec![("instance", inst), ("library copy", remote), ("component", comp), ("component set", set)];
if let Some(i) = in_inst {
cases.push(("inside an instance", i));
}
for (what, bad) in cases {
assert!(!can_create_set(s.doc().unwrap(), &[ok, bad]), "{what}: not offered");
assert_create_set_refused(&mut s, &[ok, bad]);
assert_create_set_refused(&mut s, &[bad]);
}
}
/// A command that fails leaves no trace: the checks before the creation loop catch every
/// refusal the loop's own commands could hit, and `Session::execute` restores the document, the
/// selection and the undo stack on any error, so no half-made components can survive.
#[test]
fn a_failing_create_set_leaves_no_components_behind() {
let mut s = Session::new();
let frames = named_frames(&mut s, &["A", "B"], false);
let (before, undo, selection) = (snapshot(&s), undo_len(&s), s.selection());
let e = s.execute("component.createSet", &json!({"ids": [frames[0], NodeId(u64::MAX)]}));
assert!(e.is_err());
assert_eq!(undo_len(&s), undo);
assert_eq!(snapshot(&s), before);
assert_eq!(s.selection(), selection);
}
crates/engine/src/derived.rs
+4 -1
View File
@@ -164,7 +164,10 @@ pub fn normalize(doc: &mut Document, before: &Document) {
}
}
touched.extend(doc.take_dirty());
// 4b. Board connectors follow the layers they join; their labels sit at their middles.
// 4b. Mind maps re-flow from their first nodes; then board connectors follow the layers they
// join and their labels sit at their middles.
board::settle_mind_maps(doc, before, &touched);
touched.extend(doc.take_dirty());
board::settle_routes(doc, before, &touched);
board::settle_stamps(doc, before, &touched);
touched.extend(doc.take_dirty());
crates/engine/src/design_paste_tests.rs
+64
View File
@@ -106,3 +106,67 @@ fn other_content_is_refused_without_changes() {
assert_eq!(s.doc().unwrap().nodes().count(), before);
assert!(s.clipboard.nodes.is_empty());
}
// The next three pin the paste-placement rules measured in Figma's web app on 2026-11-08 (a
// synthetic file): in place when the original is in view, at the view's centre when it is off
// screen, and in a selected frame's centre when the frame is elsewhere. The fourth pins
// FigCraft's own branch for a selected frame that contains the original (in place inside it),
// which was not measured.
fn copied_rect(s: &mut Session) -> NodeId {
let r = id(&s.execute("shape.rectangle", &json!({"x": 100, "y": 100, "width": 50, "height": 50})).unwrap());
s.execute("edit.copy", &json!({"ids": [r]})).unwrap();
r
}
fn pasted(s: &mut Session) -> NodeId {
let r = s.execute("edit.paste", &json!({})).unwrap();
params::id_of(&r["ids"][0]).unwrap()
}
#[test]
fn paste_with_the_original_in_view_lands_in_place_above_it() {
let mut s = Session::new();
let page = s.page().unwrap();
let r = copied_rect(&mut s);
s.execute("view.set", &json!({"zoom": 1, "cx": 125, "cy": 125})).unwrap();
let c = pasted(&mut s);
let b = s.doc().unwrap().world_bounds(c).unwrap();
assert_eq!((b.x0, b.y0), (100.0, 100.0));
assert_eq!(s.selection(), [c]);
assert_eq!(s.doc().unwrap().node(page).unwrap().children, [r, c]);
}
#[test]
fn paste_with_the_original_off_screen_lands_at_the_view_centre() {
let mut s = Session::new();
copied_rect(&mut s);
s.execute("view.set", &json!({"zoom": 1, "cx": 5000, "cy": 3000})).unwrap();
let c = pasted(&mut s);
let b = s.doc().unwrap().world_bounds(c).unwrap();
assert_eq!((b.center().x, b.center().y), (5000.0, 3000.0));
}
#[test]
fn paste_into_a_selected_far_frame_lands_at_its_centre() {
let mut s = Session::new();
copied_rect(&mut s);
let f = id(&s.execute("frame.create", &json!({"x": 2000, "y": 1000, "width": 300, "height": 300})).unwrap());
s.execute("select.set", &json!({"ids": [f]})).unwrap();
let c = pasted(&mut s);
assert_eq!(s.doc().unwrap().node(c).unwrap().parent, Some(f));
let b = s.doc().unwrap().world_bounds(c).unwrap();
assert_eq!((b.center().x, b.center().y), (2150.0, 1150.0));
}
#[test]
fn paste_into_a_selected_frame_holding_the_original_keeps_its_place() {
let mut s = Session::new();
copied_rect(&mut s);
let f = id(&s.execute("frame.create", &json!({"x": 0, "y": 0, "width": 500, "height": 500})).unwrap());
s.execute("select.set", &json!({"ids": [f]})).unwrap();
let c = pasted(&mut s);
assert_eq!(s.doc().unwrap().node(c).unwrap().parent, Some(f));
let b = s.doc().unwrap().world_bounds(c).unwrap();
assert_eq!((b.x0, b.y0), (100.0, 100.0));
}
crates/engine/src/devfocus_tests.rs
+9 -3
View File
@@ -84,14 +84,20 @@ fn only_the_focused_frame_is_hit_and_escape_leaves() {
click(&mut s, 75.0, 75.0);
assert_eq!(s.selection(), vec![in_a], "the layer on top of it isn't hit either");
assert_ne!(s.selection(), vec![over]);
// Escape: selection up to the frame, then out of the focus view.
// Escape: the selection goes, then out of the focus view.
s.escape().unwrap();
assert_eq!(s.selection(), vec![a]);
assert!(s.selection().is_empty(), "Escape selects nothing, not the parent frame");
assert_eq!(focused(&s), Some(a));
s.escape().unwrap();
assert_eq!(focused(&s), None, "Escape with the frame selected leaves");
assert_eq!(focused(&s), None, "Escape with nothing selected leaves");
click(&mut s, 350.0, 100.0);
assert_eq!(s.selection(), vec![b], "everything is hit again");
// With the focused frame itself selected, one Escape leaves the focus view.
ex(&mut s, "dev.focus", json!({"id": a}));
ex(&mut s, "select.set", json!({"ids": [a]}));
assert_eq!(focused(&s), Some(a));
s.escape().unwrap();
assert_eq!(focused(&s), None, "Escape with the focused frame selected leaves at once");
}
#[test]
crates/engine/src/export_behaviour_tests.rs
+14
View File
@@ -384,3 +384,17 @@ fn copy_as_png_svg_and_code() {
let css = crate::codegen::code_for(doc, a, crate::codegen::CodeLang::Css);
assert!(css.contains("background: #FF0000;"), "Copy as CSS is the layer's CSS from Inspect");
}
#[test]
fn export_rejects_an_invalid_layer_id_instead_of_exporting_the_page() {
let mut s = Session::new();
let r = rect(&mut s, 0.0, 0.0, 10.0, 10.0, "#ff0000", None);
ex(&mut s, "export.add", json!({"ids": [r]}));
for cmd in ["file.export", "file.exportLayers"] {
for p in [json!({"ids": ["abc"], "format": "svg"}), json!({"id": "abc", "format": "svg"}), json!({"ids": [], "id": "abc", "format": "svg"})] {
let res = s.execute(cmd, &p);
assert!(res.is_err(), "{cmd} {p} exported for an invalid id: {res:?}");
}
}
assert!(s.execute("file.export", &json!({"format": "svg"})).is_ok());
}
crates/engine/src/extensions/widgets.rs
+45 -3
View File
@@ -41,6 +41,8 @@ const FIELD: &str = "figcraft.widget.field";
const HOVER: &str = "figcraft.widget.hover";
/// Images in a widget are at most this many pixels on a side.
const MAX_IMAGE_SIDE: u32 = 4096;
/// All images of one widget together are at most this many pixels once decoded (four of the largest).
const MAX_IMAGES_PIXELS: u64 = 4 * 4096 * 4096;
/// Whether `n` is a widget's own layer.
pub fn is_widget(n: &Node) -> bool {
@@ -259,8 +261,9 @@ fn build(s: &mut Session, plugin: &str, w: NodeId, r: &WidgetRender) -> Result<(
_ => n.plugin_data.remove(MENU),
};
set_hover(n, r.root.hover.as_ref());
let mut pixels = 0;
for c in &r.root.children {
add(doc, w, c, cmd)?;
add(doc, w, c, cmd, &mut pixels)?;
}
// An SVG brings as many layers as it describes.
if doc.subtree(w).len() > MAX_NODES {
@@ -271,7 +274,7 @@ fn build(s: &mut Session, plugin: &str, w: NodeId, r: &WidgetRender) -> Result<(
}
/// Add layer `d` (and what it holds) inside `parent`, locked.
fn add(doc: &mut Document, parent: NodeId, d: &WidgetNode, cmd: &str) -> Result<()> {
fn add(doc: &mut Document, parent: NodeId, d: &WidgetNode, cmd: &str, pixels: &mut u64) -> Result<()> {
let (kind, name) = match d.kind {
WidgetKind::Frame => (NodeKind::Frame, "Frame"),
WidgetKind::Text => (NodeKind::Text(TextData { characters: d.text.clone(), ..TextData::default() }), "Text"),
@@ -292,6 +295,16 @@ fn add(doc: &mut Document, parent: NodeId, d: &WidgetNode, cmd: &str) -> Result<
if bytes.len() > MAX_IMAGE_BYTES {
return Err(bad(cmd, format!("an image is larger than {} KB", MAX_IMAGE_BYTES / 1024)));
}
// From the header, before anything is decoded: a small file can hold billions of pixels.
if let Some((w, h)) = figcraft_render::images::dimensions(&bytes) {
if w > MAX_IMAGE_SIDE || h > MAX_IMAGE_SIDE {
return Err(bad(cmd, format!("an image is larger than {MAX_IMAGE_SIDE} pixels on a side")));
}
*pixels += u64::from(w) * u64::from(h);
if *pixels > MAX_IMAGES_PIXELS {
return Err(bad(cmd, format!("the images are larger than {MAX_IMAGES_PIXELS} pixels together")));
}
}
let (hash, iw, ih) = crate::cmd::create::add_readable_image(doc, bytes).map_err(|e| bad(cmd, e))?;
if iw > MAX_IMAGE_SIDE || ih > MAX_IMAGE_SIDE {
return Err(bad(cmd, format!("an image is larger than {MAX_IMAGE_SIDE} pixels on a side")));
@@ -302,7 +315,7 @@ fn add(doc: &mut Document, parent: NodeId, d: &WidgetNode, cmd: &str) -> Result<
}
doc.insert(n, parent, None)?;
crate::cmd::props::apply(cmd, doc, id, &props(d, false))?;
d.children.iter().try_for_each(|c| add(doc, id, c, cmd))
d.children.iter().try_for_each(|c| add(doc, id, c, cmd, pixels))
}
/// Add SVG layer `d` inside `parent`: a frame of the picture's own size holding its layers, locked
@@ -604,3 +617,32 @@ pub fn specs() -> Vec<CommandSpec> {
spec!("widget.list", "List widgets", "{} → {widgets: [{id, plugin, name, page, state, targets, fields, menu}]}", false, list),
]
}
#[cfg(test)]
mod pixel_budget_tests {
use super::*;
use base64::Engine as _;
/// A `side` x `side` blank PNG (a few KB however many pixels).
fn png(side: u32) -> String {
let pix = figcraft_render::Pixmap::new(side, side).unwrap();
base64::engine::general_purpose::STANDARD.encode(figcraft_render::encode_png(&pix).unwrap())
}
#[test]
fn images_of_a_widget_share_a_decoded_pixel_budget() {
let mut doc = Document::new("t");
let page = doc.first_page().unwrap();
let data = png(4096);
let image = |i: usize| serde_json::from_value::<WidgetNode>(json!({"type": "image", "name": format!("I{i}"), "data": data})).unwrap();
let mut pixels = 0;
for i in 0..4 {
add(&mut doc, page, &image(i), "widget.insert", &mut pixels).unwrap();
}
let err = add(&mut doc, page, &image(4), "widget.insert", &mut pixels).unwrap_err().to_string();
assert!(err.contains("together"), "{err}");
// A header past the side limit is refused before it is decoded.
let wide = serde_json::from_value::<WidgetNode>(json!({"type": "image", "data": png(4097)})).unwrap();
assert!(add(&mut doc, page, &wide, "widget.insert", &mut 0).unwrap_err().to_string().contains("pixels on a side"));
}
}
crates/engine/src/import_export_tests.rs
+1 -1
View File
@@ -283,7 +283,7 @@ fn export_sizes_parse_and_label() {
assert_eq!(ExportSize::parse(text), Some(want), "{text}");
assert_eq!(ExportSize::parse(&want.label()), Some(want));
}
for bad in ["", "x", "0x", "-1x", "NaNx", "infx", "65x", "20000w", "2q", "2xx"] {
for bad in ["", "x", "0x", "-1x", "NaNx", "infx", "65x", "20000w", "2q", "2xx", "+2x", "+512w", "2e0x", "2E0x", "+0.5x"] {
assert_eq!(ExportSize::parse(bad), None, "{bad}");
}
let e = |size, suffix: &str, format| ExportSetting { size, suffix: suffix.into(), format, ..Default::default() };
crates/engine/src/lib.rs
+2
View File
@@ -213,6 +213,8 @@ mod board_connector_tests;
#[cfg(test)]
mod board_grid_tests;
#[cfg(test)]
mod board_mindmap_tests;
#[cfg(test)]
mod board_reshape_tests;
#[cfg(test)]
mod board_table_paste_tests;
crates/engine/src/paint_tests.rs
+10
View File
@@ -135,6 +135,16 @@ fn image_adjust_refuses_what_it_cannot_do() {
assert_eq!(s.execute("image.adjust", &json!({"ids": [plain, r], "index": 1, "preset": "vivid"})).unwrap()["changed"], 1);
}
#[test]
fn save_preset_rejects_bad_index() {
let mut s = Session::new();
let r = image_rect(&mut s);
assert!(s.execute("image.savePreset", &json!({"ids": [r], "name": "B", "index": 0})).is_err());
assert!(s.execute("image.savePreset", &json!({"ids": [r], "name": "B", "index": -1})).is_err(), "negative index accepted");
assert!(s.execute("image.savePreset", &json!({"ids": [r], "name": "B", "index": 1.5})).is_err(), "fractional index accepted");
assert!(s.execute("image.savePreset", &json!({"ids": [r], "name": "B", "index": 1})).is_ok());
}
#[test]
fn saved_image_presets() {
let mut s = Session::new();
crates/engine/src/panels_behaviour_tests.rs
+16
View File
@@ -200,6 +200,22 @@ fn reparent_index_is_the_final_position_in_auto_layout_and_across_parents() {
assert!(kids(&s, row).is_empty());
}
#[test]
fn reparent_rejects_a_negative_or_fractional_index() {
let mut s = Session::new();
let frame = id(&ex(&mut s, "node.create", json!({"type": "frame", "name": "F"})));
let rect = |s: &mut Session, n: &str, parent: NodeId| id(&ex(s, "node.create", json!({"type": "rectangle", "name": n, "parent": parent})));
let (a, b) = (rect(&mut s, "a", frame), rect(&mut s, "b", frame));
let free = id(&ex(&mut s, "node.create", json!({"type": "rectangle", "name": "free"})));
for bad in [json!(-1), json!(1.5), json!("x")] {
let r = s.execute("node.reparent", &json!({"ids": [free], "parent": frame, "index": bad}));
assert!(r.is_err(), "index {bad} accepted");
assert_eq!(kids(&s, frame), [a, b], "the tree is unchanged for index {bad}");
}
ex(&mut s, "node.reparent", json!({"ids": [free], "parent": frame, "index": 0}));
assert_eq!(kids(&s, frame), [free, a, b]);
}
#[test]
fn renaming_several_layers_by_the_documented_codes() {
// Three layers named `names`, bottom to top; (names, params, new names, derivation).
crates/engine/src/selection_behaviour_tests.rs
+17 -5
View File
@@ -271,14 +271,26 @@ fn keyboard_selection() {
ex(&mut s, cmd, json!({}));
assert_eq!(sorted(s.selection()), sorted(after), "{why}");
}
// Esc steps out to the parent, then deselects.
// Esc clears the selection at once, whatever the nesting (measured in Figma).
ex(&mut s, "select.set", json!({"ids": [k.a]}));
s.escape().unwrap();
assert_eq!(s.selection(), vec![k.g], "Esc selects the parent");
assert_eq!(s.selection(), Vec::<NodeId>::new(), "Esc from a nested layer selects nothing, not the parent");
s.escape().unwrap();
assert_eq!(s.selection(), vec![k.f]);
s.escape().unwrap();
assert_eq!(s.selection(), Vec::<NodeId>::new(), "Esc on a top-level layer deselects");
assert_eq!(s.selection(), Vec::<NodeId>::new());
// A top-level layer, and several layers, nested or not: one Esc selects nothing.
let cases: Vec<(Vec<NodeId>, &str)> = vec![
(vec![k.f], "a top-level frame"),
(vec![k.r], "a top-level layer"),
(vec![k.a, k.b], "two layers in one group (not their group)"),
(vec![k.a, k.d], "layers in different parents (not the parents)"),
(vec![k.a, k.r], "a nested layer and a top-level one"),
];
for (ids, why) in cases {
ex(&mut s, "select.set", json!({"ids": ids}));
assert_eq!(sorted(s.selection()), sorted(ids.clone()), "{why}: selected");
s.escape().unwrap();
assert_eq!(s.selection(), Vec::<NodeId>::new(), "Esc on {why} selects nothing");
}
}
#[test]
crates/engine/src/slot_tests.rs
+259
View File
@@ -376,6 +376,265 @@ fn slots_of_nested_instances_fill_from_the_outer_main_and_its_instances() {
assert_eq!(fill(&s, *kids(&s, nslot).first().unwrap()), "CCCCCC", "content no longer follows the Card main");
}
/// Wrap a component instance in another main, keeping the nested instance addressable.
fn slot_text_wrapper(s: &mut Session, component: NodeId, name: &str) -> (NodeId, NodeId) {
let frame = idv(&ex(s, "frame.create", json!({"width": 300, "height": 200, "name": name})));
let nested = idv(&ex(s, "instance.create", json!({"component": component, "parent": frame})));
(idv(&ex(s, "component.create", json!({"ids": [frame]}))), nested)
}
/// Content.Label binds Text; Composition holds Base, whose Body uses default or own Content.
/// Returns (Content main, Label, Base main, Composition main, nested Content instance).
fn slot_text_composition(s: &mut Session, own: bool) -> (NodeId, NodeId, NodeId, NodeId, NodeId) {
let frame = idv(&ex(s, "frame.create", json!({"width": 100, "height": 40, "name": "Content"})));
let label = idv(&ex(s, "text.create", json!({"text": "Default", "parent": frame, "props": {"name": "Label"}})));
let content = idv(&ex(s, "component.create", json!({"ids": [frame]})));
ex(s, "component.addProperty", json!({"id": content, "name": "Text", "type": "text", "default": "Default", "layer": label}));
let frame = idv(&ex(s, "frame.create", json!({"width": 200, "height": 100, "name": "Base"})));
let body = idv(&ex(s, "frame.create", json!({"width": 180, "height": 80, "name": "Body", "parent": frame})));
let default = (!own).then(|| idv(&ex(s, "instance.create", json!({"component": content, "parent": body}))));
let base = idv(&ex(s, "component.create", json!({"ids": [frame]})));
ex(s, "component.makeSlot", json!({"id": body}));
let (composition, nested_base) = slot_text_wrapper(s, base, "Composition");
let nested_content = if let Some(default) = default {
copy_of(s, nested_base, default)
} else {
idv(&ex(s, "instance.slotInsert", json!({"id": nested_base, "slot": "Body", "component": content})))
};
(content, label, base, composition, nested_content)
}
fn assert_slot_text(s: &mut Session, instance: NodeId, expected: &str) {
let children = kids(s, instance);
assert_eq!(children.len(), 1, "Content {instance} must have exactly one Label");
let label = children[0];
assert_eq!(node(s, label).name, "Label");
let characters = node(s, label).kind.text().expect("Content's only child must be text").characters.clone();
let html = ex(s, "inspect.code", json!({"id": instance, "language": "html"}))["code"].as_str().unwrap().to_string();
assert_eq!(characters, expected, "slot Label characters; HTML: {html}");
assert_eq!(html.matches("<p ").count(), 1, "slot Label HTML must contain exactly one paragraph: {html}");
assert_eq!(html.matches("</p>").count(), 1, "slot Label HTML must contain exactly one paragraph: {html}");
assert!(html.contains(&format!(">{expected}</p>")), "slot Label HTML: {html}");
}
fn assert_local_slot_text(s: &mut Session, instance: NodeId, expected: &str) {
assert!(
matches!(&node(s, instance).kind, NodeKind::Instance { props, .. } if props.get("Text") == Some(&json!(expected))),
"instance {instance} must store its own Text value {expected:?}: {:?}",
node(s, instance).kind
);
let properties = props_of(s, instance);
let text = properties.iter().find(|p| p["name"] == "Text").unwrap_or_else(|| panic!("instance {instance} has no Text property: {properties:?}"));
assert_eq!(text["value"], expected, "instance {instance} Text property");
}
/// Exercise the same ownership contract for default slot content and content supplied by the
/// Composition main; separate tests identify which route regresses.
fn check_slot_text_properties_stay_local(own: bool) {
let mut s = Session::new();
let (content, label, _base, composition, main_content) = slot_text_composition(&mut s, own);
let a = idv(&ex(&mut s, "instance.create", json!({"component": composition, "x": 400})));
let b = idv(&ex(&mut s, "instance.create", json!({"component": composition, "x": 800})));
let ac = copy_of(&s, a, main_content);
let bc = copy_of(&s, b, main_content);
ex(&mut s, "instance.setProperties", json!({"ids": [ac], "properties": {"Text": "Custom"}}));
assert_local_slot_text(&mut s, ac, "Custom");
assert_slot_text(&mut s, ac, "Custom");
assert_local_slot_text(&mut s, bc, "Default");
assert_slot_text(&mut s, bc, "Default");
assert_local_slot_text(&mut s, main_content, "Default");
assert_slot_text(&mut s, main_content, "Default");
assert_eq!(node(&s, label).kind.text().unwrap().characters, "Default");
// Main property edits propagate without replacing another instance's local value.
ex(&mut s, "instance.setProperties", json!({"ids": [main_content], "properties": {"Text": "Main value"}}));
assert_slot_text(&mut s, ac, "Custom");
assert_slot_text(&mut s, bc, "Main value");
assert_slot_text(&mut s, main_content, "Main value");
ex(&mut s, "component.editProperty", json!({"id": content, "name": "Text", "default": "New default"}));
assert_slot_text(&mut s, ac, "Custom");
assert_slot_text(&mut s, bc, "Main value");
assert_local_slot_text(&mut s, main_content, "Main value");
assert_slot_text(&mut s, main_content, "Main value");
healthy(&s);
}
#[test]
fn slot_text_properties_stay_local_in_default_content() {
check_slot_text_properties_stay_local(false);
}
#[test]
fn slot_text_properties_stay_local_in_own_content() {
check_slot_text_properties_stay_local(true);
}
#[test]
fn slot_text_properties_do_not_read_an_unbound_base_property() {
let mut s = Session::new();
let (_content, _label, base, composition, main_content) = slot_text_composition(&mut s, true);
ex(&mut s, "component.addProperty", json!({"id": base, "name": "Text", "type": "text", "default": "Wrong owner"}));
let i = idv(&ex(&mut s, "instance.create", json!({"component": composition, "x": 400})));
let nested_base = kids(&s, i)[0];
assert_local_slot_text(&mut s, nested_base, "Wrong owner");
let nested = copy_of(&s, i, main_content);
assert_local_slot_text(&mut s, nested, "Default");
assert_slot_text(&mut s, nested, "Default");
ex(&mut s, "instance.setProperties", json!({"ids": [nested], "properties": {"Text": "Custom"}}));
assert_local_slot_text(&mut s, nested, "Custom");
assert_slot_text(&mut s, nested, "Custom");
assert_local_slot_text(&mut s, nested_base, "Wrong owner");
assert_slot_text(&mut s, main_content, "Default");
healthy(&s);
}
#[test]
fn slot_text_properties_survive_inherited_own_content_and_persistence() {
let mut s = Session::new();
let (_content, _label, _base, composition, main_content) = slot_text_composition(&mut s, true);
let (outer, inherited) = slot_text_wrapper(&mut s, composition, "Outer composition");
let inherited_content = copy_of(&s, inherited, main_content);
let a = idv(&ex(&mut s, "instance.create", json!({"component": outer, "x": 400})));
let b = idv(&ex(&mut s, "instance.create", json!({"component": outer, "x": 800})));
let ac = copy_of(&s, a, inherited_content);
let bc = copy_of(&s, b, inherited_content);
ex(&mut s, "instance.setProperties", json!({"ids": [ac], "properties": {"Text": "Custom"}}));
assert_local_slot_text(&mut s, ac, "Custom");
assert_local_slot_text(&mut s, bc, "Default");
assert_local_slot_text(&mut s, inherited_content, "Default");
assert_local_slot_text(&mut s, main_content, "Default");
let bytes = figcraft_format::save_bytes(s.doc().unwrap(), None).unwrap();
let (back, _) = figcraft_format::load_bytes(&bytes).unwrap();
let mut s = Session::with_document(back);
assert_local_slot_text(&mut s, ac, "Custom");
assert_slot_text(&mut s, ac, "Custom");
assert_slot_text(&mut s, bc, "Default");
assert_slot_text(&mut s, inherited_content, "Default");
assert_slot_text(&mut s, main_content, "Default");
// Explicit characters override the bound property, even after a main update.
let alabel = kids(&s, ac)[0];
ex(&mut s, "text.set", json!({"id": alabel, "characters": "Explicit"}));
ex(&mut s, "instance.setProperties", json!({"ids": [ac], "properties": {"Text": "Later"}}));
ex(&mut s, "instance.setProperties", json!({"ids": [main_content], "properties": {"Text": "Main value"}}));
assert_local_slot_text(&mut s, ac, "Later");
assert_slot_text(&mut s, ac, "Explicit");
assert_slot_text(&mut s, bc, "Main value");
ex(&mut s, "component.resetOverride", json!({"id": alabel, "group": "characters"}));
assert_slot_text(&mut s, ac, "Later");
s.undo().unwrap();
assert_slot_text(&mut s, ac, "Explicit");
healthy(&s);
}
/// Check both the stored property and the Label it drives, not just one representation.
fn assert_slot_visibility(s: &mut Session, instance: NodeId, expected: bool) {
assert!(
matches!(&node(s, instance).kind, NodeKind::Instance { props, .. } if props.get("Visible") == Some(&json!(expected))),
"instance {instance} must store Visible={expected}: {:?}",
node(s, instance).kind
);
let properties = props_of(s, instance);
let visible =
properties.iter().find(|p| p["name"] == "Visible").unwrap_or_else(|| panic!("instance {instance} has no Visible property: {properties:?}"));
assert_eq!(visible["value"], expected, "instance {instance} Visible property");
let children = kids(s, instance);
assert_eq!(children.len(), 1, "Content {instance} must have exactly one Label");
assert_eq!(node(s, children[0]).name, "Label");
assert_eq!(node(s, children[0]).visible, expected, "instance {instance} Label visibility");
}
#[test]
fn slot_boolean_properties_stay_local_in_inherited_own_content() {
let mut s = Session::new();
let (content, label, base, composition, main_content) = slot_text_composition(&mut s, true);
ex(&mut s, "component.addProperty", json!({"id": content, "name": "Visible", "type": "boolean", "default": true, "layer": label}));
ex(&mut s, "component.addProperty", json!({"id": base, "name": "Visible", "type": "boolean", "default": false}));
let (outer, inherited) = slot_text_wrapper(&mut s, composition, "Outer composition");
let inherited_base = kids(&s, inherited)[0];
let inherited_content = copy_of(&s, inherited, main_content);
let a = idv(&ex(&mut s, "instance.create", json!({"component": outer, "x": 400})));
let b = idv(&ex(&mut s, "instance.create", json!({"component": outer, "x": 800})));
let ac = copy_of(&s, a, inherited_content);
let bc = copy_of(&s, b, inherited_content);
let abase = copy_of(&s, a, inherited_base);
assert!(matches!(&node(&s, abase).kind, NodeKind::Instance { props, .. } if props.get("Visible") == Some(&json!(false))));
assert_slot_visibility(&mut s, ac, true);
assert_slot_visibility(&mut s, bc, true);
ex(&mut s, "instance.setProperties", json!({"ids": [ac], "properties": {"Visible": false}}));
assert_slot_visibility(&mut s, ac, false);
assert_slot_visibility(&mut s, bc, true);
assert_slot_visibility(&mut s, inherited_content, true);
assert_slot_visibility(&mut s, main_content, true);
// A main update must not replace either instance's local value with the Base's homonym.
ex(&mut s, "instance.setProperties", json!({"ids": [main_content], "properties": {"Visible": false}}));
assert_slot_visibility(&mut s, ac, false);
assert_slot_visibility(&mut s, bc, false);
ex(&mut s, "instance.setProperties", json!({"ids": [bc], "properties": {"Visible": true}}));
ex(&mut s, "node.set", json!({"id": content, "props": {"fill": "#abcdef"}}));
assert_slot_visibility(&mut s, ac, false);
assert_slot_visibility(&mut s, bc, true);
assert_slot_visibility(&mut s, main_content, false);
healthy(&s);
let bytes = figcraft_format::save_bytes(s.doc().unwrap(), None).unwrap();
let (back, _) = figcraft_format::load_bytes(&bytes).unwrap();
let mut s = Session::with_document(back);
assert_slot_visibility(&mut s, ac, false);
assert_slot_visibility(&mut s, bc, true);
assert_slot_visibility(&mut s, inherited_content, false);
assert_slot_visibility(&mut s, main_content, false);
ex(&mut s, "instance.setProperties", json!({"ids": [main_content], "properties": {"Visible": true}}));
assert_slot_visibility(&mut s, ac, false);
assert_slot_visibility(&mut s, bc, true);
assert_slot_visibility(&mut s, main_content, true);
healthy(&s);
}
#[test]
fn same_component_in_own_slot_keeps_independent_text_properties() {
let mut s = Session::new();
let frame = idv(&ex(&mut s, "frame.create", json!({"width": 200, "height": 100, "name": "Card"})));
let label = idv(&ex(&mut s, "text.create", json!({"text": "Default", "parent": frame, "props": {"name": "Label"}})));
let body = idv(&ex(&mut s, "frame.create", json!({"width": 180, "height": 60, "y": 40, "name": "Body", "parent": frame})));
let card = idv(&ex(&mut s, "component.create", json!({"ids": [frame]})));
ex(&mut s, "component.addProperty", json!({"id": card, "name": "Text", "type": "text", "default": "Default", "layer": label}));
ex(&mut s, "component.makeSlot", json!({"id": body}));
// Only page instance content holds another Card: the main never contains itself.
let outer = idv(&ex(&mut s, "instance.create", json!({"component": card, "x": 400})));
let inner = idv(&ex(&mut s, "instance.slotInsert", json!({"id": outer, "slot": "Body", "component": card})));
let check = |s: &mut Session, outer_text: &str, inner_text: &str| {
assert_local_slot_text(s, outer, outer_text);
assert_local_slot_text(s, inner, inner_text);
assert_eq!(node(s, copy_of(s, outer, label)).kind.text().unwrap().characters, outer_text);
assert_eq!(node(s, copy_of(s, inner, label)).kind.text().unwrap().characters, inner_text);
let outer_body = copy_of(s, outer, body);
assert!(slot_edited(s.doc().unwrap(), outer_body));
assert_eq!(kids(s, outer_body), vec![inner]);
assert!(kids(s, copy_of(s, inner, body)).is_empty());
assert!(kids(s, body).is_empty(), "the main's slot must remain empty");
healthy(s);
};
ex(&mut s, "instance.setProperties", json!({"ids": [outer], "properties": {"Text": "Outer"}}));
check(&mut s, "Outer", "Default");
ex(&mut s, "instance.setProperties", json!({"ids": [inner], "properties": {"Text": "Inner"}}));
check(&mut s, "Outer", "Inner");
ex(&mut s, "text.set", json!({"id": label, "characters": "New default"}));
ex(&mut s, "node.set", json!({"id": card, "props": {"fill": "#abcdef"}}));
check(&mut s, "Outer", "Inner");
assert_eq!(fill(&s, outer), "ABCDEF");
assert_eq!(fill(&s, inner), "ABCDEF");
ex(&mut s, "instance.setProperties", json!({"ids": [outer], "properties": {"Text": "Outer updated"}}));
check(&mut s, "Outer updated", "Inner");
ex(&mut s, "instance.setProperties", json!({"ids": [inner], "properties": {"Text": "Inner updated"}}));
check(&mut s, "Outer updated", "Inner updated");
let bytes = figcraft_format::save_bytes(s.doc().unwrap(), None).unwrap();
let (back, _) = figcraft_format::load_bytes(&bytes).unwrap();
let mut s = Session::with_document(back);
check(&mut s, "Outer updated", "Inner updated");
ex(&mut s, "node.set", json!({"id": card, "props": {"fill": "#123456"}}));
check(&mut s, "Outer updated", "Inner updated");
assert_eq!(fill(&s, outer), "123456");
assert_eq!(fill(&s, inner), "123456");
}
/// Random slot edits, main edits and resets keep every instance mirroring its main.
#[test]
fn random_slot_edits_keep_instances_consistent() {
crates/engine/src/text_tail_tests.rs
+111 -1
View File
@@ -84,7 +84,11 @@ fn typed_list_starts() {
("- ", "", B, "hyphen and space: bullets"),
("* ", "", B, "asterisk and space: bullets"),
("1. ", "", N, "one, full stop, space: numbers"),
("2. ", "2. ", P, "silent: only 1. starts a numbered list"),
("2. ", "", N, "as measured in Figma: a typed number starts the list there"),
("0. ", "0. ", P, "zero is not measured: text"),
("12a. ", "12a. ", P, "digits only: text"),
("1) ", "", N, "one and a closing bracket: numbers"),
("2) ", "2) ", P, "silent: only 1) starts with a bracket"),
("a- ", "a- ", P, "not at the paragraph's start: text"),
("-x ", "-x ", P, "the space must follow the marker"),
];
@@ -108,6 +112,76 @@ fn typed_list_starts() {
assert_eq!((data(&s, t).characters.as_str(), lists(&s, t)), ("Intro\n- ", vec![(P, 0), (B, 0)]), "an item's own text stays text");
}
#[test]
fn typed_number_starts_the_list_there() {
// As measured in Figma (2026-11-11): typing "5. x", Enter, "y" reads 5. then 6.; the start
// is the typed number less one, and the next item goes on counting from it.
let mut s = Session::new();
let t = text(&mut s, "x");
s.execute("node.set", &json!({"id": t, "props": {"characters": ""}})).unwrap();
begin(&mut s, t, Some(0), false).unwrap();
for c in "5. x".chars() {
insert(&mut s, &c.to_string()).unwrap();
}
assert_eq!(data(&s, t).para_list(0).start_offset, 4, "5 starts at offset 4");
key(&mut s, "Enter", false, false, false).unwrap();
insert(&mut s, "y").unwrap();
crate::textedit::end(&mut s).unwrap();
let d = data(&s, t);
assert_eq!(d.characters, "x\ny");
assert_eq!(lists(&s, t), [(N, 0), (N, 0)]);
// An item made by Enter has no start of its own and goes on counting: 5. then 6.
assert_eq!((d.para_list(0).start_offset, d.para_list(1).start_offset), (4, 0), "the new item has no start");
s.undo().unwrap();
assert_eq!(data(&s, t).characters, "", "one undo step for the session");
assert_eq!(data(&s, t).para_list(0).start_offset, 0);
}
/// Type `first` ("5. a" style), then Enter, "b", Enter, "c", leaving the caret in "c".
fn three_typed_items(s: &mut Session, first: &str) -> NodeId {
let t = text(s, "x");
s.execute("node.set", &json!({"id": t, "props": {"characters": ""}})).unwrap();
begin(s, t, Some(0), false).unwrap();
for c in first.chars() {
insert(s, &c.to_string()).unwrap();
}
for step in ["Enter", "b", "Enter", "c"] {
if step == "Enter" {
key(s, step, false, false, false).unwrap();
} else {
insert(s, step).unwrap();
}
}
t
}
#[test]
fn a_list_split_by_unlisting_a_middle_item_restarts_at_one() {
// As measured in Figma (2026-11-11): typed "5. a", Enter, "b", Enter, "c" reads 5. 6. 7.;
// Backspace at the start of "b" takes its marker and "c" then reads 1., for "1. " too.
// `list_markers` counts on after a numbered item and restarts a numbered item that follows a
// plain paragraph at its own start, so the starts and the neighbours give the markers.
for (first, start) in [("5. a", 4), ("1. a", 0)] {
let mut s = Session::new();
let t = three_typed_items(&mut s, first);
assert_eq!(
data(&s, t).characters,
"a
b
c"
);
// The guard: unsplit, "b" and "c" go on counting (5. 6. 7.).
let d = data(&s, t);
assert_eq!(lists(&s, t), [(N, 0); 3], "{first}: no split");
assert_eq!((d.para_list(0).start_offset, d.para_list(1).start_offset, d.para_list(2).start_offset), (start, 0, 0), "{first}");
set_caret(&mut s, 2, false).unwrap();
key(&mut s, "Backspace", false, false, false).unwrap();
let d = data(&s, t);
assert_eq!(lists(&s, t), [(N, 0), (P, 0), (N, 0)], "{first}: split");
assert_eq!(d.para_list(2).start_offset, 0, "{first}: c restarts at 1 (the item made by Enter has no start)");
}
}
#[test]
fn list_keys_at_list_items() {
// (chars, lists before, caret, key, shift, chars after, lists after, derivation)
@@ -372,3 +446,39 @@ fn typing_a_creation_character_and_a_space_starts_a_list() {
}
assert_eq!((data(&s, t).characters.as_str(), lists(&s, t)), ("2) ", vec![(P, 0)]));
}
#[test]
fn splitting_a_plain_paragraph_that_kept_its_level_keeps_the_level() {
// Backspace at a nested item's start unlists it but keeps indent 1; Enter inside it then
// splits it, and neither half loses the level (the start reset changes only starts).
let mut s = Session::new();
let t = text(&mut s, "ab\ncd");
let ps = vec![ParaList { list: N, start_offset: 4, ..ParaList::default() }, ParaList { list: N, indent: 1, ..ParaList::default() }];
if let figcraft_doc::NodeKind::Text(td) = &mut s.doc_mut().unwrap().get_mut(t).unwrap().kind {
td.paragraphs = ps;
}
begin(&mut s, t, Some(3), false).unwrap();
key(&mut s, "Backspace", false, false, false).unwrap();
assert_eq!(lists(&s, t), [(N, 0), (P, 1)], "unlisted, level kept");
set_caret(&mut s, 4, false).unwrap();
key(&mut s, "Enter", false, false, false).unwrap();
assert_eq!(data(&s, t).characters, "ab\nc\nd");
assert_eq!(lists(&s, t), [(N, 0), (P, 1), (P, 1)], "both halves keep indent 1");
}
#[test]
fn a_many_line_paste_clears_every_created_start() {
let mut s = Session::new();
let t = text(&mut s, "x");
s.execute("node.set", &json!({"id": t, "props": {"characters": ""}})).unwrap();
begin(&mut s, t, Some(0), false).unwrap();
for c in "5. x".chars() {
insert(&mut s, &c.to_string()).unwrap();
}
let lines: Vec<String> = (0..2001).map(|i| format!("l{i}")).collect();
insert(&mut s, &lines.join("\n")).unwrap();
let d = data(&s, t);
assert_eq!(d.paragraph_count(), 2001);
assert_eq!(d.para_list(0).start_offset, 4, "the first item keeps its start");
assert!((1..d.paragraph_count()).all(|p| d.para_list(p).start_offset == 0 && d.para_list(p).list == N));
}
crates/engine/src/vector_behaviour_tests.rs
+52
View File
@@ -326,6 +326,58 @@ fn ex_to_vector(doc: &mut figcraft_doc::Document, id: NodeId) {
doc.get_mut(id).unwrap().kind = NodeKind::Vector { network };
}
/// How far `path` strays from `from`: the largest distance from a point sampled along `path` to
/// the nearest segment of `from`.
pub(crate) fn strays(path: &BezPath, from: &BezPath) -> f64 {
use figcraft_geom::kurbo::ParamCurveNearest;
let segs: Vec<_> = from.segments().collect();
path.segments()
.flat_map(|seg| (0..=32).map(move |i| seg.eval(f64::from(i) / 32.0)))
.map(|p| segs.iter().map(|s| s.nearest(p, 1e-6).distance_sq).fold(f64::INFINITY, f64::min).sqrt())
.fold(0.0, f64::max)
}
/// Simplify path keeps nearly collinear points, and a stroke that goes out and back, near where
/// they were: kurbo's fit, which Simplify path and the Pencil share, ran a handle hundreds of units
/// on along the line (#1741). That holds for each way the command simplifies a layer: an open
/// stroke, a filled shape, a region with its own fill, and a stroke beside a filled shape.
#[test]
fn simplify_keeps_nearly_collinear_points_near_them() {
// The points exactly as sampled.
let straight = "M209.5986907940155 -204.90932811973988 L211.27791426387097 -207.1909740207534 L214.24650682872084 -211.22882759062324";
let back =
"M80 -160 L86.04356571908697 -173.74440234910094 L87.85185073933535 -179.20284644595452 L86.04356571908697 -173.74440234910094 L95 -185";
let shape = format!("{straight} L260 -150 Z");
let cases = [
("an open stroke", straight.to_string(), false),
("a filled shape", shape.clone(), false),
("a region with its own fill", shape.clone(), true),
("a stroke beside a filled shape", format!("{shape} {back}"), false),
];
for (what, d, own_fill) in cases {
let mut s = Session::new();
let id = id_of(&ex(&mut s, "vector.create", json!({"path": "M0 0 L10 10"}))["id"]).unwrap();
// At the page origin, as given (`vector.create` would move the points).
let mut network = VectorNetwork::from_path(&BezPath::from_svg(&d).unwrap());
if own_fill {
network.regions[0].fills = Some(vec![figcraft_color::Paint::solid(figcraft_color::Color::from_hex("#FF0000").unwrap())]);
}
{
let n = s.doc_mut().unwrap().get_mut(id).unwrap();
n.transform = figcraft_geom::Affine::IDENTITY;
n.kind = NodeKind::Vector { network };
}
let before = net(&s, id);
ex(&mut s, "vector.simplify", json!({"ids": [id], "tolerance": 0.75}));
let after = s.doc().unwrap().world_transform(id) * net(&s, id).stroke_path();
let gone = strays(&after, &before.stroke_path());
assert!(gone <= 1.5, "{what}: strays {gone}: {}", after.to_svg());
let (b0, b1) = (before.stroke_path().bounding_box(), after.bounding_box());
assert!(b0.inflate(1.5, 1.5).contains_rect(b1), "{what}: {b1:?} past {b0:?}: {}", after.to_svg());
assert_eq!(net(&s, id).regions.len(), before.regions.len(), "{what}: the fill is kept");
}
}
fn ex(s: &mut Session, cmd: &str, p: Value) -> Value {
s.execute(cmd, &p).unwrap_or_else(|e| panic!("{cmd}: {e}"))
}
crates/format/src/fig/export/shape.rs
+3 -1
View File
@@ -207,7 +207,9 @@ impl<'d> Exporter<'d> {
.enumerate()
.map(|(i, v)| {
let mut st: Fields = Vec::new();
if v.radius > 0.0 {
// A point without a radius of its own is drawn with the layer's, so a sharp
// point on a rounded layer says so.
if v.radius > 0.0 || n.corners.radii[0] > 0.0 {
st.push(("cornerRadius", fl(v.radius)));
}
if let Some(m) = v.mirror {
crates/format/src/fig/export_tests.rs
+19
View File
@@ -955,6 +955,25 @@ fn closed_vector_geometry_is_written_with_its_corner_smoothing() {
assert_eq!(radii, vec![20.0, 0.0, 10.0, 0.0], "each point keeps its own radius");
}
#[test]
fn sharp_points_on_a_rounded_vector_stay_sharp() {
// A point without a radius takes the layer's when read, so a sharp point on a vector with a
// layer radius is written with its own zero.
let mut doc = Document::new("sharp point");
let page = doc.first_page().unwrap();
let mut network = VectorNetwork::from_points(&[(0.0, 0.0), (100.0, 0.0), (100.0, 100.0), (0.0, 100.0)].map(|(x, y)| Point::new(x, y)), true);
for (v, r) in network.vertices.iter_mut().zip([8.0, 0.0, 8.0, 0.0]) {
v.radius = r;
}
let id = doc.create(page, NodeKind::Vector { network }, "V", 0.0, 0.0, 100.0, 100.0).unwrap();
doc.node_mut(id).unwrap().corners.radii = [8.0; 4];
let (back, _) = round_trip(&doc, "sharp point");
let v = back.nodes().find(|n| matches!(n.kind, NodeKind::Vector { .. })).unwrap();
let NodeKind::Vector { network } = &v.kind else { panic!("vector") };
let radii: Vec<f64> = network.vertices.iter().map(|x| x.radius).collect();
assert_eq!(radii, vec![8.0, 0.0, 8.0, 0.0]);
}
#[test]
fn the_written_schema_parses_and_round_trips() {
let schema = Schema::parse(export::SCHEMA).unwrap();
crates/format/src/fig/map.rs
+3 -2
View File
@@ -356,8 +356,9 @@ struct Mapper<'a> {
/// holding it) name it by `vectorNetworkRef`. Kept out of the JSON, where a large file's
/// networks took gigabytes.
networks: Vec<Option<VectorNetwork>>,
/// Index in `networks` by its blob, position scale, style table and point-radius scale.
network_ids: HashMap<(usize, u64, u64, usize, u64), usize>,
/// Index in `networks` by its blob, position scale, style table, point-radius scale and the
/// layer's corner radius (which points without one of their own take).
network_ids: HashMap<(usize, u64, u64, usize, u64, u64), usize>,
/// Region paint elements (paints and gradient stops) read so far: one budget for the whole
/// file, since layers with region paints don't share their network.
region_paint_elements: usize,
crates/format/src/fig/map/layer.rs
+5 -2
View File
@@ -668,6 +668,8 @@ impl<'a> Mapper<'a> {
size.zip(norm).filter(|(s, n)| s.is_finite() && *n > 1e-9).map_or(1.0, |(s, n)| s / n)
};
let (sx, sy) = (scale("x"), scale("y"));
// A point whose style doesn't set a radius takes the layer's, as the editor draws it.
let layer_radius = v.len("cornerRadius");
let vertices: Vec<Value> = net
.vertices
.iter()
@@ -676,7 +678,7 @@ impl<'a> Mapper<'a> {
let st = style(p.style);
// Point radii are lengths in this row's space, unlike the normalized positions.
// An override/derived row already carries the instance's scale.
if let Some(r) = st.and_then(|s| num(s, "cornerRadius")).and_then(|r| scaled(r, radius_scale)).filter(|r| *r > 0.0) {
if let Some(r) = st.and_then(|s| num(s, "cornerRadius")).and_then(|r| scaled(r, radius_scale)).or(layer_radius).filter(|r| *r > 0.0) {
out["radius"] = json!(r);
}
match st.and_then(|s| s.get("handleMirroring")).and_then(Kv::str) {
@@ -793,7 +795,8 @@ impl<'a> Mapper<'a> {
return true;
}
// A resized instance and a K-scaled one can have the same box but different radii.
let key = (blob_id, sx.to_bits(), sy.to_bits(), std::ptr::from_ref(vd) as usize, radius_scale.to_bits());
let key =
(blob_id, sx.to_bits(), sy.to_bits(), std::ptr::from_ref(vd) as usize, radius_scale.to_bits(), layer_radius.unwrap_or(0.0).to_bits());
let id = match self.network_ids.get(&key) {
Some(id) => *id,
None => {
crates/format/src/fig/tail_tests.rs
+90
View File
@@ -521,6 +521,96 @@ fn network_of<'d>(doc: &'d figcraft_doc::Document, name: &str) -> &'d figcraft_d
}
}
#[test]
fn vector_points_without_a_radius_of_their_own_take_the_layers() {
// A vector rounded from the layer's corner radius: the editor rounds every point whose
// style doesn't set a radius (no style, or one without `cornerRadius`) with the layer's,
// while a point's own radius, zero included, wins.
let mut message = tail_message();
let Kv::Array(nodes) = field_mut(&mut message, "nodeChanges").unwrap() else { panic!() };
let wave = nodes.iter_mut().find(|node| node.get("name").and_then(Kv::str) == Some("Wave")).unwrap();
let Kv::Object(fields) = wave else { panic!() };
fields.push(("cornerRadius", f(6.0)));
let vector_data = field_mut(wave, "vectorData").unwrap();
let Kv::Array(styles) = field_mut(vector_data, "styleOverrideTable").unwrap() else { panic!() };
let Kv::Object(sharp) = styles.get_mut(2).unwrap() else { panic!() };
sharp.push(("cornerRadius", f(0.0)));
let (doc, _) = import(&canvas(&schema(), &message), "Rounded").unwrap();
let radii: Vec<f64> = network_of(&doc, "Wave").vertices.iter().map(|v| v.radius).collect();
assert_eq!(radii, [6.0, 4.0, 6.0, 0.0], "no style, own radius, style without one, own zero");
// Without a layer radius, the points without one of their own stay sharp.
let (doc, _) = import(&tail_canvas(), "Tail").unwrap();
let radii: Vec<f64> = network_of(&doc, "Wave").vertices.iter().map(|v| v.radius).collect();
assert_eq!(radii, [0.0, 4.0, 0.0, 0.0]);
}
#[test]
fn an_instance_that_rounds_a_vector_keeps_its_own_points() {
// An instance's copy shares its main's vector data; overriding the layer's radius must not
// reuse the main's network, nor hand the instance's to the main.
let mut message = tail_message();
let Kv::Array(nodes) = field_mut(&mut message, "nodeChanges").unwrap() else { panic!() };
let wave = nodes.iter_mut().find(|node| node.get("name").and_then(Kv::str) == Some("Wave")).unwrap();
*field_mut(wave, "parentIndex").unwrap() = o(vec![("guid", g(50)), ("position", s("!"))]);
*field_mut(wave, "transform").unwrap() = at(0.0, 0.0);
let rounded = o(vec![("guidPath", o(vec![("guids", arr(vec![g(30)]))])), ("cornerRadius", f(6.0))]);
nodes.push(node(50, Some((1, "~")), "SYMBOL", "Mark", vec![("size", xy(200.0, 100.0)), ("transform", at(700.0, 0.0))]));
nodes.push(node(
51,
Some((1, "~!")),
"INSTANCE",
"Rounded mark",
vec![
("size", xy(200.0, 100.0)),
("transform", at(700.0, 400.0)),
("symbolData", o(vec![("symbolID", g(50)), ("symbolOverrides", arr(vec![rounded]))])),
],
));
let (doc, _) = import(&canvas(&schema(), &message), "Instance").unwrap();
let radii_under = |parent: &str| -> Vec<f64> {
let p = named(&doc, parent);
let wave = p.children.iter().map(|c| doc.node(*c).unwrap()).find(|n| n.name == "Wave").unwrap();
let NodeKind::Vector { network } = &wave.kind else { panic!() };
network.vertices.iter().map(|v| v.radius).collect()
};
assert_eq!(radii_under("Mark"), [0.0, 4.0, 0.0, 0.0]);
assert_eq!(radii_under("Rounded mark"), [6.0, 4.0, 6.0, 6.0]);
}
#[test]
fn a_scaled_instance_scales_its_vectors_point_radii() {
// Point radii are lengths: an instance scaled with the Scale tool draws its main's, from a
// point's own style or from the layer, times the factor (#2091).
let mut message = tail_message();
let Kv::Array(nodes) = field_mut(&mut message, "nodeChanges").unwrap() else { panic!() };
let wave = nodes.iter_mut().find(|node| node.get("name").and_then(Kv::str) == Some("Wave")).unwrap();
*field_mut(wave, "parentIndex").unwrap() = o(vec![("guid", g(50)), ("position", s("!"))]);
*field_mut(wave, "transform").unwrap() = at(0.0, 0.0);
let Kv::Object(fields) = wave else { panic!() };
fields.push(("cornerRadius", f(3.0)));
nodes.push(node(50, Some((1, "~")), "SYMBOL", "Mark", vec![("size", xy(200.0, 100.0)), ("transform", at(700.0, 0.0))]));
nodes.push(node(
51,
Some((1, "~!")),
"INSTANCE",
"Big mark",
vec![
("size", xy(400.0, 200.0)),
("transform", at(700.0, 400.0)),
("symbolData", o(vec![("symbolID", g(50)), ("uniformScaleFactor", f(2.0))])),
],
));
let (doc, _) = import(&canvas(&schema(), &message), "Scaled").unwrap();
let radii_under = |parent: &str| -> Vec<f64> {
let p = named(&doc, parent);
let wave = p.children.iter().map(|c| doc.node(*c).unwrap()).find(|n| n.name == "Wave").unwrap();
let NodeKind::Vector { network } = &wave.kind else { panic!() };
network.vertices.iter().map(|v| v.radius).collect()
};
assert_eq!(radii_under("Mark"), [3.0, 4.0, 3.0, 3.0]);
assert_eq!(radii_under("Big mark"), [6.0, 8.0, 6.0, 6.0]);
}
#[test]
fn vectors_import_as_editable_networks() {
let (doc, warnings) = import(&tail_canvas(), "Tail").unwrap();
crates/geom/src/lib.rs
+2
View File
@@ -12,7 +12,9 @@ use kurbo::ParamCurve;
use std::f64::consts::{FRAC_PI_2, PI, TAU};
pub mod measure;
mod simplify;
mod transform;
pub use simplify::simplify_path;
pub use transform::*;
/// Corner radii in clockwise order from the top-left: `[tl, tr, br, bl]`.
crates/geom/src/simplify.rs
+140
View File
@@ -0,0 +1,140 @@
//! Path simplification that keeps to its input where kurbo's fit would shoot past it.
use kurbo::{BezPath, ParamCurve, ParamCurveNearest, PathEl, PathSeg, Point, Vec2};
/// How far, as a multiple of the accuracy asked for, a fitted run may stray from the run it
/// replaces before the run is kept as it was. kurbo's own fits stay within about the accuracy; its
/// failures stray by tens to hundreds of units, so twice the accuracy tells them apart without
/// undoing fits that are merely a little over.
const STRAY: f64 = 2.0;
/// `path` simplified to within `accuracy` by kurbo's [`simplify_bezpath`], kept from straying
/// far from `path` where kurbo's fit does.
///
/// Two inputs made kurbo's fit shoot far past the path it simplified (#1741, a Pencil stroke with
/// a spike off it), and both are common in pointer samples:
/// - A join where the path turns straight back (samples going down and back up the same line):
/// kurbo keeps two segments in one smooth fit when their tangents are parallel whichever way
/// they point (`|cross| <= |dot| * angle_thresh`), so it fits a smooth curve through the cusp.
/// The path is cut where it turns back by more than a right angle, each run between the cuts is
/// simplified on its own, and the runs are joined again, so the turn stays a sharp corner. Any
/// other join that isn't straight within kurbo's threshold is a corner to kurbo already, so the
/// cut changes nothing there.
/// - A run of nearly collinear segments: kurbo measures its error across the path, not along it, so
/// a fitted cubic whose handle runs hundreds of units on along the line passes its check. Each
/// fitted run is measured against the run it replaces, and one that strays more than
/// twice `accuracy` from it is kept as it was instead.
///
/// Subpaths and closes are kept, and a closing segment stays implicit, as kurbo leaves it.
///
/// [`simplify_bezpath`]: kurbo::simplify::simplify_bezpath
pub fn simplify_path(path: &BezPath, accuracy: f64) -> BezPath {
let mut out = BezPath::new();
let mut run = BezPath::new();
// Where the current subpath started, where the pen is, and the last segment's end tangent.
let mut start = Point::ZERO;
let mut at = Point::ZERO;
let mut last_tan: Option<Vec2> = None;
// Whether the next run that draws anything has to start the subpath with its move.
let mut fresh = true;
for el in path.elements() {
let seg = match *el {
PathEl::MoveTo(p) => {
flush(&mut out, &mut run, accuracy, &mut fresh);
(start, at, last_tan, fresh) = (p, p, None, true);
run.move_to(p);
continue;
}
PathEl::ClosePath => {
flush(&mut out, &mut run, accuracy, &mut fresh);
if !fresh {
out.close_path();
}
// A segment after a close starts a new subpath at the closed one's start.
(at, last_tan, fresh) = (start, None, true);
run.move_to(start);
continue;
}
PathEl::LineTo(p) => PathSeg::Line(kurbo::Line::new(at, p)),
PathEl::QuadTo(p1, p2) => PathSeg::Quad(kurbo::QuadBez::new(at, p1, p2)),
PathEl::CurveTo(p1, p2, p3) => PathSeg::Cubic(kurbo::CubicBez::new(at, p1, p2, p3)),
};
if run.elements().is_empty() {
run.move_to(at);
}
let Some((t0, t1)) = tangents(seg) else { continue };
if last_tan.is_some_and(|last| last.dot(t0) < 0.0) {
flush(&mut out, &mut run, accuracy, &mut fresh);
run.move_to(at);
}
run.push(*el);
at = seg.end();
last_tan = Some(t1);
}
flush(&mut out, &mut run, accuracy, &mut fresh);
out
}
/// Simplify `run` (one move and the segments after it) with kurbo and append it to `out`; the
/// run's move is kept only when it starts a subpath (`fresh`), else the run carries on from the
/// last point drawn. `run` is left empty.
fn flush(out: &mut BezPath, run: &mut BezPath, accuracy: f64, fresh: &mut bool) {
if run.elements().len() > 1 {
let fitted = kurbo::simplify::simplify_bezpath(run.iter(), accuracy, &Default::default());
let fitted = if keeps_to(&fitted, run, STRAY * accuracy) { fitted } else { std::mem::take(run) };
for el in fitted.elements() {
match el {
PathEl::MoveTo(_) if !*fresh => {}
_ => {
out.push(*el);
*fresh = false;
}
}
}
}
*run = BezPath::new();
}
/// Whether every point of `fitted` lies within `tol` of `source`: one subpath each, from the same
/// start to the same end, `fitted` being kurbo's simplification of `source`.
///
/// kurbo ends each fitted segment on the source, so the two are walked together: for each fitted
/// segment, the source segments from where it starts to the first one its end lies on are the only
/// ones its sample points are measured against. The work is linear in the two lengths. A fitted end
/// found on no source segment counts as straying.
fn keeps_to(fitted: &BezPath, source: &BezPath, tol: f64) -> bool {
/// Parts each fitted segment is cut into: the points between them are the ones measured.
const SAMPLES: u32 = 16;
let src: Vec<PathSeg> = source.segments().collect();
// kurbo puts each end on the source by evaluating it: off by rounding at most.
let on2 = (tol * 1e-3).powi(2);
let (tol2, mut cur) = (tol * tol, 0);
for seg in fitted.segments() {
let Some(last) = (cur..src.len()).find(|&i| src.get(i).is_some_and(|s| s.nearest(seg.end(), 1e-9).distance_sq <= on2)) else {
return false;
};
let near = src.get(cur..=last).unwrap_or_default();
for i in 1..SAMPLES {
let p = seg.eval(f64::from(i) / f64::from(SAMPLES));
if !near.iter().any(|s| s.nearest(p, 1e-6).distance_sq <= tol2) {
return false;
}
}
cur = last;
}
true
}
/// The directions `seg` leaves its start and reaches its end, skipping control points that sit on
/// an end; `None` for a segment of no length, which kurbo skips too.
fn tangents(seg: PathSeg) -> Option<(Vec2, Vec2)> {
let pts: Vec<Point> = match seg {
PathSeg::Line(l) => vec![l.p0, l.p1],
PathSeg::Quad(q) => vec![q.p0, q.p1, q.p2],
PathSeg::Cubic(c) => vec![c.p0, c.p1, c.p2, c.p3],
};
let (first, last) = (*pts.first()?, *pts.last()?);
let t0 = pts.iter().map(|p| *p - first).find(|d| d.hypot2() > 0.0)?;
let t1 = pts.iter().rev().map(|p| last - *p).find(|d| d.hypot2() > 0.0)?;
Some((t0, t1))
}
crates/geom/src/tests.rs
+274
View File
@@ -366,3 +366,277 @@ fn svg_path_refuses_numbers_past_the_limit_before_parsing() {
assert!(number_past("M0 0L-2.5.5 1e-3-4e3z", 1e3));
assert!(number_past("M.5.5e10", 1e3));
}
/// A path through `pts` with straight lines (pencil samples).
fn polyline(pts: &[(f64, f64)]) -> BezPath {
let mut p = BezPath::new();
for (k, (x, y)) in pts.iter().enumerate() {
if k == 0 { p.move_to((*x, *y)) } else { p.line_to((*x, *y)) }
}
p
}
/// How far `out` strays from `input`: the largest distance from a point sampled along `out` to the
/// nearest segment of `input` (closing segments included).
fn deviation(out: &BezPath, input: &BezPath) -> f64 {
use kurbo::{ParamCurve, ParamCurveNearest};
let segs: Vec<kurbo::PathSeg> = input.segments().collect();
out.segments()
.flat_map(|seg| (0..=32).map(move |i| seg.eval(f64::from(i) / 32.0)))
.map(|p| segs.iter().map(|s| s.nearest(p, 1e-6).distance_sq).fold(f64::INFINITY, f64::min).sqrt())
.fold(0.0, f64::max)
}
/// Pencil strokes kurbo's fit shot far past keep to their samples (#1741): a stroke that goes out
/// and back to the very point it left, nearly collinear samples, and strokes that turn back along
/// their own line. The first two are from fuzzing pencil-like strokes, where kurbo's curve went
/// about 390 and 160 units off; at whole-pixel coordinates the same shapes happened to fit well.
#[test]
fn simplifying_keeps_to_strokes_kurbo_shot_past() {
let cases: [(&str, &[(f64, f64)]); 5] = [
(
"out and back to the same point",
&[
(86.043_565_719_086_97, -173.744_402_349_100_94),
(87.851_850_739_335_35, -179.202_846_445_954_52),
(86.043_565_719_086_97, -173.744_402_349_100_94),
],
),
(
"nearly collinear",
&[
(209.598_690_794_015_5, -204.909_328_119_739_88),
(211.277_914_263_870_97, -207.190_974_020_753_4),
(214.246_506_828_720_84, -211.228_827_590_623_24),
],
),
(
"a dip straight down and back up",
&[(0.0, 0.0), (10.0, 0.0), (20.0, 2.0), (30.0, 6.0), (30.0, 12.0), (30.0, 6.0), (40.0, 2.0), (50.0, 0.0)],
),
("a slip back at the end", &[(0.0, 0.0), (10.0, 3.0), (20.0, 8.0), (30.0, 15.0), (30.0, 25.0), (30.0, 22.0)]),
(
"a near reversal in a curve",
&[(0.0, 0.0), (8.0, 2.0), (16.0, 6.0), (24.0, 12.0), (32.0, 20.0), (24.0, 12.000_01), (16.0, 6.0), (8.0, 2.0)],
),
];
for (what, pts) in cases {
keeps_to_one_stroke(what, &polyline(pts));
}
}
/// Accuracies the simplification is checked at: fine, the Pencil's, and coarse.
const ACCURACIES: [f64; 3] = [0.1, 0.75, 8.0];
/// Check that `input` (one open subpath), simplified at each of [`ACCURACIES`], strays no more
/// than twice the accuracy from it and leaves no part of it further off than that, stays in its
/// box grown by as much, and is still one subpath from its start to its end.
fn keeps_to_one_stroke(what: &str, input: &BezPath) {
for accuracy in ACCURACIES {
let out = simplify_path(input, accuracy);
let (svg, limit) = (out.to_svg(), 2.0 * accuracy);
let d = deviation(&out, input);
assert!(d <= limit, "{what} at {accuracy}: strays {d} from the input: {svg}");
let left = deviation(input, &out);
assert!(left <= limit, "{what} at {accuracy}: leaves the input {left} off: {svg}");
let (inb, outb) = (input.bounding_box(), out.bounding_box());
assert!(inb.inflate(limit, limit).contains_rect(outb), "{what} at {accuracy}: {outb:?} past {inb:?}");
let moves = out.elements().iter().filter(|e| matches!(e, kurbo::PathEl::MoveTo(_))).count();
assert_eq!(moves, 1, "{what} at {accuracy}: {svg}");
// From its start to its end: kurbo evaluates a fitted end on the input, so it is off by
// rounding at most.
let ends = |p: &BezPath| p.segments().next().map(|s| s.start()).zip(p.segments().last().map(|s| s.end()));
let ((start, end), (start_in, end_in)) = (ends(&out).unwrap(), ends(input).unwrap());
assert!((start - start_in).hypot() < 1e-9 && (end - end_in).hypot() < 1e-9, "{what} at {accuracy}: {svg}");
}
}
/// Strokes made of curves keep to them as polylines do (#1741): a quadratic or a cubic that goes
/// out and comes straight back, one whose control points sit on its ends (so its direction is
/// read from the control point after them), and nearly collinear curves.
#[test]
fn simplifying_keeps_to_curves_that_turn_back_or_run_straight() {
let (p, q, r) = (
(209.598_690_794_015_5, -204.909_328_119_739_88),
(211.277_914_263_870_97, -207.190_974_020_753_4),
(214.246_506_828_720_84, -211.228_827_590_623_24),
);
// The nearly collinear samples, each line as a cubic with its handles a third of the way along.
let third = |a: (f64, f64), b: (f64, f64), t: f64| (a.0 + (b.0 - a.0) * t, a.1 + (b.1 - a.1) * t);
let mut straight_cubics = BezPath::new();
straight_cubics.move_to(p);
for (a, b) in [(p, q), (q, r)] {
straight_cubics.curve_to(third(a, b, 1.0 / 3.0), third(a, b, 2.0 / 3.0), b);
}
let mut straight_quads = BezPath::new();
straight_quads.move_to(p);
straight_quads.quad_to(third(p, q, 0.5), q);
straight_quads.quad_to(third(q, r, 0.5), r);
let cases = [
("a quadratic out and back", BezPath::from_svg("M0 0 Q15 10 30 0 Q15 10 0 0 Q-15 10 -30 0").unwrap()),
("a cubic out and back", BezPath::from_svg("M0 0 C10 8 20 8 30 0 C20 8 10 8 0 0 C-10 8 -20 8 -30 0").unwrap()),
("handles on the ends", BezPath::from_svg("M0 0 C0 0 30 4 30 4 C30 4 0 0 0 0 L-30 -4").unwrap()),
("a cubic dip down and back up", BezPath::from_svg("M0 0 L10 0 C15 0 20 5 20 12 C20 5 25 0 30 0 L40 0").unwrap()),
("nearly collinear cubics", straight_cubics),
("nearly collinear quadratics", straight_quads),
];
for (what, input) in cases {
keeps_to_one_stroke(what, &input);
}
}
/// `sides` simplified by kurbo one at a time and joined into one subpath.
fn fitted_apart(sides: &[&BezPath], accuracy: f64) -> BezPath {
let mut out = BezPath::new();
for side in sides {
let fit = kurbo::simplify::simplify_bezpath(side.iter(), accuracy, &Default::default());
let skip = usize::from(!out.elements().is_empty());
out.extend(fit.elements().iter().copied().skip(skip));
}
out
}
/// `curve` cut into `n` cubics, drawn on from where `path` is: forwards, or back from its end.
fn in_pieces(path: &mut BezPath, curve: kurbo::CubicBez, n: u32, back: bool) {
use kurbo::ParamCurve;
for i in 0..n {
let i = if back { n - 1 - i } else { i };
let c = curve.subsegment(f64::from(i) / f64::from(n)..f64::from(i + 1) / f64::from(n));
if back { path.curve_to(c.p2, c.p1, c.p0) } else { path.curve_to(c.p1, c.p2, c.p3) }
}
}
/// Where a path turns straight back it is cut, so the result is kurbo's fit of each side on its
/// own, with a point of the path at the turn. Fitted as one, kurbo rounds the turn off: its curve
/// passes the stray check, but falls short of the turn or takes more segments. A cubic whose
/// control points sit on its ends turns back as a line does.
#[test]
fn simplifying_fits_each_side_of_a_turn_back_on_its_own() {
use kurbo::ParamCurve;
let svg = |d: &str| BezPath::from_svg(d).unwrap();
let s = kurbo::CubicBez::new((0.0, 0.0), (40.0, -60.0), (80.0, 60.0), (120.0, 0.0));
let (mut s_out, mut s_back) = (BezPath::new(), BezPath::new());
s_out.move_to(s.p0);
in_pieces(&mut s_out, s, 8, false);
s_back.move_to(s.p3);
in_pieces(&mut s_back, s, 8, true);
let cases = [
("lines", svg("M0 0 L10 0 L20 0 L30 0"), svg("M30 0 L20 0 L10 0")),
("handles on the ends", svg("M0 0 L10 0 L20 0 C20 0 30 0 30 0"), svg("M30 0 C30 0 20 0 20 0 L10 0")),
("a curve in pieces", s_out, s_back),
];
for (what, out_side, back_side) in cases {
let turn = out_side.segments().last().map(|seg| seg.end()).unwrap();
let mut input = out_side.clone();
input.extend(back_side.elements().iter().copied().skip(1));
for accuracy in ACCURACIES {
let ours = simplify_path(&input, accuracy);
let apart = fitted_apart(&[&out_side, &back_side], accuracy);
assert_eq!(ours.elements(), apart.elements(), "{what} at {accuracy}");
assert!(ours.segments().any(|seg| (seg.end() - turn).hypot() < 1e-9), "{what} at {accuracy}: {}", ours.to_svg());
}
}
}
/// Where a path never turns back and kurbo's fit holds, the result is kurbo's own, element for
/// element: smooth runs, corners sharper than a right angle, closed subpaths and several subpaths.
/// A fit counts as holding up to twice the accuracy asked for, whatever that is: the large wave's
/// is further off at the coarse accuracy than the Pencil's limit of 1.5.
#[test]
fn simplifying_is_kurbos_where_its_fit_holds() {
let wave: Vec<(f64, f64)> = (0..=60).map(|i| (f64::from(i) * 4.0, (f64::from(i) / 6.0).sin() * 30.0)).collect();
let zigzag: Vec<(f64, f64)> = (0..=8).map(|i| (f64::from(i) * 10.0, if i % 2 == 0 { 0.0 } else { 40.0 })).collect();
let mut closed = polyline(&wave[..20]);
closed.close_path();
let mut several = polyline(&wave);
several.extend(polyline(&zigzag).elements().iter().map(|e| match *e {
kurbo::PathEl::MoveTo(p) => kurbo::PathEl::MoveTo(p + Vec2::new(0.0, 100.0)),
kurbo::PathEl::LineTo(p) => kurbo::PathEl::LineTo(p + Vec2::new(0.0, 100.0)),
e => e,
}));
let curves = BezPath::from_svg("M0 0 C10 -20 30 -20 40 0 C50 20 70 20 80 0 Q100 -30 120 0 L140 10 Z M200 0 L240 0").unwrap();
// A sine 300 high in 40 smooth cubics.
let sine = |x: f64| ((x / 120.0).sin() * 300.0, (x / 120.0).cos() * 2.5);
let mut large = BezPath::new();
large.move_to((0.0, 0.0));
for i in 0..40 {
let (x0, x1) = (f64::from(i) * 40.0, f64::from(i + 1) * 40.0);
let ((y0, d0), (y1, d1)) = (sine(x0), sine(x1));
large.curve_to((x0 + 40.0 / 3.0, y0 + d0 * 40.0 / 3.0), (x1 - 40.0 / 3.0, y1 - d1 * 40.0 / 3.0), (x1, y1));
}
let coarse = simplify_path(&large, 8.0);
assert!(coarse.elements().len() < 10 && (1.5..=8.0).contains(&deviation(&coarse, &large)), "{}", deviation(&coarse, &large));
for (what, input) in [
("a wave", polyline(&wave)),
("a zigzag", polyline(&zigzag)),
("closed", closed),
("two subpaths", several),
("curves", curves),
("a large wave", large),
] {
for accuracy in ACCURACIES {
let ours = simplify_path(&input, accuracy);
let theirs = kurbo::simplify::simplify_bezpath(input.iter(), accuracy, &Default::default());
assert_eq!(ours.elements(), theirs.elements(), "{what} at {accuracy}");
}
}
}
/// A closed path with a reversal in it stays one closed subpath, and each subpath of several keeps
/// its own start.
#[test]
fn simplifying_keeps_closes_and_subpaths_across_a_reversal() {
let mut input = polyline(&[(0.0, 0.0), (40.0, 0.0), (40.0, 30.0), (40.0, 20.0), (0.0, 30.0)]);
input.close_path();
input.extend(polyline(&[(100.0, 0.0), (100.0, 20.0), (100.0, 10.0)]).elements().iter().copied());
let out = simplify_path(&input, 0.75);
let els = out.elements();
let moves: Vec<Point> = els.iter().filter_map(|e| if let kurbo::PathEl::MoveTo(p) = e { Some(*p) } else { None }).collect();
assert_eq!(moves, [Point::new(0.0, 0.0), Point::new(100.0, 0.0)], "{}", out.to_svg());
assert_eq!(els.iter().filter(|e| matches!(e, kurbo::PathEl::ClosePath)).count(), 1, "{}", out.to_svg());
let close = els.iter().position(|e| matches!(e, kurbo::PathEl::ClosePath)).unwrap();
assert!(matches!(els[close + 1], kurbo::PathEl::MoveTo(_)), "the first subpath closes before the second starts");
assert!(deviation(&out, &input) <= 1.5, "{}", out.to_svg());
// Nothing to draw: nothing out, not a stray move or close.
let mut empty = BezPath::new();
empty.move_to((5.0, 5.0));
empty.line_to((5.0, 5.0));
empty.close_path();
assert!(simplify_path(&empty, 0.75).elements().is_empty());
for d in ["", "M5 5", "M5 5 M6 6", "M5 5 Z"] {
let input = if d.is_empty() { BezPath::new() } else { BezPath::from_svg(d).unwrap() };
assert!(simplify_path(&input, 0.75).elements().is_empty(), "{d:?}");
}
}
/// The subpaths simplified keep their starts: a move with nothing drawn from it between two
/// subpaths leaves no trace, and a segment drawn on from a close starts a subpath where the closed
/// one started, as it does in the path given.
#[test]
fn simplifying_keeps_where_each_subpath_starts() {
let starts =
|p: &BezPath| -> Vec<Point> { p.elements().iter().filter_map(|e| if let kurbo::PathEl::MoveTo(p) = e { Some(*p) } else { None }).collect() };
let between = BezPath::from_svg("M0 0 L10 0 L20 5 M50 50 M100 0 L110 0 L120 5").unwrap();
let out = simplify_path(&between, 0.75);
assert_eq!(starts(&out), [Point::new(0.0, 0.0), Point::new(100.0, 0.0)], "{}", out.to_svg());
assert!(deviation(&out, &between) <= 1.5, "{}", out.to_svg());
// After the close, the pen is back at (0, 0): the next segments start there, also across a
// reversal.
use kurbo::PathEl::{ClosePath, LineTo, MoveTo};
let on = BezPath::from_vec(vec![
MoveTo(Point::new(0.0, 0.0)),
LineTo(Point::new(10.0, 0.0)),
LineTo(Point::new(10.0, 10.0)),
ClosePath,
LineTo(Point::new(20.0, 20.0)),
LineTo(Point::new(30.0, 20.0)),
LineTo(Point::new(20.0, 20.0)),
]);
let out = simplify_path(&on, 0.75);
let els = out.elements();
let close = els.iter().position(|e| matches!(e, kurbo::PathEl::ClosePath)).unwrap();
assert_eq!(els.get(close + 1), Some(&kurbo::PathEl::MoveTo(Point::new(0.0, 0.0))), "{}", out.to_svg());
assert_eq!(starts(&out), [Point::new(0.0, 0.0), Point::new(0.0, 0.0)], "{}", out.to_svg());
assert_eq!(out.segments().last().map(|s| kurbo::ParamCurve::end(&s)), Some(Point::new(20.0, 20.0)));
assert!(deviation(&out, &on) <= 1.5, "{}", out.to_svg());
}
crates/layout/src/depth_tests.rs
+12
View File
@@ -93,3 +93,15 @@ fn deeply_nested_fill_frames_lay_out_without_running_out_of_stack() {
assert_eq!(width(&d, chain[DEEP - 1]), 10.0, "past the nesting the layout follows, layers stay");
});
}
#[test]
fn snap_lines_are_bounded_across_a_frames_grids() {
use figcraft_doc::{Document, GridKind, LayoutGrid, NodeKind};
let mut d = Document::new("t");
let p = d.first_page().unwrap();
let f = d.create(p, NodeKind::Frame, "F", 0.0, 0.0, 4000.0, 4000.0).unwrap();
d.get_mut(f).unwrap().grids = vec![LayoutGrid { kind: GridKind::Grid, size: 1.0, visible: true, ..LayoutGrid::default() }; 1000];
let (xs, ys) = crate::grid_snap_lines(&d, f);
assert!(xs.len() + ys.len() <= 200_000, "{}", xs.len() + ys.len());
assert!(xs.len() > 4000 && ys.len() > 4000, "the first grids still give their lines");
}
crates/layout/src/lib.rs
+10 -1
View File
@@ -1159,6 +1159,9 @@ pub fn grid_snap_lines(doc: &Document, frame: NodeId) -> (Vec<f64>, Vec<f64>) {
grid_snap_lines_in(doc, frame, doc.world_transform(frame))
}
/// The most snap coordinates a frame's grids give together (a few dozen grids' worth of lines).
const MAX_SNAP_LINES: usize = 200_000;
/// [`grid_snap_lines`] mapped from the frame's coordinates by `xf` (the frame's world transform
/// for page lines).
pub fn grid_snap_lines_in(doc: &Document, frame: NodeId, xf: Affine) -> (Vec<f64>, Vec<f64>) {
@@ -1166,7 +1169,13 @@ pub fn grid_snap_lines_in(doc: &Document, frame: NodeId, xf: Affine) -> (Vec<f64
let mut xs = Vec::new();
let mut ys = Vec::new();
for g in f.grids.iter().filter(|g| g.visible) {
for r in grid_lines(g, f.width, f.height) {
// A frame-wide budget: each grid adds up to ~17,000 lines, and a file can hold any number of grids;
// a grid that would pass it is left out whole.
let lines = grid_lines(g, f.width, f.height);
if xs.len() + ys.len() + 2 * lines.len() > MAX_SNAP_LINES {
break;
}
for r in lines {
let a = xf * Point::new(r.x0, r.y0);
let b = xf * Point::new(r.x1, r.y1);
match g.kind {
crates/svg/src/import.rs
+52 -5
View File
@@ -704,13 +704,36 @@ fn simple_hash(b: &[u8]) -> String {
/// Deepest element nesting the parser is given: deeper documents would exhaust the stack.
const MAX_NESTING: usize = 512;
/// The most attributes one element may have. The XML parser checks each attribute against the
/// earlier ones, so a huge count is quadratic work; real elements have a few dozen at most.
const MAX_ATTRIBUTES: usize = 4096;
/// How deep elements nest in `data`: a scan of its tags (comments, CDATA, declarations and quoted
/// attribute values skipped) that stops once past `limit`.
pub(crate) fn nesting(data: &[u8], limit: usize) -> usize {
scan(data, limit).0
}
/// The most the parser's duplicate-attribute checks may cost over a whole document, as the sum of
/// each element's attribute count squared (a real file with 100,000 elements of 20 attributes is
/// 40 million).
const MAX_ATTRIBUTE_WORK: usize = 1 << 28;
/// Whether an element of `data` has more than [`MAX_ATTRIBUTES`] attributes, or all of them cost
/// more than [`MAX_ATTRIBUTE_WORK`] (counted as quoted values, before the parser sees them; the
/// declarations of a DTD count as one element, as entities can hold elements).
pub(crate) fn too_wide(data: &[u8]) -> bool {
let (_, widest, work) = scan(data, usize::MAX);
widest > MAX_ATTRIBUTES || work > MAX_ATTRIBUTE_WORK
}
/// [`nesting`], the most attribute values on one element and the attribute work (see
/// [`MAX_ATTRIBUTE_WORK`]); stops once any is past its limit.
fn scan(data: &[u8], limit: usize) -> (usize, usize, usize) {
let find = |from: usize, pat: &[u8]| -> usize {
data.get(from..).and_then(|r| r.windows(pat.len()).position(|w| w == pat)).map_or(data.len(), |p| from + p + pat.len())
};
let (mut depth, mut max, mut i) = (0usize, 0usize, 0usize);
let (mut depth, mut max, mut i, mut widest, mut work) = (0usize, 0usize, 0usize, 0usize, 0usize);
while let Some(off) = data.get(i..).and_then(|r| r.iter().position(|b| *b == b'<')) {
i += off;
let rest = data.get(i..).unwrap_or(&[]);
@@ -718,6 +741,19 @@ pub(crate) fn nesting(data: &[u8], limit: usize) -> usize {
i = find(i + 4, b"-->");
} else if rest.starts_with(b"<![CDATA[") {
i = find(i + 9, b"]]>");
} else if rest.starts_with(b"<!DOCTYPE") {
// To the `]>` closing its subset (the first `>` when it has none).
let end = match (rest.iter().position(|b| *b == b'['), rest.iter().position(|b| *b == b'>')) {
(Some(o), Some(g)) if o < g => find(i, b"]>"),
_ => find(i, b">"),
};
let quotes = data.get(i..end).unwrap_or(&[]).iter().filter(|b| matches!(**b, b'"' | b'\'')).count();
widest = widest.max(quotes / 2);
work = work.saturating_add((quotes / 2).saturating_mul(quotes / 2));
if widest > MAX_ATTRIBUTES || work > MAX_ATTRIBUTE_WORK {
return (max, widest, work);
}
i = end;
} else if rest.starts_with(b"<?") || rest.starts_with(b"<!") {
i = find(i + 2, b">");
} else if rest.starts_with(b"</") {
@@ -725,12 +761,15 @@ pub(crate) fn nesting(data: &[u8], limit: usize) -> usize {
i = find(i + 2, b">");
} else {
// A start tag: to its `>` outside quotes; `/>` closes it.
let (mut quote, mut j, mut closed) = (None, i + 1, false);
let (mut quote, mut j, mut closed, mut attrs) = (None, i + 1, false, 0usize);
while let Some(&c) = data.get(j) {
match quote {
Some(q) if c == q => quote = None,
Some(_) => {}
None if c == b'"' || c == b'\'' => quote = Some(c),
None if c == b'"' || c == b'\'' => {
quote = Some(c);
attrs += 1;
}
None if c == b'>' => {
closed = data.get(j.wrapping_sub(1)) == Some(&b'/');
break;
@@ -739,17 +778,22 @@ pub(crate) fn nesting(data: &[u8], limit: usize) -> usize {
}
j += 1;
}
widest = widest.max(attrs);
work = work.saturating_add(attrs * attrs);
if widest > MAX_ATTRIBUTES || work > MAX_ATTRIBUTE_WORK {
return (max, widest, work);
}
if !closed {
depth += 1;
max = max.max(depth);
if max > limit {
return max;
return (max, widest, work);
}
}
i = j + 1;
}
}
max
(max, widest, work)
}
/// Whether `data` nests elements more than [`MAX_NESTING`] deep: the byte scan first, then the
@@ -883,6 +927,9 @@ fn import_within(
) -> Result<Imported, ImportError> {
// SVGZ is unpacked here, within a budget, so every check below sees the real document.
let data = budget::document(data, &limits).map_err(ImportError)?;
if too_wide(&data) {
return Err(ImportError(format!("an element has more than {MAX_ATTRIBUTES} attributes")));
}
if too_deep(&data) {
return Err(ImportError(format!("elements nested more than {MAX_NESTING} deep")));
}
crates/svg/src/import/budget.rs
+1 -1
View File
@@ -87,7 +87,7 @@ fn embedded(used: &Used, limits: &Limits, data: &[u8], opts: &Options) -> Option
}
};
used.bytes.fetch_add(plain.len(), Ordering::Relaxed);
if super::too_deep(&plain) {
if super::too_wide(&plain) || super::too_deep(&plain) {
return None;
}
used.depth.fetch_add(1, Ordering::Relaxed);
crates/svg/src/import/hostile_tests.rs
+24
View File
@@ -181,3 +181,27 @@ fn entity_expansion_cannot_bypass_the_nesting_limit() {
let err = import_svg(&mut d, data.as_bytes(), p, 0.0, 0.0, "x").err().map(|e| e.to_string()).unwrap_or_default();
assert!(err.contains("nested more than 512 deep"), "{err:?}");
}
#[test]
fn an_element_with_thousands_of_attributes_is_refused_before_parsing() {
use super::too_wide;
let many = |n: usize| (0..n).map(|i| format!(" a{i}=\"1\"")).collect::<String>();
assert!(!too_wide(format!("<svg{}/>", many(4096)).as_bytes()));
assert!(too_wide(format!("<svg><g{}/></svg>", many(4097)).as_bytes()));
assert!(!too_wide(format!("<svg>{}</svg>", "<g a='1' b='2'/>".repeat(10_000)).as_bytes()), "per element, not per file");
let mut d = Document::new("t");
let p = d.first_page().unwrap();
assert!(import_svg(&mut d, &svg(&format!("<g{}/>", many(100_000))), p, 0.0, 0.0, "x").is_err());
}
#[test]
fn attribute_work_is_bounded_over_the_whole_document_and_its_dtd() {
use super::too_wide;
let many = |n: usize| (0..n).map(|i| format!(" a{i}=\"1\"")).collect::<String>();
let tag = format!("<g{}/>", many(4000));
assert!(!too_wide(format!("<svg>{}</svg>", tag.repeat(10)).as_bytes()));
assert!(too_wide(format!("<svg>{}</svg>", tag.repeat(40)).as_bytes()), "each element is within the limit, all together are not");
let dtd = format!("<!DOCTYPE svg [<!ENTITY e '<g{}/>'>]><svg>&e;</svg>", many(5000));
assert!(too_wide(dtd.as_bytes()), "entities can hold elements");
assert!(!too_wide(b"<?xml version='1.0'?><!DOCTYPE svg [<!ENTITY ns 'http://www.w3.org/2000/svg'>]><svg/>"));
}
crates/svg/src/import/text.rs
+28 -3
View File
@@ -195,7 +195,7 @@ pub(crate) fn text(cx: &mut Ctx, t: &usvg::Text, parent: NodeId, base: Affine, d
let x = chunk.x().map_or(pen_x, f64::from) + d(t.dx());
let y = chunk.y().map_or(pen_y, f64::from) + d(t.dy());
char_at += count;
let ci = |b: usize| text.get(..b).map_or(count, |p| p.chars().count());
let ci = char_index(text, chunk.spans().iter().flat_map(|sp| [sp.start(), sp.end()]));
let spans: Vec<_> = chunk.spans().iter().map(|sp| (ci(sp.start()), ci(sp.end()), sp, span_style(sp, s, fonts))).collect();
if spans.is_empty() {
continue;
@@ -229,6 +229,32 @@ pub(crate) fn text(cx: &mut Ctx, t: &usvg::Text, parent: NodeId, base: Affine, d
}
}
/// The characters of `text` before each of the byte `offsets` (all of them for an offset that is
/// past the end or inside a character): one pass over the text, whatever the number of spans.
fn char_index(text: &str, offsets: impl IntoIterator<Item = usize>) -> impl Fn(usize) -> usize {
let mut want: Vec<usize> = offsets.into_iter().collect();
want.sort_unstable();
want.dedup();
let mut found: Vec<(usize, usize)> = Vec::with_capacity(want.len());
let mut wanted = want.into_iter().peekable();
let mut count = 0;
for (i, _) in text.char_indices() {
while let Some(&o) = wanted.peek() {
match o.cmp(&i) {
std::cmp::Ordering::Equal => found.push((o, count)),
std::cmp::Ordering::Greater => break,
std::cmp::Ordering::Less => {}
}
wanted.next();
}
count += 1;
}
if wanted.any(|o| o == text.len()) {
found.push((text.len(), count));
}
move |b| found.binary_search_by_key(&b, |f| f.0).ok().and_then(|k| found.get(k)).map_or(count, |f| f.1)
}
/// The text of `lines` (one per line, stacked at their pitch; `s`: their scale): characters, the
/// first span's style and a run per span, fills still to come.
fn text_data(lines: &[Line], s: f64) -> TextData {
@@ -262,8 +288,7 @@ fn on_path(cx: &mut Ctx, t: &usvg::Text, world: Affine, parent: NodeId) -> bool
let Some(len) = figcraft_geom::measure::polylines(&path).and_then(|l| l.first().map(|l| l.length())).filter(|l| *l > 1e-9) else { return false };
let fonts = cx.fonts.get_or_insert_with(Fonts::load);
let text = chunk.text();
let count = text.chars().count();
let ci = |b: usize| text.get(..b).map_or(count, |p| p.chars().count());
let ci = char_index(text, chunk.spans().iter().flat_map(|sp| [sp.start(), sp.end()]));
let spans: Vec<_> = chunk.spans().iter().map(|sp| (ci(sp.start()), ci(sp.end()), sp, span_style(sp, 1.0, fonts))).collect();
let line = Line { x: 0.0, y: 0.0, anchor: chunk.anchor(), text: text.to_string(), spans };
let mut td = text_data(std::slice::from_ref(&line), 1.0);
crates/svg/src/import/text_tests.rs
+8
View File
@@ -30,3 +30,11 @@ fn css_system_font_names_keep_their_name_where_the_system_font_is() {
assert_eq!(family(&named(&["-apple-system", "BlinkMacSystemFont", "system-ui", "sans-serif"]), &elsewhere), "Inter");
assert_eq!(family(&named(&["-apple-system"]), &elsewhere), "-apple-system", "nothing installed: the first name it gives");
}
#[test]
fn char_index_counts_the_characters_before_a_byte_offset() {
let t = "aé😀b";
let ci = super::char_index(t, [0, 1, 3, 7, 8, 2, 4, 99]);
assert_eq!([ci(0), ci(1), ci(3), ci(7), ci(8)], [0, 1, 2, 3, 4]);
assert_eq!([ci(2), ci(4), ci(99)], [4, 4, 4], "inside a character or past the end: all of them");
}
crates/text/src/fontdb.rs
+27 -3
View File
@@ -92,6 +92,10 @@ pub struct Face {
pub italic: bool,
pub bytes: FontBytes,
pub index: u32,
/// 0 for a built-in or installed face; else the order it was loaded in with `text.loadFont`
/// ([`FontDb::add_loaded`]). A loaded face wins over any other of its family and style, the
/// latest load over earlier ones (#2092).
pub loaded: u32,
pub upem: f64,
/// Ascent and descent in font units, both positive.
pub ascent: f64,
@@ -207,6 +211,7 @@ impl Face {
family,
style,
index,
loaded: 0,
upem,
ascent,
descent,
@@ -620,6 +625,8 @@ pub struct FontDb {
loaded_files: std::collections::BTreeSet<(std::path::PathBuf, u32)>,
/// Font files added as bytes (hash and length → families), so loading one again adds nothing.
loaded_bytes: std::collections::HashMap<(u64, usize), Vec<String>>,
/// Loads so far ([`Face::loaded`]).
load_seq: u32,
system_scanned: bool,
/// Browser fonts text asked for and not yet taken by the browser layer.
wanted: Vec<usize>,
@@ -716,8 +723,20 @@ impl FontDb {
face
}
/// [`add`](Self::add) a face loaded explicitly (`text.loadFont`): it wins over the other faces
/// of its family and style, and over those loaded before it.
pub fn add_loaded(&mut self, mut face: Face) -> Arc<Face> {
self.load_seq += 1;
face.loaded = self.load_seq;
self.add(face)
}
/// Add font file bytes (all faces of a collection). Returns the faces added.
pub fn add_bytes(&mut self, bytes: Vec<u8>) -> Vec<Arc<Face>> {
self.add_bytes_with(bytes, false)
}
fn add_bytes_with(&mut self, bytes: Vec<u8>, loaded: bool) -> Vec<Arc<Face>> {
let shared = Arc::new(bytes);
let count = match FileRef::new(shared.as_slice()) {
// A collection's header may name any number of faces, each a few bytes pointing at
@@ -727,7 +746,10 @@ impl FontDb {
Ok(FileRef::Font(_)) => 1,
Err(_) => 0,
};
(0..count).filter_map(|i| Face::from_bytes(FontBytes::Shared(shared.clone()), i, None, None)).map(|f| self.add(f)).collect()
(0..count)
.filter_map(|i| Face::from_bytes(FontBytes::Shared(shared.clone()), i, None, None))
.map(|f| if loaded { self.add_loaded(f) } else { self.add(f) })
.collect()
}
/// The family and style of the face whose PostScript name is `ps` (ignoring case), loaded or
@@ -1035,7 +1057,9 @@ impl FontDb {
/// The loaded face of `family` nearest `style`.
fn best(&self, family: &str, style: &str) -> Option<Arc<Face>> {
let (_, idx) = self.families.get(&self.key(family))?;
let faces: Vec<&Arc<Face>> = idx.iter().filter_map(|i| self.faces.get(*i)).collect();
let mut faces: Vec<&Arc<Face>> = idx.iter().filter_map(|i| self.faces.get(*i)).collect();
// A loaded font comes first (the latest load first): of faces as near, the first wins.
faces.sort_by_key(|f| std::cmp::Reverse(f.loaded));
let want = norm_style(style);
if let Some(f) = faces.iter().find(|f| norm_style(&f.style) == want).or_else(|| faces.iter().find(|f| has_style(f, style))) {
return Some((*f).clone());
@@ -1595,7 +1619,7 @@ pub fn load_font_bytes(bytes: Vec<u8>) -> Vec<String> {
if let Some(families) = db.loaded_bytes.get(&key) {
return families.clone();
}
let faces = db.add_bytes(bytes);
let faces = db.add_bytes_with(bytes, true);
let mut families: Vec<String> = faces.iter().map(|f| f.family.clone()).collect();
families.dedup();
if !families.is_empty() {
crates/text/src/fontdb_tests.rs
+39
View File
@@ -382,6 +382,45 @@ fn font_bytes_load_into_the_db() {
}
}
/// #2092: a font loaded with `text.loadFont` wins over the built-in and installed faces of its family
/// and style, the latest load over earlier ones; other styles resolve as before.
#[test]
fn a_loaded_face_wins_over_the_built_in_one_of_its_family_and_style() {
// Any embedded or installed font stands in for the faces (none without craft-fonts on CI).
let stand_in = CRAFT_FONTS.first().map(|f| f.bytes.to_vec()).or_else(|| {
let mut installed = BTreeMap::new();
for dir in system_font_dirs() {
scan_dir(&dir, 0, &mut installed);
}
installed.values().flat_map(|(_, v)| v).find_map(|p| std::fs::read(&p.path).ok())
});
let Some(bytes) = stand_in.map(Arc::new) else {
eprintln!("skipping: no font to stand in");
return;
};
let face = |style: &str, name: &str| {
let mut f = Face::from_bytes(FontBytes::Shared(bytes.clone()), 0, Some("Brand Sans"), Some(style)).unwrap();
f.instances.clear();
f.postscript = Some(name.into());
f
};
let name = |db: &FontDb, style: &str| db.best("Brand Sans", style).and_then(|f| f.postscript.clone());
let mut db = FontDb::default();
db.add(face("Regular", "Built-in-Regular"));
db.add(face("Bold", "Built-in-Bold"));
assert_eq!(name(&db, "Regular").as_deref(), Some("Built-in-Regular"));
db.add_loaded(face("Regular", "Loaded-Regular"));
assert_eq!(name(&db, "Regular").as_deref(), Some("Loaded-Regular"));
// Bold wasn't loaded: the built-in one stays. Nor does the loaded Regular stand in for it.
assert_eq!(name(&db, "Bold").as_deref(), Some("Built-in-Bold"));
// The latest load wins.
db.add_loaded(face("Regular", "Loaded-Regular-2"));
assert_eq!(name(&db, "Regular").as_deref(), Some("Loaded-Regular-2"));
// A face added after a load, not loaded, doesn't displace it.
db.add(face("Regular", "Installed-Regular"));
assert_eq!(name(&db, "Regular").as_deref(), Some("Loaded-Regular-2"));
}
/// Apple's system font answers to the names designs and CSS use for it (SF Pro, SF UI Text,
/// system-ui, …), unless a font of that name is installed.
#[test]
crates/text/src/tail_tests.rs
+10 -2
View File
@@ -93,8 +93,16 @@ fn list_numbering_by_level() {
vec!["\u{2022}", "\u{2022}", "\u{2022}", "\u{2022}"],
"bullets keep the same styling at all levels of indentation",
),
(vec![pl(N, 0), pl(N, 0), pl(P, 0), pl(N, 0)], vec!["1.", "2.", "", "1."], "silent: a plain paragraph ends a list, the next starts at 1"),
(vec![pl(N, 0), pl(B, 0), pl(N, 0)], vec!["1.", "\u{2022}", "1."], "silent: the other kind of list at the same level starts the count again"),
(
vec![pl(N, 0), pl(N, 0), pl(P, 0), pl(N, 0)],
vec!["1.", "2.", "", "1."],
"as measured in Figma (2026-11-11): a plain paragraph ends a list, the next starts at 1",
),
(
vec![pl(N, 0), pl(B, 0), pl(N, 0)],
vec!["1.", "\u{2022}", "1."],
"as measured in Figma (2026-11-11): a bullet item between numbered ones starts the count again",
),
(vec![pl(N, 0), pl(N, 1), pl(N, 0), pl(N, 1)], vec!["1.", "a.", "2.", "a."], "a shallower item starts the deeper count again"),
(vec![pl(N, 2), pl(N, 2), pl(N, 2), pl(N, 2)], vec!["i.", "ii.", "iii.", "iv."], "roman numerals at the third level"),
];
crates/ui-egui/locales/ar.toml
+1
View File
@@ -2009,6 +2009,7 @@ status = "draft — needs native review"
"component.combineVariants" = "جمع كتنويعات"
"component.create" = "إنشاء مكوّن"
"component.createMultiple" = "إنشاء مكونات متعددة"
"component.createSet" = "إنشاء مجموعة مكونات"
"component.deleteProperty" = "حذف خاصية المكوّن"
"component.detach" = "فصل النسخة المثيلة"
"component.editProperty" = "تحرير خاصية المكوّن"
crates/ui-egui/locales/bs.toml
+1
View File
@@ -2038,6 +2038,7 @@ status = "draft — needs native review"
"component.combineVariants" = "Kombinuj kao varijante"
"component.create" = "Kreiraj komponentu"
"component.createMultiple" = "Kreiraj više komponenti"
"component.createSet" = "Kreiraj skup komponenti"
"component.deleteProperty" = "Izbriši svojstvo komponente"
"component.detach" = "Odvoji instancu"
"component.editProperty" = "Uredi svojstvo komponente"
crates/ui-egui/locales/cs.toml
+1
View File
@@ -1913,6 +1913,7 @@ status = "draft — needs native review"
"component.combineVariants" = "Sloučit jako varianty"
"component.create" = "Vytvořit komponentu"
"component.createMultiple" = "Vytvořit více komponent"
"component.createSet" = "Vytvořit sadu komponent"
"component.deleteProperty" = "Smazat vlastnost komponenty"
"component.detach" = "Odpojit instanci"
"component.editProperty" = "Upravit vlastnost komponenty"
crates/ui-egui/locales/de.toml
+1
View File
@@ -2079,6 +2079,7 @@ status = "draft — needs native review"
"component.combineVariants" = "Als Varianten kombinieren"
"component.create" = "Komponente erstellen"
"component.createMultiple" = "Mehrere Komponenten erstellen"
"component.createSet" = "Komponentensatz erstellen"
"component.deleteProperty" = "Komponenteneigenschaft löschen"
"component.detach" = "Instanz lösen"
"component.editProperty" = "Komponenteneigenschaft bearbeiten"
crates/ui-egui/locales/es.toml
+1
View File
@@ -2002,6 +2002,7 @@ status = "draft — needs native review"
"component.combineVariants" = "Combinar como variantes"
"component.create" = "Crear componente"
"component.createMultiple" = "Crear varios componentes"
"component.createSet" = "Crear conjunto de componentes"
"component.deleteProperty" = "Eliminar propiedad de componente"
"component.detach" = "Separar instancia"
"component.editProperty" = "Editar propiedad de componente"
crates/ui-egui/locales/fi.toml
+1
View File
@@ -2086,6 +2086,7 @@ status = "draft — needs native review"
"component.combineVariants" = "Yhdistä varianteiksi"
"component.create" = "Luo komponentti"
"component.createMultiple" = "Luo useita komponentteja"
"component.createSet" = "Luo komponenttijoukko"
"component.deleteProperty" = "Poista komponentin ominaisuus"
"component.detach" = "Irrota ilmentymä"
"component.editProperty" = "Muokkaa komponentin ominaisuutta"
crates/ui-egui/locales/fr.toml
+1
View File
@@ -1958,6 +1958,7 @@ status = "draft — needs native review"
"component.combineVariants" = "Combiner en variantes"
"component.create" = "Créer un composant"
"component.createMultiple" = "Créer plusieurs composants"
"component.createSet" = "Créer un ensemble de composants"
"component.deleteProperty" = "Supprimer la propriété de composant"
"component.detach" = "Détacher l’instance"
"component.editProperty" = "Modifier la propriété de composant"
crates/ui-egui/locales/id.toml
+1
View File
@@ -1917,6 +1917,7 @@ status = "draft — needs native review"
"component.combineVariants" = "Gabungkan sebagai variant"
"component.create" = "Buat component"
"component.createMultiple" = "Buat beberapa component"
"component.createSet" = "Buat set component"
"component.deleteProperty" = "Hapus properti component"
"component.detach" = "Lepaskan instance"
"component.editProperty" = "Edit properti component"
crates/ui-egui/locales/it.toml
+1
View File
@@ -1861,6 +1861,7 @@ status = "draft — needs native review"
"component.combineVariants" = "Combina come varianti"
"component.create" = "Crea componente"
"component.createMultiple" = "Crea più componenti"
"component.createSet" = "Crea set di componenti"
"component.deleteProperty" = "Elimina proprietà del componente"
"component.detach" = "Scollega istanza"
"component.editProperty" = "Modifica proprietà del componente"
crates/ui-egui/locales/ja.toml
+1
View File
@@ -1938,6 +1938,7 @@ status = "draft — needs native review"
"component.combineVariants" = "バリアントとして結合"
"component.create" = "コンポーネントを作成"
"component.createMultiple" = "複数のコンポーネントを作成"
"component.createSet" = "コンポーネントセットを作成"
"component.deleteProperty" = "コンポーネントプロパティを削除"
"component.detach" = "インスタンスを切り離す"
"component.editProperty" = "コンポーネントプロパティを編集"
crates/ui-egui/locales/ka.toml
+1
View File
@@ -2013,6 +2013,7 @@ status = "draft — reviewed by a native speaker, awaiting a maintainer's approv
"component.combineVariants" = "ვარიანტებად გაერთიანება"
"component.create" = "კომპონენტის შექმნა"
"component.createMultiple" = "რამდენიმე კომპონენტის შექმნა"
"component.createSet" = "კომპონენტების ნაკრების შექმნა"
"component.deleteProperty" = "კომპონენტის თვისების წაშლა"
"component.detach" = "ინსტანსის გამოყოფა"
"component.editProperty" = "კომპონენტის თვისების რედაქტირება"
crates/ui-egui/locales/ko.toml
+1
View File
@@ -1978,6 +1978,7 @@ status = "draft — needs native review"
"component.combineVariants" = "배리언트로 결합"
"component.create" = "컴포넌트 만들기"
"component.createMultiple" = "여러 컴포넌트 만들기"
"component.createSet" = "컴포넌트 세트 만들기"
"component.deleteProperty" = "컴포넌트 속성 삭제"
"component.detach" = "인스턴스 분리"
"component.editProperty" = "컴포넌트 속성 편집"
crates/ui-egui/locales/nl.toml
+1
View File
@@ -1956,6 +1956,7 @@ status = "draft — needs native review"
"component.combineVariants" = "Combineren als varianten"
"component.create" = "Component maken"
"component.createMultiple" = "Meerdere componenten maken"
"component.createSet" = "Componentenset maken"
"component.deleteProperty" = "Componenteigenschap verwijderen"
"component.detach" = "Instance loskoppelen"
"component.editProperty" = "Componenteigenschap bewerken"
crates/ui-egui/locales/pl.toml
+1
View File
@@ -1970,6 +1970,7 @@ name = "Polski"
"component.combineVariants" = "Połącz jako warianty"
"component.create" = "Utwórz komponent"
"component.createMultiple" = "Utwórz wiele komponentów"
"component.createSet" = "Utwórz zestaw komponentów"
"component.deleteProperty" = "Usuń właściwość komponentu"
"component.detach" = "Odłącz instancję"
"component.editProperty" = "Edytuj właściwość komponentu"
crates/ui-egui/locales/pt-BR.toml
+1
View File
@@ -1975,6 +1975,7 @@ status = "draft — needs native review"
"component.combineVariants" = "Combinar como variantes"
"component.create" = "Criar componente"
"component.createMultiple" = "Criar vários componentes"
"component.createSet" = "Criar conjunto de componentes"
"component.deleteProperty" = "Excluir propriedade de componente"
"component.detach" = "Desvincular instância"
"component.editProperty" = "Editar propriedade de componente"
crates/ui-egui/locales/ru.toml
+1
View File
@@ -1970,6 +1970,7 @@ name = "Русский"
"component.combineVariants" = "Объединить в варианты"
"component.create" = "Создать компонент"
"component.createMultiple" = "Создать несколько компонентов"
"component.createSet" = "Создать набор компонентов"
"component.deleteProperty" = "Удалить свойство компонента"
"component.detach" = "Отсоединить экземпляр"
"component.editProperty" = "Изменить свойство компонента"
crates/ui-egui/locales/sv.toml
+1
View File
@@ -2077,6 +2077,7 @@ name = "Svenska"
"component.combineVariants" = "Kombinera som varianter"
"component.create" = "Skapa komponent"
"component.createMultiple" = "Skapa flera komponenter"
"component.createSet" = "Skapa komponentuppsättning"
"component.deleteProperty" = "Radera komponentegenskap"
"component.detach" = "Koppla bort instans"
"component.editProperty" = "Redigera komponentegenskap"
crates/ui-egui/locales/ta.toml
+2685
View File
File diff suppressed because it is too large. Load diff
crates/ui-egui/locales/th.toml
+1
View File
@@ -1934,6 +1934,7 @@ status = "draft — needs native review"
"component.combineVariants" = "รวมเป็นแวเรียนต์"
"component.create" = "สร้างคอมโพเนนต์"
"component.createMultiple" = "สร้างหลายคอมโพเนนต์"
"component.createSet" = "สร้างชุดคอมโพเนนต์"
"component.deleteProperty" = "ลบพร็อพเพอร์ตีของคอมโพเนนต์"
"component.detach" = "ถอดอินสแตนซ์"
"component.editProperty" = "แก้ไขพร็อพเพอร์ตีของคอมโพเนนต์"
crates/ui-egui/locales/tr.toml
+1
View File
@@ -1918,6 +1918,7 @@ name = "Türkçe"
"component.combineVariants" = "Varyant olarak birleştir"
"component.create" = "Bileşen oluştur"
"component.createMultiple" = "Birden çok bileşen oluştur"
"component.createSet" = "Bileşen kümesi oluştur"
"component.deleteProperty" = "Bileşen özelliğini sil"
"component.detach" = "Örneği ayır"
"component.editProperty" = "Bileşen özelliğini düzenle"
crates/ui-egui/locales/vi.toml
+1
View File
@@ -1862,6 +1862,7 @@ status = "draft — needs native review"
"component.combineVariants" = "Kết hợp thành các biến thể"
"component.create" = "Tạo thành phần"
"component.createMultiple" = "Tạo nhiều thành phần"
"component.createSet" = "Tạo bộ thành phần"
"component.deleteProperty" = "Xóa thuộc tính thành phần"
"component.detach" = "Tách bản thể"
"component.editProperty" = "Chỉnh sửa thuộc tính thành phần"
crates/ui-egui/locales/zh-Hans.toml
+1
View File
@@ -1871,6 +1871,7 @@ status = "draft — needs native review"
"component.combineVariants" = "合并为变体"
"component.create" = "创建组件"
"component.createMultiple" = "创建多个组件"
"component.createSet" = "创建组件集"
"component.deleteProperty" = "删除组件属性"
"component.detach" = "分离实例"
"component.editProperty" = "编辑组件属性"
crates/ui-egui/locales/zh-Hant.toml
+1
View File
@@ -2089,6 +2089,7 @@ status = "draft — needs native review"
"component.combineVariants" = "合併為變體"
"component.create" = "建立元件"
"component.createMultiple" = "建立多個元件"
"component.createSet" = "建立元件集"
"component.deleteProperty" = "刪除元件屬性"
"component.detach" = "分離實例"
"component.editProperty" = "編輯元件屬性"
crates/ui-egui/src/canvas/board_bar.rs
+1 -1
View File
@@ -140,7 +140,7 @@ fn has(app: &FigApp) -> Option<Has> {
});
line.ids.push(n.id);
}
Some(BoardItem::Label { .. }) => h.text = true,
Some(BoardItem::Label { .. } | BoardItem::MindNode) => h.text = true,
Some(BoardItem::Table) => h.table = true,
Some(BoardItem::Stamp { .. }) | None => {}
}
crates/ui-egui/src/cjk.rs
+13
View File
@@ -131,6 +131,11 @@ fn shows(code: &str, web: bool) -> bool {
// Arabic; keep the catalog out until an embedded Arabic fallback is supplied.
return figcraft_text::face_with_char('ع', &["Noto Sans Arabic"]).is_some();
}
if code.split('-').next() == Some("ta") {
// Desktop draws Tamil with a system face (#2018); the web has none until craft-fonts
// carries Noto Sans Tamil.
return figcraft_text::face_with_char('த', &["Noto Sans Tamil"]).is_some();
}
let need = language(code);
need == 0 || samples(need, 0, traditional(code)).iter().all(|(c, families)| figcraft_text::face_with_char(*c, families).is_some())
}
@@ -228,6 +233,14 @@ mod tests {
assert_eq!(shows("ar-SA", true), face);
}
#[test]
fn the_web_offers_tamil_only_with_its_face() {
assert!(shows("ta", false), "desktop always lists Tamil");
let face = figcraft_text::face_with_char('த', &["Noto Sans Tamil"]).is_some();
assert_eq!(shows("ta", true), face);
assert_eq!(shows("ta-IN", true), face);
}
/// The UI language's script leads the fallback order; the others follow.
#[test]
fn the_ui_language_script_comes_first() {
Loaded 100 of 119 files, more files were not shown because too many files have changed in this diff. Show more