🎛️ Familiar by design
- The toolbar, layers panel, Design panel, menus and shortcuts sit where your hands expect them. If you know Figma, you already know FigCraft.
+ The toolbar, layers panel, Design panel, menus and shortcuts sit right where your hands expect them.
⚡ Native and fast
@@ -227,7 +234,7 @@ The desktop app also offers a loopback-only control channel (`figcraft --control
- **Its own renderer:** tiny-skia on every core for the canvas and exports, with layer blending, effects and masks; booleans from linesweeper, geometry from kurbo, text from skrifa and HarfRust.
- **Runs in the browser:** the whole engine and UI compile to WebAssembly.
- **Accessible:** screen readers get names, roles, values and states for the tools, layer rows, fields, dropdowns, tabs and menus (AccessKit on desktop), F6 moves the keyboard between the toolbar, layers, canvas and properties (Tab within them, Escape back to the canvas), the system's reduce-motion setting is honoured, and panel text meets WCAG AA contrast in both themes.
-- **Languages:** English, Russian and Turkish (reviewed by native speakers), and Spanish, French, German, Brazilian Portuguese, Japanese, Korean, Simplified Chinese, Czech and Indonesian drafts, picked in Preferences or taken from the system or browser and switched live; adding a language is one catalog file ([`docs/translating.md`](docs/translating.md)).
+- **Languages:** English, Russian and Turkish (reviewed by native speakers), and Spanish, French, German, Brazilian Portuguese, Japanese, Korean, Simplified Chinese, Czech, Indonesian and Georgian drafts, picked in Preferences or taken from the system or browser and switched live; adding a language is one catalog file ([`docs/translating.md`](docs/translating.md)).
- **Plugins:** sandboxed WebAssembly plugins (a metered, pure-Rust interpreter with a memory cap and no file or network access, in the browser too) that act through the same commands, each run one undo step, within the permissions their manifest asks for. A Rust SDK and three example plugins are in [`plugins/`](plugins); see [`docs/plugins.md`](docs/plugins.md).
- **Live sessions (preview):** share the open file from the app (Share ▸ Start sharing: online through a server, or on your local network), give the others the short join code it shows (or the invite link), and edit it together: everyone's changes sync live, with cursors, selections, avatars and follow, and undo takes back only your own changes. Others join from the desktop app (invite links open it) or from the browser build. See [`docs/collab-protocol.md`](docs/collab-protocol.md).
- **A server of your own (preview):** `figcraft-server` keeps a team's files, publishes them from the app (File ▸ Publish to server…, or Share ▸ Online with your server in Preferences) and hands out share links and join codes that let people edit or only view; files survive restarts and apps reconnect where they were. No accounts yet: links are the access. Releases ship it for Linux, and the desktop app joins over `wss://`; [hosting it on a rented Linux server](docs/server.md#deploy-on-a-linux-server) takes a systemd unit and Caddy or nginx (or Docker). See [`docs/server.md`](docs/server.md).
@@ -262,7 +269,7 @@ New contributors and AI agents: start with [`AGENTS.md`](AGENTS.md), then [`docs
Installers for macOS (universal, signed and notarized), Windows (x64, x86 and arm64), Linux (AppImage, `.deb`, `.rpm`, Flatpak and tarball), FreeBSD and the web are attached to each [GitHub release](https://github.com/storytold/figcraft/releases). Maintainers: [`docs/releasing.md`](docs/releasing.md) explains how releases are built, signed and published.
> [!IMPORTANT]
-> **Status:** FigCraft is in **alpha**: about 49% of the way to replacing Figma for real work, by our own estimate. Nearly all of Figma's main menu is wired ([`docs/parity-checklist.md`](docs/parity-checklist.md)) and the core editor works end to end, but FigCraft opens `.fig` files only best effort, has only a first preview of multiplayer (live sessions hosted from the app or a self-hosted server, with per-person undo and share links to edit or to view; no accounts, teams or cloud yet), runs its own WebAssembly plugins rather than Figma's, and hasn't been checked against real Figma documents. The honest, area-by-area picture is in the [roadmap](ROADMAP.md) and [`docs/target-app-parity.md`](docs/target-app-parity.md). Expect rough edges and please file issues, or tell us what broke on [Discord](https://discord.gg/artcraft).
+> **Status:** FigCraft is in **alpha**: about 49% of the way to replacing proprietary tools for real work, by our own estimate. Nearly all tracked interface design actions in the menu checklist are wired ([`docs/parity-checklist.md`](docs/parity-checklist.md)) and the core editor works end to end, but FigCraft opens `.fig` files only best effort, has only a first preview of multiplayer (live sessions hosted from the app or a self-hosted server, with per-person undo and share links to edit or to view; no accounts, teams or cloud yet), runs its own WebAssembly plugins, and hasn't been checked against real design documents. The honest, area-by-area picture is in the [roadmap](ROADMAP.md) and [`docs/target-app-parity.md`](docs/target-app-parity.md). Expect rough edges and please file issues, or tell us what broke on [Discord](https://discord.gg/artcraft).
## Privacy and online sharing
@@ -348,8 +355,6 @@ ArtCraft Team and are not covered by this license. They may be used only unmodif
part of this repository and FigCraft, under [`docs/brand/LICENSE-brand.txt`](docs/brand/LICENSE-brand.txt).
Forks and modified versions must remove them.
-Figma is a trademark of Figma, Inc. FigCraft is an independent, open-source project and is not affiliated with, sponsored by or endorsed by Figma, Inc.; the name is used only to describe the workflows FigCraft is compatible with.
-
Made by the ArtCraft team and community.
diff --git a/ROADMAP.md b/ROADMAP.md
index f3c4bb14..d32eb906 100644
--- a/ROADMAP.md
+++ b/ROADMAP.md
@@ -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-10-17 · **Change:** minor (Outline stroke preserves stroke holes; community batch #753: Selection colors, smart-selection spacing, a Present tab; language table re-measured from the catalogs; community fixes from #524 up (55 PRs: `.fig` import fidelity, paste from other apps, the Actions palette, editor fixes, server limits) and a boolean-op crash guard; number variables in the text content picker (#629); frames and sections convert into each other (#719); bounded canvas pan overscan; community fixes from #478 up and a control-channel fix (#589); bounded canvas pan overscan; Typography spacing icons support scrubbing (#373); font scans skip named pipes; system theme on first run; recent files as cards with thumbnails on the home screen; community fixes: lost images reported on loading (#207), SVG import budgets (#190), Leptos code (#223), full screen (#227), server snapshots readable again (#188), owner-only preferences (#200), ruzstd 0.9.1 (#182), layer cycle repair (#205), batch rollback, Direct3D 12 on Windows, plugin metering (#192); vector edit mode regions: hover hatch, selection and drag; SVG/PDF exports refuse over-depth documents (#208); bounded MCP/control framing, connections and queues (#201); plugin log limits (#191); live-session revert guard (#198); attached MCP no longer replays after a lost reply (#194); repeat command recursion fix; the Layout panel's constrain-proportions link scales the other side, #220; core editor leftovers: component playground, auto gap handles, variables inside styles, inner shadows and background blur on groups, command-made text readable on dark pages, a one-step frame/group convert, delays on mouse triggers and manual overlay offsets, wrapped-line alignment; `.fig` export: instance sizes, variables with modes, shared styles, variable-width strokes; starter templates, a Templates tab and Getting started tips on the home screen; your online files; everyday editing partials: number fields, outline options, Hide when publishing, cursors, panel widths, dark pages; sharing with a join code; text box sizes measured against documents re-saved by other software; live sessions per document; .fig export checked by opening written files in other software; a public figcraft-server: open hosting, owner tokens, per-address limits, idle expiry, moderation, install.sh; experimental .fig export; keyboard shortcut parity suite and bindings; Simplified Chinese draft catalog; Latin American Spanish overlay; prototyping tail: gamepad triggers, widgets in prototypes, mode lookups; plugin directory on figcraft-server; Japanese and Korean draft catalogs and CJK UI fonts; plugin widgets and the plugin panel tail; French, German and Brazilian Portuguese draft catalogs; cursor chat and spotlight in live sessions; layers and assets panels behaviour suite and fixes; vector multi-edit and edit tail; dev resources links; extended collections tail; branch version history and finer list merges; headline percentages recomputed from the area table: feature breadth ~84%, core ~94%, mainstream ~50%; text lists, hanging punctuation and decoration styles; comments and version history behaviour suite and fixes; canvas navigation, guides and grids behaviour suite and fixes; export and inspect behaviour suite and fixes; .fig import: editable vector networks and more layer kinds; shapes and vector behaviour suite and fixes; paint and effects behaviour suite and fixes; frames, groups, sections and masks behaviour suite and fixes; styles and variables behaviour suite and fixes; prototyping behaviour suite and fixes; components behaviour suite and fixes; embedded image colour profiles; layers panel keyboard: F2 rename, Shift+F10 context menu, keyboard box selection, 10k-layer QA; per-side stroke weight variables; text behaviour suite: CJK line breaking, metrics, vertical trim; selection and transform behaviour suite and fixes; `.fig` import, best effort; Windows QA pass with eight fixes; auto layout behaviour suite and fixes; Display P3: gamut warning and soft-proof (true P3 blocked upstream); several windows; localization layer with a draft Spanish catalog; hosting figcraft-server: wss in the desktop app, server releases, deployment guide; plugin panels and settings; canvas fixes: boolean hit testing on the result, group drags, frame outlines and slices; code connect; stretch and scatter brushes, pen pressure; text on a path and pattern fills; team libraries on the server and swap library; branches: create, update from main, review and merge; animated GIF fills and TIFF images; Open recent, outlines for the selection and mask outlines: menu breadth 100%; extended collections, variables import/export, gradient stop and variant bindings; feature breadth ~80%; ready ~49%) · **Target:** Figma Design (desktop app 126.10.7)
+> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-22 · **Change:** minor (boards: a board area row and progress entry; `fill`/`stroke` props accept `"none"` and `null` as no paint (#1036); community batch #753: Selection colors, smart-selection spacing, a Present tab; language table re-measured from the catalogs; community fixes from #524 up (55 PRs: `.fig` import fidelity, paste from other apps, the Actions palette, editor fixes, server limits) and a boolean-op crash guard; number variables in the text content picker (#629); frames and sections convert into each other (#719); bounded canvas pan overscan; community fixes from #478 up and a control-channel fix (#589); bounded canvas pan overscan; Typography spacing icons support scrubbing (#373); font scans skip named pipes; system theme on first run; recent files as cards with thumbnails on the home screen; community fixes: lost images reported on loading (#207), SVG import budgets (#190), Leptos code (#223), full screen (#227), server snapshots readable again (#188), owner-only preferences (#200), ruzstd 0.9.1 (#182), layer cycle repair (#205), batch rollback, Direct3D 12 on Windows, plugin metering (#192); vector edit mode regions: hover hatch, selection and drag; SVG/PDF exports refuse over-depth documents (#208); bounded MCP/control framing, connections and queues (#201); plugin log limits (#191); live-session revert guard (#198); attached MCP no longer replays after a lost reply (#194); repeat command recursion fix; the Layout panel's constrain-proportions link scales the other side, #220; core editor leftovers: component playground, auto gap handles, variables inside styles, inner shadows and background blur on groups, command-made text readable on dark pages, a one-step frame/group convert, delays on mouse triggers and manual overlay offsets, wrapped-line alignment; `.fig` export: instance sizes, variables with modes, shared styles, variable-width strokes; starter templates, a Templates tab and Getting started tips on the home screen; your online files; everyday editing partials: number fields, outline options, Hide when publishing, cursors, panel widths, dark pages; sharing with a join code; text box sizes measured against documents re-saved by other software; live sessions per document; .fig export checked by opening written files in other software; a public figcraft-server: open hosting, owner tokens, per-address limits, idle expiry, moderation, install.sh; experimental .fig export; keyboard shortcut parity suite and bindings; Simplified Chinese draft catalog; Latin American Spanish overlay; prototyping tail: gamepad triggers, widgets in prototypes, mode lookups; plugin directory on figcraft-server; Japanese and Korean draft catalogs and CJK UI fonts; plugin widgets and the plugin panel tail; French, German and Brazilian Portuguese draft catalogs; cursor chat and spotlight in live sessions; layers and assets panels behaviour suite and fixes; vector multi-edit and edit tail; dev resources links; extended collections tail; branch version history and finer list merges; headline percentages recomputed from the area table: feature breadth ~84%, core ~94%, mainstream ~50%; text lists, hanging punctuation and decoration styles; comments and version history behaviour suite and fixes; canvas navigation, guides and grids behaviour suite and fixes; export and inspect behaviour suite and fixes; .fig import: editable vector networks and more layer kinds; shapes and vector behaviour suite and fixes; paint and effects behaviour suite and fixes; frames, groups, sections and masks behaviour suite and fixes; styles and variables behaviour suite and fixes; prototyping behaviour suite and fixes; components behaviour suite and fixes; embedded image colour profiles; layers panel keyboard: F2 rename, Shift+F10 context menu, keyboard box selection, 10k-layer QA; per-side stroke weight variables; text behaviour suite: CJK line breaking, metrics, vertical trim; selection and transform behaviour suite and fixes; `.fig` import, best effort; Windows QA pass with eight fixes; auto layout behaviour suite and fixes; Display P3: gamut warning and soft-proof (true P3 blocked upstream); several windows; localization layer with a draft Spanish catalog; hosting figcraft-server: wss in the desktop app, server releases, deployment guide; plugin panels and settings; canvas fixes: boolean hit testing on the result, group drags, frame outlines and slices; code connect; stretch and scatter brushes, pen pressure; text on a path and pattern fills; team libraries on the server and swap library; branches: create, update from main, review and merge; animated GIF fills and TIFF images; Open recent, outlines for the selection and mask outlines: menu breadth 100%; extended collections, variables import/export, gradient stop and variant bindings; feature breadth ~80%; ready ~49%) · **Target:** Figma Design (desktop app 126.10.7)
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
@@ -50,7 +50,7 @@ against real Figma documents. Ready-for-real-work is ~53%, inside alpha's ~40–
~75% **and** reliable `.fig` import: the `.fig` import's tail (5–10 h), a real-file corpus with measured
fidelity (15–30 h), the interaction pass (25–40 h of the 40–60), core depth to ~80% (40–75 h),
basic multiplayer on the landed core (30–55 h), stability and platform QA (20–40 h), a partial GPU path (15–30 h);
-native speakers' reviews of the six language drafts need people.
+native speakers' reviews of the nine language drafts need people.
## By dimension
@@ -63,7 +63,7 @@ native speakers' reviews of the six language drafts need people.
| Stability | 55% | 20–40 | [gaps](docs/gaps.md) |
| Performance | 60% | 30–60 | [hardware-parity](docs/hardware-parity.md) |
| Hardware | 60% | 10–21 | [hardware-parity](docs/hardware-parity.md) |
-| Localization | 39% (layer; English; Spanish with a Latin American overlay, French, German, Brazilian Portuguese, Japanese, Korean, Simplified Chinese drafts; CJK UI fonts) | 29–51 | [localization-parity](docs/localization-parity.md) |
+| Localization | 39% (layer; English; Russian and Turkish reviewed by native speakers; Spanish with a Latin American overlay, French, German, Brazilian Portuguese, Japanese, Korean, Simplified Chinese, Indonesian and Czech drafts; CJK UI fonts) | 29–51 | [localization-parity](docs/localization-parity.md) |
| Platforms | 75% | 10–20 | [hardware-parity](docs/hardware-parity.md) |
| Ecosystem / plugins | 38% (own WASM plugins with panels, settings and widgets; a self-hosted plugin directory) | 8–26 | [gaps](docs/gaps.md) |
| AI features | 0% | 30–60 | [gaps](docs/gaps.md) |
@@ -86,13 +86,14 @@ native speakers' reviews of the six language drafts need people.
| Styles & variables | 95% | 76% | 2–4 | [components-parity](docs/components-parity.md) |
| Prototyping | 92% | 74% | 2–5 | [prototyping-parity](docs/prototyping-parity.md) |
| Import/export | 86% | 58% | 5–10 | [file-format-parity](docs/file-format-parity.md) |
-| Dev Mode / inspect | 96% | 72% | 0–1 | [dev-mode-parity](docs/dev-mode-parity.md) |
+| Dev Mode / inspect | 97% | 76% | 2–4 | [dev-mode-parity](docs/dev-mode-parity.md) |
| Comments, versions, misc | 87% | 63% | 1–3 | [collaboration-parity](docs/collaboration-parity.md) |
| Multiplayer & sharing | 17% | 5% | 42–84 | [collaboration-parity](docs/collaboration-parity.md) |
| Plugins & widgets | 60% | 35% | 8–26 | [plugins](docs/plugins.md) |
| Team libraries | 70% | 40% | 4–8 | [components-parity](docs/components-parity.md) |
| Figma Draw extras | 88% | 60% | 1–3 | [gaps](docs/gaps.md) |
| AI features | 0% | 0% | 30–60 | [gaps](docs/gaps.md) |
+| Boards (whiteboarding; not in the weighted numbers) | ~35% | ~20% | 30–60 | [boards-parity](docs/boards-parity.md) |
## Languages
@@ -126,16 +127,25 @@ Ranked; detail and milestones in [`docs/roadmap.md`](docs/roadmap.md).
1. `.fig` import's tail: fixes from real files, connector labels, table cells, filled areas with their own fills (the best-effort import, editable vector networks, the other layer kinds and variable prototype actions landed 2026-10-11): 5–10 h; then checking the rest of the experimental `.fig` export (landed 2026-10-12; written files open and draw in other software) on effects, images, prototypes and real files: 5–15 h.
2. Real-file corpus and measured fidelity: 15–30 h.
3. Tool-by-tool interaction pass against Figma: 40–60 h.
-4. Languages: native reviews of the es, fr, de, pt-BR, ja and ko drafts (people), Latin American Spanish (1–2 h), then Simplified Chinese (3–5 h).
+4. Languages: native reviews of the es (with es-419), fr, de, pt-BR, ja, ko, zh-Hans, id and cs drafts (people), the entries added since each catalog was written, then Hindi, Vietnamese and Arabic ([localization-parity](docs/localization-parity.md)).
5. Multiplayer (M9): accounts and teams on top of the live sessions and the standalone server (transport, hosting, invite links that open the app, document sync, presence with remote text carets, cursor chat and spotlight, per-user undo, reconnect with offline edits, collision-free ids for styles, variables and comments, the browser client, `figcraft-server` with persistence and share links to edit or view, team libraries on the server landed): 42–84 h.
## Progress log
+- **2026-10-24** · Boards (M12): File ▸ New board makes a board, a file kind of its own saved in `.figcraft` and carried to people joining a live session. Sticky notes (8 colours, text that shrinks as the note grows, the author's name, Shift+Cmd/Ctrl+Enter for the next one), shapes with text (7 outlines), connectors that re-route when what they join moves (computed in the engine's normalize pass, so local edits, undo and others' edits agree), marker, highlighter and eraser, stamps with the placer's name on hover; a board toolbar, a contextual bar over the selection and the Design panel hidden until asked for; prototyping and Dev Mode refuse on boards. Design files and boards have their own marks (a pen nib, a note) on tabs, the home screen and the Open files list. Checked in the app, with two app instances in one live session, and through MCP; the web build compiles ([boards-parity](docs/boards-parity.md)).
+- **2026-10-15** · Auto-save (M1, #305): Preferences ▸ Save files automatically (`pref.autoSave`, off by default, desktop only) saves each open file that has a path 3 s after its last change, never during a gesture, a live text preview or while a version is shown; the file is encoded off the UI thread, a failed save says why and is tried again a minute later. Numbers unchanged.
+- **2026-10-15** · A text box by dragging (M1, #363): a drag with the Text tool makes a fixed-size text box the size of the drag; a click still makes auto-width text. Numbers unchanged.
+- **2026-10-15** · Batch step references (M0.9, #400): a `command.batch` step can use the id an earlier step made (`{"$step": n}`, a reserved key), so a nested tree takes one call and one undo step. Numbers unchanged.
+- **2026-10-15** · Removing someone from a live session (M9, #338): the host or the file's owner removes a person from the avatar's menu or with `collab.removePerson`; they keep their copy and can't rejoin while the session runs. Numbers unchanged.
+- **2026-10-15** · Languages (M10, #257, #263, #469, #477, #288): Russian (one/few/many plurals) and Turkish catalogs reviewed by native speakers, Czech and Indonesian drafts, the Japanese draft completed; Preferences ▸ Language lists 12 languages and Latin American Spanish. Numbers unchanged.
+- **2026-10-15** · Zoom previews (M8, #312): when renders from scratch are slow, a new zoom shows the whole view coarsely first, then refines it. Numbers unchanged.
+- **2026-10-15** · Web clipboard (M1, #375): copy and paste in the browser go through the system clipboard. Numbers unchanged.
+- **2026-10-15** · Alt-drag copies snap to their original and Duplicate (Cmd+D) repeats the last copy's offset (M1, #283). Numbers unchanged.
+- **2026-10-22** · `fill` and `stroke` props accept `"none"` and `null` (M1, #1036): `node.create`, `node.set` and the other prop appliers map them to an empty fills/strokes list, as `fills: []` already did, so an outline-only shape is one call (agents write `"none"` for no paint; the empty-list form was undocumented). The parameter docs (`KEYS`, shown by `list_commands` and the CLI) and `docs/mcp.md` say so, and the error message names the accepted forms. `fill_none_tests` covers create, set, undo, text and the error. Numbers unchanged.
- **2026-10-17** · Control channel while the window is minimised (M8, #720): a minimised or covered window answers every request that acts on the app's state (edits, `ui.inspect`, `ui.pointer`, `ui.key`, `ui.type`, `ui.set`, `app.quit`…) without drawing, and what needs a drawn frame (`ui.screenshot`, `ui.input`, `window.new`) is an error at once; before, those waited up to 60 s and held up every later request on the connection (an attached agent's `inspect_ui` or window screenshot stalled until the window came back). Measured on Windows 11, minimised: requests ~100 ms each (eframe wakes a minimised window at most ten times a second; ~2 ms on screen), a window screenshot fails in ~100 ms instead of 60 s, idle CPU 0. Numbers unchanged.
- **2026-10-17** · Number variables on text content (M3, #629): the Typography section's variable picker also lists number variables for a text layer's content, as the engine already accepted (the text shows the number, e.g. 42.5, and follows the variable). Other text fields keep their own types. Numbers unchanged.
- **2026-10-17** · Frames and sections convert into each other (M1, #719): `object.convertToSection` turns a frame on the page or in a section into a section in place (same box, name, fill and layers, which stay where they are; what only a frame has goes: auto layout, clipping, layout grids, guides, scrolling), and `object.convertToFrame` now also turns a section into a frame that keeps its fill and doesn't clip, so the look stays. Nested frames, instances, main components and sections holding sections are refused with the reason; one undo step each. Both are in the canvas context menu (Convert to section / Convert to frame) and in Spanish. Numbers unchanged.
-- **2026-10-15** · M4: Outline stroke preserves even-odd stroke holes. Pixel comparisons cover alignment, dashes, individual side weights, vector paths and stroke-only opacity; native save/reopen, Undo/Redo and instance opacity inheritance/overrides are covered by `outline_stroke`. Existing estimates unchanged; filled-shape compositing needs separate work.
-
+- **2026-10-15** · Dev Mode tail (M6, gap 16): generated layer trees start with the import lines of the connected components they call, once each per language; Compare changes takes any saved version as the before; a behaviour suite made the Dev Mode canvas inspect-only (no moving, resizing, drawing or editing; menus and shortcuts refuse design edits with a note), added Changed to the ready list and refused statuses on layers inside frames; read-only plugins show their panels from the Inspect tab. Dev Mode 97% / 76%.
- **2026-10-14** · Corner handles win over the corner-radius handles (M1, #292): a press on the inner half of a corner handle's square picked the radius handle 10 px in, so the drag neither resized nor (dragging outward) rounded anything. Inside the drawn square the corner now resizes both sides (in ratio with Shift or the link); further in the radius handle still answers. Regression test in the transform behaviour suite. Numbers unchanged.
- **2026-10-14** · Home screen recent files as cards (M7): each card shows the picture its file carries on its first page's colour, the file's icon, name and "Edited ... ago"; sort by name, creation or last change either way; a table view; a click selects, a double-click or Enter opens, arrow keys move; Open, Show in folder and Remove from recents on right-click. Numbers unchanged.
- **2026-10-13** · Vector edit mode regions (M4): with the Move tool, the filled area under the pointer is hatched with "/" lines in the selection colour, clipped by the area's own fill rule so holes stay clear; the hatch goes near points (3.5 px) and segments (2 px), and its spacing follows octave folding (8 px at every power-of-two zoom), fixed to the shape. A click selects the area with its points (they move with it but keep the unselected look), Shift adds or removes one, a press on a selected area drags the whole selection as one undo step, and a click on an empty spot clears the areas and stays in edit mode. `vector.edit.select {regions}` and `vector.edit.state` (`regions`, `regionVertices`, `regionHover`); `vector_regions_tests` and `regions_tests`. Numbers unchanged.
@@ -318,6 +328,64 @@ Ranked; detail and milestones in [`docs/roadmap.md`](docs/roadmap.md).
| Date | Change | Summary |
|---|---|---|
+| 2026-10-24 | minor | Boards (M12): a file kind of its own (`file.newBoard`, saved in `.figcraft`, carried to live-session joiners) with sticky notes, shapes with text, connectors that re-route when what they join moves (an engine recompute, the same for local edits, undo and others' edits), marker, highlighter and eraser, stamps with the placer's name, a board toolbar and a contextual bar; prototyping and Dev Mode refuse on boards; design files and boards have their own marks on tabs and file rows. Boards row added outside the weighted numbers; headline numbers unchanged at this rounding |
+| 2026-10-15 | minor | Auto-save (#305, #296): Preferences ▸ Save files automatically (`pref.autoSave`, off by default; desktop only, the browser has no files to save to) saves each open file that has a path 3 s after its last change, so steady editing doesn't save every few seconds, and never during a gesture, a live text preview or while a version is shown. The file is encoded on a thread of its own and written as of that moment (edits made meanwhile stay unsaved); a failed save says why in a toast and is tried again a minute later, and version history checkpoints keep coming with it on. Numbers unchanged |
+| 2026-10-15 | minor | A text box by dragging (#363, #360): a drag with the Text tool makes a fixed-size text box the size of the drag (at least one line tall); a click, or a drag shorter than the drag threshold, still makes auto-width text. Numbers unchanged |
+| 2026-10-15 | minor | Batch step references (#400): inside `command.batch` (MCP `batch`), `{"$step": n}` anywhere in a step's params stands for the `id` step n returned (`{"$step": n, "field": …}` for another field; `$step` is a reserved key), so a frame with its children takes one batch and one undo step; a malformed reference fails the batch, which rolls back, and a nested batch keeps references to its own steps. Numbers unchanged |
+| 2026-10-15 | minor | Removing someone from a live session (#338): right-click a person's avatar ▸ Remove *name* from session, or `collab.removePerson {client}`, when you host the session or own the file on a server; the session ends for them (they keep their copy), the code or link they hold no longer gets them back in while it runs, and everyone else stays. Numbers unchanged |
+| 2026-10-15 | minor | Pages list (#272, #258): a long pages list scrolls in its own area, so the layers below stay in view; page and layer drops count only inside the list's visible rows. Numbers unchanged |
+| 2026-10-15 | minor | Variables export in the browser (#368): Export… ▸ Variables JSON / CSS custom properties did nothing in the web build and now arrives as a download; importing there still needs a file picker. Numbers unchanged |
+| 2026-10-15 | minor | Font picker keys (#352, #345): Up and Down step through the font families from the current one, keeping the highlight in view and previewing it on the canvas; Enter applies it, Escape leaves the text as it was. Numbers unchanged |
+| 2026-10-15 | minor | Leaving Design ends the pen path (#308, #307): switching to Prototype or Inspect while the Pen draws ends the path and goes back to Move (pressing Design again keeps drawing), and a click on the toolbar no longer reaches the canvas under it. Numbers unchanged |
+| 2026-10-15 | minor | Vector edit mode keeps the canvas still (#322): the edit mode hints in the Design panel wrap, so entering edit mode and picking a region no longer shift the canvas by about 25 points in the middle of the click (which dragged the region picked). Numbers unchanged |
+| 2026-10-15 | minor | Drop shadows under a background blur (#317, #255): a layer with both casts its shadows from what it paints (a translucent fill casts a lighter shadow than an opaque one) and reads the backdrop only after drawing them, so a shadow shown behind transparent areas is seen through the blur. Numbers unchanged |
+| 2026-10-15 | minor | When the window can't open (#306, #261): Windows release builds have no console, so a graphics failure at start quit without a word; the error is now logged and shown in a message box in the interface language, with what to try (unset `WGPU_BACKEND`, update the driver, OpenGL) and where to report it, skipped with `--control`. Numbers unchanged |
+| 2026-10-15 | minor | Crashes on Windows (#271, #314, #337; #224 and two more): a text field focused before it was drawn aborted the screen-reader layer; double-clicking a page, creating a variable collection and renaming a style folder no longer close the app. Numbers unchanged |
+| 2026-10-15 | minor | Deeply nested layers (#330, #210): one depth guard (256) on the three recursive layout paths, so a deep file can't run the layout out of stack. Numbers unchanged |
+| 2026-10-15 | minor | Image memory budgets (#326; #203, #189): decoded images and a file's images have budgets; the decode cache evicts its least recently used entries. Numbers unchanged |
+| 2026-10-15 | minor | macOS file dialogs (#253, #250) no longer re-enter the event loop; a dialog's result goes to the file and window it was opened for, and dialogs are parented to the main window. Numbers unchanged |
+| 2026-10-15 | minor | Recovery copies (#297, #303, #331, #336; #202, #185, #187): a copy counts only after its write succeeds and a failed one is retried; saves and closes wait for the write in flight; copies keep version history and branches; a recovered copy stays until this run has its own. Numbers unchanged |
+| 2026-10-15 | minor | Text edits (#280, #278) no longer roll back earlier changes; a drag released off the canvas ends at the pointer's last canvas position. Numbers unchanged |
+| 2026-10-15 | minor | Rollback (#282, #301; #196): a failed command rolls back during a drag or other gesture too; a failed batch keeps the redo steps. Numbers unchanged |
+| 2026-10-15 | minor | Atomic save and export (#284): staging files are uniquely named and created exclusively, so a file or link already at the old fixed staging name is never written through, and two writers of one file no longer share one. Numbers unchanged |
+| 2026-10-15 | minor | Alt-drag copies (#283) snap to their original, and Duplicate (Cmd+D) then repeats the last copy's offset. Numbers unchanged |
+| 2026-10-15 | minor | The pen (#277) shows its Bezier handles while a point is dragged out. Numbers unchanged |
+| 2026-10-15 | minor | Corner handles (#293, #292): a press on a corner handle resizes instead of picking the corner-radius handle. Numbers unchanged |
+| 2026-10-15 | minor | New text (#372, #362) takes a readable colour from the frame it is drawn in, not only the page (text drawn in a white frame on a dark page was white). Numbers unchanged |
+| 2026-10-15 | minor | Outline stroke (#386) works on every selected layer. Numbers unchanged |
+| 2026-10-15 | minor | Send to back (#444) counts per parent when the selection spans frames. Numbers unchanged |
+| 2026-10-15 | minor | Align buttons (#276) are off when the selection has nothing to align to. Numbers unchanged |
+| 2026-10-15 | minor | Gradient type icons (#275) show their gradient. Numbers unchanged |
+| 2026-10-15 | minor | Corner resize cursors (#388) stay diagonal at any proportions; the text selection highlight (#390) stays inside the box on the last line. Numbers unchanged |
+| 2026-10-15 | minor | New pages (#311, #295) take the current page's background; the theme still decides a new file's page. Numbers unchanged |
+| 2026-10-15 | minor | A slice's export preview (#265) shows the content under it. Numbers unchanged |
+| 2026-10-15 | minor | SVG export (#327, #325) keeps a nested frame's fill and stroke inside its parent's clip. Numbers unchanged |
+| 2026-10-15 | minor | Home screen (#318, #324): recent files notice files deleted while it is open; a long path no longer draws over the file name. Numbers unchanged |
+| 2026-10-15 | minor | The Small caps sample in Type settings (#355) draws from capitals, no longer a box where the UI font lacks the small-capital letter. Numbers unchanged |
+| 2026-10-15 | minor | Web clipboard (#375): copy and paste in the browser go through the system clipboard, so a paste after a copy brings the copied layers instead of whatever text the clipboard held. Numbers unchanged |
+| 2026-10-15 | minor | Zoom previews (#312): when renders from scratch are slow, a new zoom first shows the whole view coarsely instead of the page colour, then the refined image; images of another file or page never show. Numbers unchanged |
+| 2026-10-15 | minor | Hidden windows (#313, #332; #269): a minimised or covered window answers control and MCP requests (commands, inspection, `ui.render`) at once, each window on its own; screenshots and input still wait for it to be on screen. Numbers unchanged |
+| 2026-10-15 | minor | Server (#340, #302): a compaction cut short closes the file instead of confirming lost edits (#183); each team library version is kept in its own file (#206). Numbers unchanged |
+| 2026-10-15 | minor | Counters (#343, #344, #353; #309): collab sequence numbers, layer name counters and opacity digits can't overflow. Numbers unchanged |
+| 2026-10-15 | minor | Commands refuse bad indexes and ids (#475, #384, #310): `page.select` and `doc.switch`, `effect.set` and `export.update` / `export.remove`, `page.move` with a non-page id. Numbers unchanged |
+| 2026-10-15 | minor | Find and replace (#358, #361) changes every occurrence, case-insensitively, also when the replacement contains the search text. Numbers unchanged |
+| 2026-10-15 | minor | The gradient shorthand (#254, #252) is read by the engine, so the CLI, control channel and MCP share it. Numbers unchanged |
+| 2026-10-15 | minor | .fig import (#279, #281): resized instances lay out their layers by their constraints (#266); explicit variable modes whose collection is named by its asset key, as library collections are, come across (#267). Numbers unchanged |
+| 2026-10-15 | minor | Colour emoji (#300, #268) draw from their own colour tables (sbix and CBDT/EBDT bitmap strikes, COLR v0 layers), a colour face tried first; COLR v1 still draws outlines. Numbers unchanged |
+| 2026-10-15 | minor | macOS (#290, #289): `.figcraft` files open from Finder, Open With and the Dock. Numbers unchanged |
+| 2026-10-15 | minor | Windows (#294, #291): the first preferred language alone picks the UI language. Numbers unchanged |
+| 2026-10-15 | minor | Unix font discovery (#474) follows `XDG_DATA_HOME`. Numbers unchanged |
+| 2026-10-15 | minor | Linux packaging (#346, #328): the window id matches the desktop entry (FreeBSD keeps its class); the RPM requires glibc 2.35. Numbers unchanged |
+| 2026-10-15 | minor | Tests (#472, #471, #339): the rename shortcut test, the hanging punctuation test and the font-scanning tests no longer depend on the platform, font or test order. Numbers unchanged |
+| 2026-10-15 | minor | Languages (#257, #263, #469, #477, #288): Russian (with one/few/many plural forms) and Turkish catalogs, reviewed by native speakers; Czech and Indonesian drafts; the Japanese draft completed. 2,177 entries now (1,587 UI strings, 559 command labels, 31 menu wordings); strings added since a catalog was written read English there. Localization 39% and 29–51 h unchanged at this rounding (Indonesian is now a draft, while the five older drafts lack 88 newer entries) |
+| 2026-10-22 | minor | Type settings keeps its width (#1029): in languages whose labels run past the 110 px label column (French "Retrait de paragraphe", "Espacement de liste"), the List spacing, Paragraph indent, Max lines and decoration rows were wider than the popover, which then widened every frame while open. Those fields now take the width left after their label; English is unchanged. Regression test in `type_settings_tests`. Numbers unchanged. |
+| 2026-10-22 | minor | `fill`/`stroke` props accept `"none"` (either case) and `null` as no paint (M1, #1036): mapped to an empty fills/strokes list, as `fills: []` already did (undocumented), so an outline-only shape is one call; `KEYS` and `docs/mcp.md` document it, the error names the accepted forms, `fill_none_tests` covers create, set, undo, text and the error. Numbers unchanged |
+| 2026-10-20 | minor | A document dropped on the canvas opens (#916): a `.figcraft`, `.fig` or file JSON dropped on the canvas opens as a file of its own, as on the home screen, in the browser too; it used to add its pages to the file in front. Images and SVG still import at the drop point, File ▸ Import still adds pages, and dragging only documents over the canvas says "Drop to open" (not in the browser, which names no file until the drop). Numbers unchanged |
+| 2026-10-20 | minor | Duplicating a main component makes an instance (#892): Duplicate and Alt-drag copied a main component as a second main; within its file the copy is now an instance of it, as Copy then Paste already was (a variant duplicated in its set stays a variant). Numbers unchanged. |
+| 2026-10-20 | minor | Readable disabled and selected text (#890): the dim text colour (disabled buttons, placeholders, hints) is at least 3:1 against panels, fields and selected rows in both themes (it was 2.1:1 in the light theme), a disabled button is grey with that text instead of fading to 40%, and selected text (renaming a page or layer, any text box) takes the theme's readable green on the highlight (1.4:1 in the dark theme before, now 4.2:1 or more); checked with the colour contrast helper (`theme::tests`). Numbers unchanged |
+| 2026-10-20 | minor | Layer data reads back (#879): `node.get` (the command, the control method and MCP `get_node`) and `document.inspect` report a layer's or page's `pluginData` as `{key: value}` when it has any, so a tool that keeps state in a file with `node.set {props: {pluginData}}` can read it on its next run (`plugin_data_tests`). Numbers unchanged |
+| 2026-10-20 | minor | Measuring while nudging (#894): with Alt held over another layer, the arrows nudge the selection (Shift: the big step) and the distances follow every nudge (Alt+arrows used to do nothing); while measuring, the selection's handles and size label hide and both layers keep their outlines (`measure_nudge_tests`). Numbers unchanged |
+| 2026-10-20 | minor | Release fonts (#885): the web release embeds craft-fonts again (Inter), so the browser version draws text and lists fonts; it had none since releases moved to the shared workflow. The craft-fonts pin goes back to the commit with the Latin manifest (the Georgian change had moved it to one without Inter, which would have failed the next release). Numbers unchanged. |
| 2026-10-17 | minor | Community batch #753 (10 PRs): Selection colors for mixed selections (#403); smart-selection spacing fields and canvas handles (#402); a Present tab with device and scale controls (#537); adding auto layout to an empty frame keeps its size (#369); `node.set` applies auto layout keys to frames only and warns about font styles a family lacks (#603); canvas images on whole device pixels (#359); Adwaita window controls on Wayland without server decorations (#592, not run on GNOME or KDE by the maintainers); the keyboard shortcuts panel closes on the home screen (#548); macOS paste modifiers in tests (#750); credits column tests (#347). `cargo xtask parity` re-run: 212 / 212 menu items (100%; the catalog gained View ▸ Full screen with #227 on 2026-10-14), 561 commands. Language table re-measured from the catalogs (2,272 entries): the drafts read 95–99% (strings added since 2026-10-12 show English), Indonesian has a draft (99%; it read none), and Russian, Swedish (its command labels from #599), Turkish and Czech are listed with their counts. Per-area parity rows for the day's landings in `docs/gaps.md`, `target-app-parity.md` and the area docs. Numbers unchanged |
| 2026-10-17 | minor | Control channel while the window is minimised (M8, #720): a minimised or covered window answers every request that acts on the app's state (edits, `ui.inspect`, `ui.pointer`, `ui.key`, `ui.type`, `ui.set`, `app.quit`…) without drawing, and what needs a drawn frame (`ui.screenshot`, `ui.input`, `window.new`) is an error at once; before, those waited up to 60 s and held up every later request on the connection (an attached agent's `inspect_ui` or window screenshot stalled until the window came back). Measured on Windows 11, minimised: requests ~100 ms each (eframe wakes a minimised window at most ten times a second; ~2 ms on screen), a window screenshot fails in ~100 ms instead of 60 s, idle CPU 0. Numbers unchanged. |
| 2026-10-17 | minor | Community fixes from #524 up (batches #727, #728, #733, #735, #736 and #729; 55 PRs) and a crash guard. `.fig` import: explicit instance identity, overrides by key, text style precedence, grid track sizes, slot content, connector labels, skip ink, paragraph options and hanging lists, list start numbers, vertical trim, per-point stroke joins, text on a path, image adjustments and embedded images; large files open within budgets from the file's own size; an import report after opening; imported bytes stay out of the command journal. Files and paste: save a copy as `.fig`; Cmd/Ctrl+V pastes images copied in other apps and layers copied from another design app (`edit.pasteDesignLayers`); paste over and paste properties; clipboard reads on Linux and the BSDs time out after 2 s. Editor: live font preview on hover; Shift+I and Resources open Assets; Shift-drag moves the selection; thin strokes take a nearby double-click; dropped points merge; Flatten keeps open paths; the Actions palette gets tabs, ranked search, a keyboard highlight and recents; the colour picker opens on a new fill or stroke; text strokes follow their alignment; selection highlights after line breaks; a draggable pages/layers divider; variant properties reorder by drag; submenus keep their hover with a safe triangle; menu actions that need a value ask for it; File ▸ Rename edits the name in place. Engine: bad paint indexes, non-finite geometry and pages in copy/cut are refused; a param naming a layer says so when it isn't one; a CLI script is one undo step and resolves `$step`. Server and collaboration: message limits follow `max_file_mb` (client capped at 1 GiB); a damaged generation field no longer drops flushed edits; the web build joins a session from a `#join=` link. Also Swedish command labels, Nix CI through the shared workflow, paint bounds once per render, and a guard that turns a panic inside the boolean-op library into bad input (the stroke draws unclipped). Numbers unchanged. |
@@ -325,9 +393,9 @@ Ranked; detail and milestones in [`docs/roadmap.md`](docs/roadmap.md).
| 2026-10-17 | minor | Frames and sections convert into each other (M1, #719): `object.convertToSection` turns a frame on the page or in a section into a section in place (same box, name, fill and layers, which stay where they are; what only a frame has goes: auto layout, clipping, layout grids, guides, scrolling), and `object.convertToFrame` now also turns a section into a frame that keeps its fill and doesn't clip, so the look stays. Nested frames, instances, main components and sections holding sections are refused with the reason; one undo step each. Both are in the canvas context menu (Convert to section / Convert to frame) and in Spanish. Numbers unchanged. |
| 2026-10-16 | minor | Community fixes from #478 up (batches #591, #598, #602; 69 PRs) and a control-channel fix: a line that isn't JSON now ends a `--control` connection, so a web page can't drive the app through a browser request (#589). Highlights: page copies keep navigation, flows, prototype settings and guides; Find and Replace keeps line endings and case-insensitive matches; text hyperlinks survive import and export; recent colours record only what was picked; MCP screenshots respect `maxSize`; Swedish catalog (UI strings), Czech plurals; bounded canvas overscan while panning; Korean fallback at the run's weight; many vector-edit, guide, page and .fig round-trip fixes. Numbers unchanged |
| 2026-10-15 | minor | Drop files anywhere to open them (M7): dragging files over the window shows a "Drop to open" (home) or "Drop to import" (canvas) overlay. On the home screen each supported file opens as a document of its own and other files are turned away with a toast; on the canvas the files import at the drop point. Both wait behind a small card that is on screen before a large file blocks the window. A canvas import stays with the document and page that received the drop even if the tab or page changes meanwhile, and is cancelled with a message if that document or page is gone. Numbers unchanged. |
-| 2026-10-15 | minor | M4: Outline stroke preserves even-odd stroke holes. Pixel comparisons cover alignment, dashes, individual side weights, vector paths and stroke-only opacity; native save/reopen, Undo/Redo and instance opacity inheritance/overrides are covered by `outline_stroke`. Existing estimates unchanged; filled-shape compositing needs separate work. |
| 2026-10-15 | minor | M7: system font discovery skips entries observed as non-regular files before opening them, avoiding the reproduced named-pipe stall. Regular-file symlinks remain supported; directory depth, font limits and priorities are unchanged. Numbers unchanged. |
| 2026-10-15 | minor | Canvas retains a bounded margin while panning so newly exposed strips can reuse the previous render. Numbers unchanged. |
+| 2026-10-15 | minor | Dev Mode tail (M6, gap 16): import lines for connected components inside generated layer trees (definitions, slots and swapped-in instances too); `dev.compare {version}` and the compare view's Compare with menu compare with any saved version; behaviour suite (5 tests; 4 failed before the fixes): an inspect-only Dev Mode canvas with menus, shortcuts, nudges, opacity keys and paste refusing design edits, toolbar drawing tools returning to the design, Changed in the ready list (`inspect.readyForDev {status: changed}`), statuses only on sections and top-level frames; read-only plugins' panels from the Inspect tab. Dev Mode 96%/72% → 97%/76%, 0–1 h → 2–4 h (measurements kept on the canvas and a read-only layers panel counted as missing); header totals not recomputed |
| 2026-10-15 | minor | Typography spacing icons scrub with the shared number-field gesture, modifier rates and one Undo step per drag (#373). Units and selected-character targeting are preserved. Numbers unchanged. |
| 2026-10-14 | minor | System theme on first run (M7): preferences without a theme default to System; the first frame reads the OS appearance directly, including when returning from a manual theme. Saved Light/Dark choices stay explicit; unavailable OS appearance falls back to Light. Numbers unchanged. |
| 2026-10-14 | minor | Home screen recent files as cards (M7): each card shows the picture its file carries on its first page's colour, the file's icon, name and "Edited ... ago"; sort by name, creation or last change either way; a table view; a click selects, a double-click or Enter opens, arrow keys move; Open, Show in folder and Remove from recents on right-click. Numbers unchanged. |
diff --git a/apps/figcraft-cli/src/args.rs b/apps/figcraft-cli/src/args.rs
index 4c162dbb..3fe17e80 100644
--- a/apps/figcraft-cli/src/args.rs
+++ b/apps/figcraft-cli/src/args.rs
@@ -1,6 +1,6 @@
//! Minimal std-only argument parsing: positionals, `--key value` / `--key=value` / `-o value`
//! options (given again: the last counts, or all with [`Args::values`]), and boolean `--flag`s.
-//! Unknown options are usage errors.
+//! Unknown options are usage errors; `--help` or `-h` is [`CliError::Help`].
use std::collections::BTreeMap;
@@ -16,6 +16,8 @@ pub struct Args {
impl Args {
pub fn parse(argv: &[String], valued: &[&str], flags: &[&str]) -> CliResult {
let mut a = Args::default();
+ // The first bad option, reported once the rest of the line is checked for `--help`.
+ let mut bad: Option = None;
let mut it = argv.iter();
while let Some(arg) = it.next() {
let name = if let Some(n) = arg.strip_prefix("--") {
@@ -30,19 +32,27 @@ impl Args {
Some((n, v)) => (n, Some(v.to_string())),
None => (name, None),
};
+ // `--help` / `-h` anywhere among the options (not as an option's value) asks for help.
+ if inline.is_none() && matches!(name, "help" | "h") {
+ return Err(CliError::Help);
+ }
if valued.contains(&name) {
- let v = match inline {
- Some(v) => v,
- None => it.next().cloned().ok_or_else(|| CliError::Usage(format!("`{arg}` needs a value")))?,
- };
- a.values.entry(name.to_string()).or_default().push(v);
+ match inline.or_else(|| it.next().cloned()) {
+ Some(v) => a.values.entry(name.to_string()).or_default().push(v),
+ None => {
+ bad.get_or_insert(CliError::Usage(format!("`{arg}` needs a value")));
+ }
+ }
} else if flags.contains(&name) && inline.is_none() {
a.flags.push(name.to_string());
} else {
- return Err(CliError::Usage(format!("unknown option `{arg}`")));
+ bad.get_or_insert(CliError::Usage(format!("unknown option `{arg}`")));
}
}
- Ok(a)
+ match bad {
+ Some(e) => Err(e),
+ None => Ok(a),
+ }
}
pub fn value(&self, k: &str) -> Option {
@@ -135,4 +145,18 @@ mod tests {
let a = Args::parse(&v(&["-5"]), &[], &[]).unwrap();
assert_eq!(a.positional, ["-5"]);
}
+
+ #[test]
+ fn help_is_asked_for_anywhere_but_as_a_value() {
+ // Also after a bad option: help wins over the usage error (#1161 review).
+ for argv in
+ [&["--help"][..], &["-h"], &["in.figcraft", "-o", "out", "--help"], &["--json", "-h"], &["--bogus", "--help"], &["--json=1", "-h"]]
+ {
+ assert!(matches!(Args::parse(&v(argv), &["o"], &["json"]), Err(CliError::Help)), "{argv:?}");
+ }
+ let a = Args::parse(&v(&["--filter", "--help", "-o", "-h"]), &["filter", "o"], &[]).unwrap();
+ assert_eq!((a.value("filter").as_deref(), a.value("o").as_deref()), (Some("--help"), Some("-h")));
+ // `--help=x` is no request for help, just an unknown option.
+ assert!(matches!(Args::parse(&v(&["--help=x"]), &[], &[]), Err(CliError::Usage(_))));
+ }
}
diff --git a/apps/figcraft-cli/src/files.rs b/apps/figcraft-cli/src/files.rs
index 65b19ee4..b3778063 100644
--- a/apps/figcraft-cli/src/files.rs
+++ b/apps/figcraft-cli/src/files.rs
@@ -29,9 +29,20 @@ fn image_format(e: &str) -> Option {
}
}
+/// Writes through [`figcraft_engine::file_access`] when automation roots are in force, so a
+/// confined run can only write inside a write root (#833).
+///
+/// Unconfined it writes with `std::fs::write`, as it always did. `file_access::write` stages the
+/// bytes and renames them into place, which **replaces** a symbolic link at `path` instead of
+/// writing through it to its target -- a change of behaviour for anyone whose output path is a
+/// link, and nothing to do with confinement. Inside a root the staged write is the right one:
+/// `Roots::check` has already refused a link that leads out of the root.
fn write(path: &str, bytes: &[u8]) -> CliResult<()> {
if let Some(dir) = Path::new(path).parent().filter(|d| !d.as_os_str().is_empty()) {
- std::fs::create_dir_all(dir).map_err(|e| CliError::Failed(format!("{}: {e}", dir.display())))?;
+ figcraft_engine::file_access::create_dir_all(dir).map_err(|e| CliError::Failed(e.to_string()))?;
+ }
+ if figcraft_engine::file_access::current().is_some() {
+ return figcraft_engine::file_access::write(path, bytes).map_err(|e| CliError::Failed(e.to_string()));
}
std::fs::write(path, bytes).map_err(|e| CliError::Failed(format!("{path}: {e}")))
}
@@ -196,9 +207,11 @@ pub fn info(path: &str, as_json: bool) -> CliResult {
Ok(ExitCode::SUCCESS)
}
+/// The file name a layer exports to: the app's rule ([`figcraft_engine::cmd::file::safe_file_name`],
+/// so `/` becomes `_` too), without leading or trailing spaces and dots, at most 100 characters.
fn sanitize(name: &str) -> String {
- let s: String = name.chars().map(|c| if c.is_alphanumeric() || matches!(c, '-' | '_' | ' ' | '.') { c } else { '_' }).collect();
- let s = s.trim().trim_matches('.').to_string();
+ let s = figcraft_engine::cmd::file::safe_file_name(name);
+ let s = s.trim_matches(|c: char| c == '.' || c.is_whitespace()).to_string();
if s.is_empty() { "layer".into() } else { s.chars().take(100).collect() }
}
@@ -244,7 +257,7 @@ pub fn export(file: &str, out: &str, t: &Target) -> CliResult {
println!("{out}");
return Ok(ExitCode::SUCCESS);
}
- std::fs::create_dir_all(out).map_err(|e| CliError::Failed(format!("{out}: {e}")))?;
+ figcraft_engine::file_access::create_dir_all(out).map_err(|e| CliError::Failed(e.to_string()))?;
let ids = match target {
Some(t) => vec![t],
None => {
@@ -329,7 +342,8 @@ pub fn parse_script(text: &str) -> Result, String> {
}
pub fn run_script(script: &str, input: Option<&str>, out: Option<&str>) -> CliResult {
- let text = std::fs::read_to_string(script).map_err(|e| CliError::Failed(format!("{script}: {e}")))?;
+ let bytes = figcraft_engine::file_access::read(script).map_err(|e| CliError::Failed(e.to_string()))?;
+ let text = String::from_utf8(bytes).map_err(|_| CliError::Failed(format!("{script}: not UTF-8")))?;
let steps = parse_script(&text).map_err(|e| CliError::Failed(format!("{script}: {e}")))?;
let mut s = match input {
Some(path) => {
@@ -399,6 +413,13 @@ mod tests {
assert_eq!(sanitize("Home / Hero"), "Home _ Hero");
assert_eq!(sanitize("../.."), "_");
assert_eq!(sanitize(""), "layer");
+ // The same characters the app's export keeps (#1154): only what file systems refuse goes.
+ assert_eq!(sanitize("Homepage - desktop (live + verbeteringen)"), "Homepage - desktop (live + verbeteringen)");
+ assert_eq!(sanitize("Q&A, 50% #1 [v2] {x} ~é"), "Q&A, 50% #1 [v2] {x} ~é");
+ assert_eq!(sanitize("a\\b:c*d?e\"fh|i\tj"), "a_b_c_d_e_f_g_h_i_j");
+ assert_eq!(sanitize(" .hidden. "), "hidden");
+ assert_eq!(sanitize(" . .name. . "), "name", "spaces and dots at the edges, mixed");
+ assert_eq!(sanitize(&"x".repeat(300)).chars().count(), 100);
}
#[test]
diff --git a/apps/figcraft-cli/src/main.rs b/apps/figcraft-cli/src/main.rs
index 281d79dd..66627673 100644
--- a/apps/figcraft-cli/src/main.rs
+++ b/apps/figcraft-cli/src/main.rs
@@ -22,11 +22,12 @@ USAGE:
figcraft-cli convert
figcraft-cli render -o [--scale N] [--page NAME]
figcraft-cli run [--in ] [--out ]
+ (info, export, convert, render and run also take --automation-read-root DIR / --automation-write-root DIR)
figcraft-cli commands [--json] [--filter TEXT]
figcraft-cli mcp [--attach PORT] [--automation-read-root DIR]... [--automation-write-root DIR]...
figcraft-cli plugin publish --server ws://host:port/[?key=KEY]
figcraft-cli perf [--layers N[,N...]] [--instances N[,N...]]
- figcraft-cli help | --help | --version
+ figcraft-cli help | --help | --version (a subcommand followed by --help or -h prints this too)
Every subcommand takes --no-system-fonts (or set FIGCRAFT_NO_SYSTEM_FONTS=1): text uses only the
fonts built into FigCraft, for renders that match on every machine. Otherwise installed fonts are
@@ -42,16 +43,42 @@ crop and bleed marks, CMYK colour). `run` executes a JSON array (or JSON lines)
`plugin publish` sends a plugin folder (figcraft-plugin.json, its module, an optional assets/ folder)
to a figcraft-server's plugin directory as a new version; the server's key comes from the address or
the FIGCRAFT_SERVER_KEY environment variable (which keeps it out of the shell history).
-`mcp --automation-read-root DIR` / `--automation-write-root DIR` (each may be repeated; the folders
-must exist) confine the files the agent's commands touch: reads only inside a read or write root,
-writes only inside a write root, everything else refused. A running app confines itself: start it
-with `figcraft --control PORT` and the same flags (`--attach` refuses them).
+`--automation-read-root DIR` / `--automation-write-root DIR` (each may be repeated; the folders
+must exist) confine the files a subcommand touches: reads only inside a read or write root, writes
+only inside a write root, everything else refused -- so giving no write root denies writing
+altogether. They reach the headless side only: `mcp` takes them to confine the agent's commands,
+and `info`, `export`, `convert`, `render` and `run` to confine that one run; without them a
+subcommand reads and writes as the user who started it, as before. A `mcp --attach` server is
+confined by the app it attaches to, not by flags passed to the CLI: start that app with
+`figcraft --control PORT` and the same roots (`--attach` refuses them).
See docs/cli.md and docs/mcp.md.";
+/// The automation roots a file subcommand was given, if any. Omitting both leaves the run
+/// unconfined, as before; giving either confines every file the subcommand touches (#833).
+const ROOT_FLAGS: [&str; 2] = ["automation-read-root", "automation-write-root"];
+
+fn roots_of(a: &Args) -> CliResult> {
+ let (read, write) = (a.values("automation-read-root"), a.values("automation-write-root"));
+ if read.is_empty() && write.is_empty() {
+ return Ok(None);
+ }
+ Ok(Some(figcraft_engine::file_access::Roots::new(read, write).map_err(CliError::Failed)?))
+}
+
+/// Runs `f` confined to the roots `a` carries.
+fn confined(a: &Args, f: impl FnOnce() -> CliResult) -> CliResult {
+ let roots = roots_of(a)?.map(std::sync::Arc::new);
+ figcraft_engine::file_access::confined(roots.as_ref(), f)
+}
+
fn main() -> ExitCode {
let argv: Vec = std::env::args().skip(1).collect();
match run(&argv) {
Ok(code) => code,
+ Err(CliError::Help) => {
+ println!("{USAGE}");
+ ExitCode::SUCCESS
+ }
Err(CliError::Usage(msg)) => {
eprintln!("error: {msg}\n\n{USAGE}");
ExitCode::from(2)
@@ -65,6 +92,8 @@ fn main() -> ExitCode {
#[derive(Debug)]
pub enum CliError {
+ /// `--help` or `-h` after a subcommand: usage on stdout, exit code 0.
+ Help,
/// Bad arguments: usage is printed, exit code 2.
Usage(String),
/// The operation failed: exit code 1.
@@ -98,35 +127,38 @@ fn run(argv: &[String]) -> CliResult {
Ok(ExitCode::SUCCESS)
}
"info" => {
- let a = Args::parse(rest, &[], &["json"])?;
+ let a = Args::parse(rest, &ROOT_FLAGS, &["json"])?;
let file = a.one_positional("info ")?;
- files::info(&file, a.flag("json"))
+ confined(&a, || files::info(&file, a.flag("json")))
}
"export" => {
- let a = Args::parse(rest, &["format", "scale", "page", "node", "o", "out", "bleed"], &["crop-marks", "bleed-marks", "cmyk"])?;
+ let valued = [&["format", "scale", "page", "node", "o", "out", "bleed"][..], &ROOT_FLAGS[..]].concat();
+ let a = Args::parse(rest, &valued, &["crop-marks", "bleed-marks", "cmyk"])?;
let file = a.one_positional("export -o ")?;
let out = a.value("o").or_else(|| a.value("out")).ok_or_else(|| CliError::Usage("export needs -o ".into()))?;
let target =
files::Target { format: a.value("format"), scale: a.scale()?, page: a.value("page"), node: a.value("node"), print: a.print()? };
- files::export(&file, &out, &target)
+ confined(&a, || files::export(&file, &out, &target))
}
"convert" => {
- let a = Args::parse(rest, &[], &[])?;
+ let a = Args::parse(rest, &ROOT_FLAGS, &[])?;
match a.positional.as_slice() {
- [i, o] => files::convert(i, o),
+ [i, o] => confined(&a, || files::convert(i, o)),
_ => Err(CliError::Usage("convert ".into())),
}
}
"render" => {
- let a = Args::parse(rest, &["o", "out", "scale", "page"], &[])?;
+ let valued = [&["o", "out", "scale", "page"][..], &ROOT_FLAGS[..]].concat();
+ let a = Args::parse(rest, &valued, &[])?;
let file = a.one_positional("render -o ")?;
let out = a.value("o").or_else(|| a.value("out")).ok_or_else(|| CliError::Usage("render needs -o ".into()))?;
- files::render(&file, &out, a.scale()?, a.value("page").as_deref())
+ confined(&a, || files::render(&file, &out, a.scale()?, a.value("page").as_deref()))
}
"run" => {
- let a = Args::parse(rest, &["in", "out"], &[])?;
+ let valued = [&["in", "out"][..], &ROOT_FLAGS[..]].concat();
+ let a = Args::parse(rest, &valued, &[])?;
let script = a.one_positional("run ")?;
- files::run_script(&script, a.value("in").as_deref(), a.value("out").as_deref())
+ confined(&a, || files::run_script(&script, a.value("in").as_deref(), a.value("out").as_deref()))
}
"commands" => {
let a = Args::parse(rest, &["filter"], &["json"])?;
@@ -137,23 +169,20 @@ fn run(argv: &[String]) -> CliResult {
Ok(ExitCode::SUCCESS)
}
"mcp" => {
- let a = Args::parse(rest, &["attach", "automation-read-root", "automation-write-root"], &[])?;
+ let valued = [&["attach"][..], &ROOT_FLAGS[..]].concat();
+ let a = Args::parse(rest, &valued, &[])?;
if !a.positional.is_empty() {
return Err(CliError::Usage("mcp takes no positional arguments".into()));
}
- let (read, write) = (a.values("automation-read-root"), a.values("automation-write-root"));
- let roots = match (read.is_empty() && write.is_empty(), a.value("attach")) {
- (true, _) => None,
- // The app runs the commands: only its own roots can confine them.
- (false, Some(_)) => {
- return Err(CliError::Usage(
- "--attach can't take automation roots: start the app with them instead (`figcraft --control PORT --automation-read-root DIR ...`)"
- .into(),
- ));
- }
- (false, None) => Some(figcraft_engine::file_access::Roots::new(read, write).map_err(CliError::Failed)?),
- };
- mcp(a.value("attach").as_deref(), roots)
+ let attach = a.value("attach");
+ // The app runs the commands: only its own roots can confine them.
+ if attach.is_some() && ROOT_FLAGS.iter().any(|f| !a.values(f).is_empty()) {
+ return Err(CliError::Usage(
+ "--attach can't take automation roots: start the app with them instead (`figcraft --control PORT --automation-read-root DIR ...`)"
+ .into(),
+ ));
+ }
+ mcp(attach.as_deref(), roots_of(&a)?)
}
"plugin" => {
let a = Args::parse(rest, &["server"], &[])?;
diff --git a/apps/figcraft-cli/tests/cli.rs b/apps/figcraft-cli/tests/it/cli.rs
similarity index 52%
rename from apps/figcraft-cli/tests/cli.rs
rename to apps/figcraft-cli/tests/it/cli.rs
index 7eaf051f..b1aeb54a 100644
--- a/apps/figcraft-cli/tests/cli.rs
+++ b/apps/figcraft-cli/tests/it/cli.rs
@@ -1,5 +1,4 @@
//! The binary end to end.
-#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
use std::io::Write;
use std::process::{Command, Stdio};
@@ -40,6 +39,40 @@ fn bad_arguments_exit_2_without_panicking() {
assert_eq!(out.status.code(), Some(1));
}
+/// `--help` / `-h` after a subcommand prints the usage on stdout and exits 0, as it does first
+/// (#1155), whatever else is on the line; nothing runs.
+#[test]
+fn help_after_a_subcommand_prints_the_usage() {
+ for args in [
+ &["--help"][..],
+ &["-h"],
+ &["help"],
+ &["mcp", "--help"],
+ &["mcp", "-h"],
+ &["info", "--help"],
+ &["export", "--help"],
+ &["export", "x.figcraft", "-o", "out", "--help"],
+ &["convert", "-h"],
+ &["render", "--help"],
+ &["run", "--help"],
+ &["commands", "--help"],
+ &["plugin", "publish", "--help"],
+ &["perf", "--help"],
+ &["mcp", "--attach", "notaport", "--help"],
+ &["mcp", "--bogus", "--help"],
+ ] {
+ let out = bin().args(args).stdin(Stdio::null()).output().unwrap();
+ assert_eq!(out.status.code(), Some(0), "{args:?}: {}", String::from_utf8_lossy(&out.stderr));
+ let text = String::from_utf8_lossy(&out.stdout);
+ assert!(text.contains("USAGE") && text.contains("figcraft-cli mcp"), "{args:?}: {text}");
+ assert!(out.stderr.is_empty(), "{args:?}: nothing on stderr, got {}", String::from_utf8_lossy(&out.stderr));
+ }
+ // A value that happens to be `-h` is still a value, not a request for help.
+ let out = bin().args(["commands", "--filter", "--help"]).output().unwrap();
+ assert_eq!(out.status.code(), Some(0));
+ assert!(!String::from_utf8_lossy(&out.stdout).contains("USAGE"), "--filter took `--help` as its text");
+}
+
#[test]
fn run_export_info_convert() {
let d = tmp("run");
@@ -81,6 +114,30 @@ fn run_export_info_convert() {
std::fs::remove_dir_all(&d).ok();
}
+/// `export` into a folder names the files as the app's export does (#1154): brackets, `+`, `&`,
+/// `%`, `#` and commas stay, what file systems refuse becomes `_`.
+#[test]
+fn export_file_names_keep_what_the_app_keeps() {
+ let d = tmp("names");
+ let script = d.join("s.json");
+ let names = ["Homepage - desktop (live + verbeteringen)", "Q&A, 50% #1 [v2]", "a:b*c?d|e"];
+ let steps: Vec = names
+ .iter()
+ .enumerate()
+ .map(|(i, n)| serde_json::json!({"command": "frame.create", "params": {"x": i * 200, "y": 0, "width": 20, "height": 20, "name": n}}))
+ .collect();
+ std::fs::write(&script, serde_json::to_string(&steps).unwrap()).unwrap();
+ let file = d.join("doc.figcraft");
+ assert!(bin().arg("run").arg(&script).arg("--out").arg(&file).output().unwrap().status.success());
+ let dir = d.join("out");
+ let out = bin().arg("export").arg(&file).arg("-o").arg(&dir).output().unwrap();
+ assert!(out.status.success(), "{}", String::from_utf8_lossy(&out.stderr));
+ for want in ["Homepage - desktop (live + verbeteringen).png", "Q&A, 50% #1 [v2].png", "a_b_c_d_e.png"] {
+ assert!(dir.join(want).is_file(), "{want} in {:?}", std::fs::read_dir(&dir).unwrap().flatten().map(|e| e.file_name()).collect::>());
+ }
+ std::fs::remove_dir_all(&d).ok();
+}
+
#[test]
fn run_takes_the_documented_gradient_shorthand() {
// #252: only MCP used to accept it; `run` said "`fills` must be paints or colours".
@@ -172,3 +229,98 @@ fn commands_json_lists_everything() {
let v: serde_json::Value = serde_json::from_slice(&out.stdout).unwrap();
assert!(v.as_array().unwrap().len() > 200);
}
+
+/// The automation roots confine the file subcommands too, not just `mcp` (#833): a read outside a
+/// root, and a write outside a write root, are refused and leave no file behind. Without the flags
+/// the same commands behave as they always did.
+#[test]
+fn file_subcommands_are_confined_to_automation_roots() {
+ let d = tmp("file-roots");
+ let _ = std::fs::remove_dir_all(&d);
+ for sub in ["in", "out"] {
+ std::fs::create_dir_all(d.join(sub)).unwrap();
+ }
+ let p = |rel: &str| d.join(rel).to_string_lossy().into_owned();
+ let out_of = |o: &std::process::Output| String::from_utf8_lossy(&o.stderr).into_owned();
+
+ // A document to work on, made unconfined.
+ std::fs::write(d.join("in/make.json"), br#"[{"command":"shape.rectangle","params":{"x":0,"y":0,"width":40,"height":20}}]"#).unwrap();
+ let made = bin().args(["run", &p("in/make.json"), "--out", &p("in/doc.figcraft")]).output().unwrap();
+ assert!(made.status.success(), "{}", out_of(&made));
+
+ // Inside the roots: renders as usual.
+ let ok = bin()
+ .args(["render", &p("in/doc.figcraft"), "-o", &p("out/ok.png"), "--automation-read-root", &p("in"), "--automation-write-root", &p("out")])
+ .output()
+ .unwrap();
+ assert!(ok.status.success(), "{}", out_of(&ok));
+ assert!(d.join("out/ok.png").is_file());
+
+ // A write outside the write root is refused, and nothing is written.
+ let escaped = d.join("escaped.png");
+ let refused = bin()
+ .args([
+ "render",
+ &p("in/doc.figcraft"),
+ "-o",
+ &escaped.to_string_lossy(),
+ "--automation-read-root",
+ &p("in"),
+ "--automation-write-root",
+ &p("out"),
+ ])
+ .output()
+ .unwrap();
+ assert!(!refused.status.success());
+ assert!(out_of(&refused).contains("may be written"), "{}", out_of(&refused));
+ assert!(!escaped.exists(), "the refused render wrote a file anyway");
+
+ // No write root at all: writing is refused outright, reading still works.
+ let no_write = bin().args(["render", &p("in/doc.figcraft"), "-o", &p("out/no.png"), "--automation-read-root", &p("in")]).output().unwrap();
+ assert!(!no_write.status.success());
+ assert!(out_of(&no_write).contains("no folder may be written"), "{}", out_of(&no_write));
+
+ // A read outside every root is refused: `info` on the document with only `out` readable.
+ let read_refused = bin().args(["info", &p("in/doc.figcraft"), "--automation-read-root", &p("out")]).output().unwrap();
+ assert!(!read_refused.status.success());
+ assert!(out_of(&read_refused).contains("may be read"), "{}", out_of(&read_refused));
+
+ // `convert` and `run` take them as well, and a root that is not a folder is refused.
+ let missing = bin().args(["convert", &p("in/doc.figcraft"), &p("out/c.svg"), "--automation-read-root", &p("missing")]).output().unwrap();
+ assert!(!missing.status.success());
+ assert!(out_of(&missing).contains("automation-read-root"), "{}", out_of(&missing));
+
+ // Unconfined, the same render still writes wherever it is told.
+ let plain = bin().args(["render", &p("in/doc.figcraft"), "-o", &escaped.to_string_lossy()]).output().unwrap();
+ assert!(plain.status.success(), "{}", out_of(&plain));
+ assert!(escaped.is_file());
+ let _ = std::fs::remove_dir_all(&d);
+}
+
+/// An output path that is a symbolic link is written through, to its target, as `std::fs::write`
+/// always did. Routing the CLI's writes through `file_access` for #833 would otherwise have
+/// replaced the link with a regular file, because that write stages the bytes and renames them
+/// into place.
+#[cfg(unix)]
+#[test]
+fn an_unconfined_write_follows_a_symbolic_link() {
+ let d = tmp("symlink-out");
+ let _ = std::fs::remove_dir_all(&d);
+ std::fs::create_dir_all(d.join("real")).unwrap();
+ let p = |rel: &str| d.join(rel).to_string_lossy().into_owned();
+ std::fs::write(d.join("in.json"), br#"[{"command":"shape.rectangle","params":{"x":0,"y":0,"width":40,"height":20}}]"#).unwrap();
+ let made = bin().args(["run", &p("in.json"), "--out", &p("doc.figcraft")]).output().unwrap();
+ assert!(made.status.success(), "{}", String::from_utf8_lossy(&made.stderr));
+
+ let target = d.join("real/target.png");
+ std::fs::write(&target, b"placeholder").unwrap();
+ let link = d.join("link.png");
+ std::os::unix::fs::symlink(&target, &link).unwrap();
+
+ let out = bin().args(["render", &p("doc.figcraft"), "-o", &link.to_string_lossy()]).output().unwrap();
+ assert!(out.status.success(), "{}", String::from_utf8_lossy(&out.stderr));
+ assert!(std::fs::symlink_metadata(&link).unwrap().file_type().is_symlink(), "the link is still a link");
+ let written = std::fs::read(&target).unwrap();
+ assert!(written.starts_with(b"\x89PNG"), "the target holds the render, not the placeholder");
+ let _ = std::fs::remove_dir_all(&d);
+}
diff --git a/apps/figcraft-cli/tests/export_depth.rs b/apps/figcraft-cli/tests/it/export_depth.rs
similarity index 97%
rename from apps/figcraft-cli/tests/export_depth.rs
rename to apps/figcraft-cli/tests/it/export_depth.rs
index d8b3ef36..37350c1e 100644
--- a/apps/figcraft-cli/tests/export_depth.rs
+++ b/apps/figcraft-cli/tests/it/export_depth.rs
@@ -1,5 +1,4 @@
//! Depth refusal through the actual CLI, including its exit status and destination writes.
-#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
use figcraft_doc::color::{Color, Paint};
use figcraft_doc::{Document, NodeKind};
diff --git a/apps/figcraft-cli/tests/fonts.rs b/apps/figcraft-cli/tests/it/fonts.rs
similarity index 98%
rename from apps/figcraft-cli/tests/fonts.rs
rename to apps/figcraft-cli/tests/it/fonts.rs
index ef5c638f..a48056bd 100644
--- a/apps/figcraft-cli/tests/fonts.rs
+++ b/apps/figcraft-cli/tests/it/fonts.rs
@@ -1,6 +1,5 @@
//! Headless runs lay text out with the installed fonts, like the desktop app, unless
//! `--no-system-fonts` or `FIGCRAFT_NO_SYSTEM_FONTS=1` opts out.
-#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
use std::process::Command;
diff --git a/apps/figcraft-cli/tests/it/main.rs b/apps/figcraft-cli/tests/it/main.rs
new file mode 100644
index 00000000..ae4b0488
--- /dev/null
+++ b/apps/figcraft-cli/tests/it/main.rs
@@ -0,0 +1,12 @@
+//! The crate's integration tests, built as one test binary.
+
+#[allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
+mod cli;
+#[allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
+mod export_depth;
+#[allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
+mod fonts;
+#[allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
+mod pdf;
+#[allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
+mod pdf_print;
diff --git a/apps/figcraft-cli/tests/pdf.rs b/apps/figcraft-cli/tests/it/pdf.rs
similarity index 97%
rename from apps/figcraft-cli/tests/pdf.rs
rename to apps/figcraft-cli/tests/it/pdf.rs
index 28d5ca6c..185d5b60 100644
--- a/apps/figcraft-cli/tests/pdf.rs
+++ b/apps/figcraft-cli/tests/it/pdf.rs
@@ -1,5 +1,4 @@
//! `figcraft-cli export --format pdf` and `convert … .pdf` end to end.
-#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
use std::process::Command;
diff --git a/apps/figcraft-cli/tests/pdf_print.rs b/apps/figcraft-cli/tests/it/pdf_print.rs
similarity index 97%
rename from apps/figcraft-cli/tests/pdf_print.rs
rename to apps/figcraft-cli/tests/it/pdf_print.rs
index b2ce3c9a..f12725ed 100644
--- a/apps/figcraft-cli/tests/pdf_print.rs
+++ b/apps/figcraft-cli/tests/it/pdf_print.rs
@@ -1,5 +1,4 @@
//! `figcraft-cli export` with PDF print options: bleed, marks, CMYK; bad lengths are usage errors.
-#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
use std::process::Command;
diff --git a/apps/figcraft-server/src/hardening_tests.rs b/apps/figcraft-server/src/hardening_tests.rs
index 086539ca..92b17710 100644
--- a/apps/figcraft-server/src/hardening_tests.rs
+++ b/apps/figcraft-server/src/hardening_tests.rs
@@ -838,3 +838,25 @@ fn a_library_publish_that_fails_keeps_serving_the_old_version() {
assert_eq!(served(fetch(&mut store)), (2, v2));
assert!(!files.join(crate::store::library_name(1)).exists(), "the old version is deleted");
}
+
+#[test]
+fn a_library_publish_cannot_claim_the_highest_version() {
+ let dir = TempDir::new("libmax");
+ let mut store = Store::open(dir.path(), config(dir.path()).store()).unwrap();
+ let (file, ..) = store.publish("Library", &snapshot("Library")).unwrap();
+ let mut s = Session::new();
+ let f = s.execute("frame.create", &json!({"x": 0, "y": 0, "width": 50, "height": 20, "name": "Button"})).unwrap()["id"].as_u64().unwrap();
+ s.execute("component.create", &json!({"ids": [f]})).unwrap();
+ s.execute("library.publish", &json!({})).unwrap();
+ let mut lib = s.doc().unwrap().published.clone().unwrap().as_ref().clone();
+ let mut archive = |version: u64| {
+ lib.manifest.version = version;
+ figcraft_engine::library_server::archive(&lib).unwrap()
+ };
+ let high = 1u64 << 32;
+ assert!(store.publish_library(&file.id, &archive(u64::MAX)).is_err(), "a first publish can't claim the highest version");
+ assert_eq!(store.publish_library(&file.id, &archive(high)).unwrap(), high, "the highest accepted first version goes in");
+ assert_eq!(store.publish_library(&file.id, &archive(high + 1)).unwrap(), high + 1, "and a newer one still follows it");
+ assert!(store.publish_library(&file.id, &archive(u64::MAX)).is_err(), "a jump to the highest version is refused");
+ assert_eq!(store.publish_library(&file.id, &archive(high + 2)).unwrap(), high + 2, "later versions still go in");
+}
diff --git a/apps/figcraft-server/src/public_tests.rs b/apps/figcraft-server/src/public_tests.rs
index 978d9e8e..dc86d123 100644
--- a/apps/figcraft-server/src/public_tests.rs
+++ b/apps/figcraft-server/src/public_tests.rs
@@ -164,6 +164,64 @@ fn caps_per_address_and_for_everyone() {
assert_eq!(store.publish_open(ip("198.51.100.8"), "No", &snapshot("No")).unwrap_err(), KEY_ONLY);
}
+#[test]
+fn caps_per_address_count_the_wider_ipv6_blocks() {
+ let dir = TempDir::new("block-caps");
+ let mut c = open(dir.path());
+ c.max_files_per_ip = 1;
+ c.publishes_per_hour = 1000;
+ let mut store = Store::open(dir.path(), c.store()).unwrap();
+ // A /48 keeps 4 times one address's files: /64s in different /56s of it.
+ for i in 0..4 {
+ store.publish_open(ip(&format!("2001:db8:1:{:x}::1", i << 8)), "One", &snapshot("One")).unwrap();
+ }
+ let e = store.publish_open(ip("2001:db8:1:400::1"), "Five", &snapshot("Five")).unwrap_err();
+ assert!(e.contains("files on this server already"), "{e}");
+ // A /56 keeps twice one address's files.
+ store.publish_open(ip("2001:db8:2:1::1"), "One", &snapshot("One")).unwrap();
+ store.publish_open(ip("2001:db8:2:2::1"), "Two", &snapshot("Two")).unwrap();
+ let e = store.publish_open(ip("2001:db8:2:3::1"), "Three", &snapshot("Three")).unwrap_err();
+ assert!(e.contains("files on this server already"), "{e}");
+ drop(store);
+ // Bytes: one address keeps one file's worth, so a /48 keeps 4 files.
+ let probe = TempDir::new("block-caps-probe");
+ let mut p = Store::open(probe.path(), open(probe.path()).store()).unwrap();
+ let size = p.publish_open(ip("203.0.113.1"), "One", &snapshot("One")).unwrap().0.bytes;
+ let dir = TempDir::new("block-caps-bytes");
+ let mut s = open(dir.path()).store();
+ s.hosting.max_files_per_ip = 100;
+ s.hosting.max_bytes_per_ip = size;
+ let mut store = Store::open(dir.path(), s).unwrap();
+ for i in 0..4 {
+ store.publish_open(ip(&format!("2001:db8:3:{:x}::1", i << 8)), "One", &snapshot("One")).unwrap();
+ }
+ let e = store.publish_open(ip("2001:db8:3:400::1"), "One", &snapshot("One")).unwrap_err();
+ assert!(e.contains("MiB it may keep"), "{e}");
+}
+
+#[test]
+fn edits_count_the_wider_ipv6_blocks_too() {
+ use figcraft_collab_net::hub::Backend;
+ let probe = TempDir::new("block-room-probe");
+ let mut p = Store::open(probe.path(), open(probe.path()).store()).unwrap();
+ let size = p.publish_open(ip("203.0.113.1"), "One", &snapshot("One")).unwrap().0.bytes;
+ let dir = TempDir::new("block-room");
+ let mut s = open(dir.path()).store();
+ s.hosting.max_files_per_ip = 100;
+ // One address keeps 2.25 files' worth, so its /56 keeps 4.5.
+ s.hosting.max_bytes_per_ip = size * 2 + size / 4;
+ let mut store = Store::open(dir.path(), s).unwrap();
+ let mut ids = Vec::new();
+ for i in 0..4 {
+ ids.push(store.publish_open(ip(&format!("2001:db8:4:{i:x}::1")), "One", &snapshot("One")).unwrap().0.id);
+ }
+ let server = Backend::open(&mut store, &ids[0]).unwrap();
+ // Its own /64 has room for this, but its /56 doesn't.
+ let e = Backend::room(&mut store, &ids[0], &server, (size * 3 / 4) as usize).unwrap_err();
+ assert!(e.contains("have reached their"), "{e}");
+ Backend::room(&mut store, &ids[0], &server, (size / 4) as usize).unwrap();
+}
+
#[test]
fn idle_files_published_without_the_key_expire() {
let dir = TempDir::new("expiry");
@@ -196,6 +254,22 @@ fn idle_files_published_without_the_key_expire() {
assert!(store.listing(&|_| None).iter().all(|r| r.info.id != fresh.id));
}
+#[test]
+fn offline_commands_do_not_sweep_idle_files() {
+ let dir = TempDir::new("offline-sweep");
+ let mut c = open(dir.path());
+ c.idle_days = 30.0;
+ let mut store = Store::open(dir.path(), c.store()).unwrap();
+ let (public, ..) = store.publish_open(ip("203.0.113.9"), "Public", &snapshot("Public")).unwrap();
+ store.age(&public.id, 31 * 86_400);
+ drop(store);
+ let store = Store::try_open(dir.path(), c.store()).unwrap().unwrap();
+ drop(store);
+ assert!(dir.path().join("files").join(&public.id).exists(), "a command deleted an idle file");
+ let _serving = Store::open(dir.path(), c.store()).unwrap();
+ assert!(!dir.path().join("files").join(&public.id).exists());
+}
+
#[test]
fn rate_limits_and_blocks_refuse_with_a_reason() {
let dir = TempDir::new("limits");
diff --git a/apps/figcraft-server/src/server_tests.rs b/apps/figcraft-server/src/server_tests.rs
index 153bb5ab..f60150da 100644
--- a/apps/figcraft-server/src/server_tests.rs
+++ b/apps/figcraft-server/src/server_tests.rs
@@ -261,7 +261,9 @@ fn fuzzed_frames_dont_hurt_the_server() {
break;
}
}
- let _ = ws.read();
+ // read() returns Result, not a lock guard; the fuzz loop ends here on purpose and
+ // the close frame from the server is not interesting.
+ let _ = ws.read(); // NOSONAR
}
// Still serving, the file intact.
let mut b = join(&p.edit, "Bo");
diff --git a/apps/figcraft-server/src/store.rs b/apps/figcraft-server/src/store.rs
index ea9bc626..a60d482d 100644
--- a/apps/figcraft-server/src/store.rs
+++ b/apps/figcraft-server/src/store.rs
@@ -42,7 +42,7 @@ use figcraft_collab::message::{
PluginReply, PluginReq, ReportInfo, Usage,
};
use figcraft_collab::{Change, Replica, Server, same_secret};
-use figcraft_collab_net::hub::{Admission, Backend, Closing, Handled, OpenFile, ip_key};
+use figcraft_collab_net::hub::{Admission, Backend, Closing, Handled, OpenFile, ip_blocks, ip_key};
use figcraft_collab_net::token;
use serde::{Deserialize, Serialize};
use sha2::{Digest, Sha256};
@@ -291,7 +291,17 @@ fn valid_id(s: &str) -> bool {
/// A name others may see: trimmed, no control characters, at most 256 characters.
fn clean_name(s: &str) -> String {
- s.trim().chars().filter(|c| !c.is_control()).take(256).collect()
+ s.trim().chars().filter(|c| !c.is_control() && !is_bidi_control(*c)).take(256).collect()
+}
+
+/// A report's reason: trimmed, control and bidi characters turned into spaces, at most `MAX_REASON` characters.
+fn clean_reason(s: &str) -> String {
+ s.trim().chars().map(|c| if c.is_control() || is_bidi_control(c) { ' ' } else { c }).take(MAX_REASON).collect()
+}
+
+/// Bidirectional format characters, which could reorder what a terminal shows.
+fn is_bidi_control(c: char) -> bool {
+ matches!(c, '\u{61C}' | '\u{200E}' | '\u{200F}' | '\u{202A}'..='\u{202E}' | '\u{2066}'..='\u{2069}')
}
/// Take the data directory's lock: `None` when someone else holds it.
@@ -302,6 +312,10 @@ pub fn lock(root: &Path) -> Result, String> {
#[cfg(unix)]
std::os::unix::fs::DirBuilderExt::mode(&mut dirs, 0o700);
dirs.create(root).map_err(|e| format!("can't create the data directory {}: {e}", root.display()))?;
+ // `DirBuilder` only applies the mode to directories it creates; tighten an existing one too.
+ #[cfg(unix)]
+ fs::set_permissions(root, std::os::unix::fs::PermissionsExt::from_mode(0o700))
+ .map_err(|e| format!("can't restrict the data directory {}: {e}", root.display()))?;
let f = OpenOptions::new()
.create(true)
.truncate(false)
@@ -334,16 +348,27 @@ fn write_key(root: &Path) -> Result {
Ok(key)
}
+/// The highest version a file's first library publish may claim. Publishing counts up by one (a
+/// library carried over from another server keeps its number), so no real history gets near it.
+/// Later publishes may go one past the version on the server, so there is always a next one.
+const MAX_FIRST_LIBRARY_VERSION: u64 = 1 << 32;
+
impl Store {
/// Use the data directory `root` (made if missing). Fails when another server or command holds
/// it. Files that can't be read are skipped and listed in [`problems`](Self::problems).
pub fn open(root: &Path, cfg: StoreConfig) -> Result {
- Self::try_open(root, cfg)?.ok_or_else(|| format!("another figcraft-server (or a command) is using {}", root.display()))
+ let mut store = Self::try_open(root, cfg)?.ok_or_else(|| format!("another figcraft-server (or a command) is using {}", root.display()))?;
+ store.sweep();
+ Ok(store)
}
- /// [`open`](Self::open), or `None` when someone else holds the directory.
+ /// [`open`](Self::open) without the expiry sweep (for commands that only look or edit), or
+ /// `None` when someone else holds the directory.
pub fn try_open(root: &Path, cfg: StoreConfig) -> Result, String> {
let Some(lock) = lock(root)? else { return Ok(None) };
+ for name in [KEY, BLOCKED, REPORTS] {
+ let _ = fs::remove_file(disk::temp_of(&root.join(name)));
+ }
let key = load_key(root)?;
let dir = root.join(FILES);
fs::create_dir_all(&dir).map_err(|e| format!("can't create {}: {e}", dir.display()))?;
@@ -374,7 +399,6 @@ impl Store {
store.scan(&dir);
store.blocked = store.read_list::(BLOCKED).iter().filter_map(|s| s.parse().ok()).map(ip_key).collect();
store.reports = store.read_list(REPORTS);
- store.sweep();
Ok(Some(store))
}
@@ -425,12 +449,20 @@ impl Store {
/// A file folder's description and links, after checking its snapshot and log. Leftover
/// temporary files (writes cut short) are removed.
fn check(&self, path: &Path) -> Result {
- for name in [SNAPSHOT, LOG, META, LINKS] {
+ for name in [SNAPSHOT, LOG, META, LINKS, USAGE] {
let tmp = disk::temp_of(&path.join(name));
if tmp.exists() {
let _ = fs::remove_file(&tmp);
}
}
+ if let Ok(entries) = fs::read_dir(path) {
+ for e in entries.flatten() {
+ let name = e.file_name().to_string_lossy().into_owned();
+ if name.starts_with("library-") && name.ends_with(".bin.tmp") {
+ let _ = fs::remove_file(e.path());
+ }
+ }
+ }
let meta: Meta = serde_json::from_slice(&disk::read_capped(&path.join(META), 1 << 20)?).map_err(|e| format!("{META} is damaged ({e})"))?;
let links: Vec().map(|a| ip_blocks(ip_key(a))).unwrap_or_default();
+ let kept: Vec<(&str, Vec<_>, u64)> = self
+ .files
+ .iter()
+ .filter_map(|(id, e)| {
+ let from = e.meta.ip.as_deref()?;
+ Some((from, blocks_of(from).into_iter().map(|(b, _)| b).collect(), self.bytes(id)))
+ })
+ .collect();
+ let sum = |mine: &mut dyn Iterator- , u64)>| mine.fold((0, 0u64), |(f, b), (_, _, n)| (f + 1, b.saturating_add(*n)));
+ let blocks = blocks_of(ip);
+ if blocks.is_empty() {
+ let (files, bytes) = sum(&mut kept.iter().filter(|(from, _, _)| *from == ip));
+ return vec![(1, files, bytes)];
+ }
+ blocks
+ .into_iter()
+ .map(|(block, times)| {
+ let (files, bytes) = sum(&mut kept.iter().filter(|(_, blocks, _)| blocks.contains(&block)));
+ (times, files, bytes)
+ })
+ .collect()
+ }
+
/// Keep a document published without the key from `ip`, within the caps on what one address
/// and everyone may keep: the file, its links and its owner token.
pub fn publish_open(&mut self, ip: IpAddr, name: &str, snapshot: &[Change]) -> Result<(FileInfo, NewLink, NewLink, String), String> {
@@ -525,19 +585,21 @@ impl Store {
if !self.abuse.allow(ip, Action::Publish, Instant::now()) {
return Err("too many files published from your address lately: try again in an hour".into());
}
- let ip_text = ip.to_string();
- let mine: Vec<&String> = self.files.iter().filter(|(_, e)| e.meta.ip.as_deref() == Some(ip_text.as_str())).map(|(id, _)| id).collect();
- if mine.len() >= max_files {
- return Err(format!(
- "your address keeps {} files on this server already, the most it may: remove one (with its owner token) or wait until one expires",
- mine.len()
- ));
+ let blocks = self.per_block(&ip.to_string());
+ for &(times, files, _) in &blocks {
+ if files >= max_files.saturating_mul(times as usize) {
+ return Err(format!(
+ "your address keeps {files} files on this server already, the most it may: remove one (with its owner token) or wait until one expires"
+ ));
+ }
}
- let used_ip: u64 = mine.iter().map(|id| self.bytes(id)).sum();
let used_all: u64 = self.files.keys().map(|id| self.bytes(id)).sum();
let fits = |n: u64| {
- if used_ip.saturating_add(n) > max_ip {
- return Err(format!("your address's files would take more than the {} MiB it may keep here: remove one first", max_ip >> 20));
+ for &(times, _, used) in &blocks {
+ let cap = max_ip.saturating_mul(u64::from(times));
+ if used.saturating_add(n) > cap {
+ return Err(format!("your address's files would take more than the {} MiB it may keep here: remove one first", cap >> 20));
+ }
}
if used_all.saturating_add(n) > max_all {
return Err("this server is full: it takes no more files for now (try again later, or another server)".into());
@@ -748,7 +810,7 @@ impl Store {
/// Keep a report about `file` (from someone who joined it with `link`, at `ip`).
pub fn keep_report(&mut self, file: &str, link: Option<&str>, ip: IpAddr, reason: &str) -> Result<(), String> {
- let reason: String = reason.trim().chars().map(|c| if c.is_control() { ' ' } else { c }).take(MAX_REASON).collect();
+ let reason = clean_reason(reason);
if reason.is_empty() {
return Err("say what is wrong with the file".into());
}
@@ -973,6 +1035,12 @@ impl Store {
if m.version <= old.version {
return Err(format!("version {} is on the server already: publish again to follow it", old.version));
}
+ // A jump would let a client use up the numbers and leave no newer version to publish.
+ if m.version > old.version.saturating_add(1) {
+ return Err(format!("version {} is too high: the next one after {} is {}", m.version, old.version, old.version.saturating_add(1)));
+ }
+ } else if m.version > MAX_FIRST_LIBRARY_VERSION {
+ return Err(format!("version {} is too high: a first publish goes up to {MAX_FIRST_LIBRARY_VERSION}", m.version));
}
// Each version has a file of its own, written before the description names it: a failed
// description write or a crash in between leaves the previous version served whole, never
@@ -1090,9 +1158,11 @@ impl Store {
let h = &self.cfg.hosting;
let Some(ip) = self.files.get(file).filter(|e| e.meta.owner.is_some()).and_then(|e| e.meta.ip.clone()) else { return Ok(()) };
let (max_ip, max_all) = (h.max_bytes_per_ip, h.max_total_bytes);
- let used_ip: u64 = self.files.iter().filter(|(_, e)| e.meta.ip.as_deref() == Some(ip.as_str())).map(|(id, _)| self.bytes(id)).sum();
- if used_ip.saturating_add(n) > max_ip {
- return Err(format!("the files published from this file's address have reached their {} MiB: that change wasn't kept", max_ip >> 20));
+ for (times, _, used) in self.per_block(&ip) {
+ let cap = max_ip.saturating_mul(u64::from(times));
+ if used.saturating_add(n) > cap {
+ return Err(format!("the files published from this file's address have reached their {} MiB: that change wasn't kept", cap >> 20));
+ }
}
let used_all: u64 = self.files.keys().map(|id| self.bytes(id)).sum();
if used_all.saturating_add(n) > max_all {
@@ -1110,7 +1180,24 @@ impl Store {
let mut issues = Vec::new();
let mut fresh_log = true;
let mut kept = 0;
- match disk::read_capped(&dir.join(LOG), self.cfg.max_file_bytes).and_then(|b| disk::read_log(&b)) {
+ let log_path = dir.join(LOG);
+ // A log that's there but can't be read (an IO error, or over a lowered cap) may hold
+ // confirmed edits: the file isn't opened, and the log is left as it is for another try.
+ let read = match disk::read_capped(&log_path, self.cfg.max_file_bytes) {
+ Err(why) if log_path.exists() => return Err(format!("its log can't be read ({why}); it was left as it is")),
+ r => r,
+ };
+ // One that isn't a log is moved aside before a new one replaces it (or the file isn't opened).
+ let read = match read.map(|b| disk::read_log(&b)) {
+ Ok(Err(why)) => {
+ let aside = dir.join(format!("{LOG}.unreadable-{generation}-{}", now()));
+ fs::rename(&log_path, &aside).map_err(|e| format!("{why}, and it couldn't be moved aside ({e})"))?;
+ Err(format!("{why}; it was moved aside to {}", aside.display()))
+ }
+ Ok(Ok(log)) => Ok(log),
+ Err(why) => Err(why),
+ };
+ match read {
Ok(log) if log.generation == generation => {
fresh_log = false;
for entry in log.entries {
@@ -1167,7 +1254,10 @@ impl Store {
Log { generation, file: f, pending: Vec::new(), entries: kept, bytes, dirty: kept > 0 }
}
// A new snapshot and log of the next generation, so appends start clean.
- _ => self.rewrite(file, generation + 1, &server).map_err(|e| e.why)?,
+ _ => {
+ let next = generation.checked_add(1).ok_or("the file's generation can't go any higher")?;
+ self.rewrite(file, next, &server).map_err(|e| e.why)?
+ }
};
self.entry(file)?.log = Some(log);
Ok(server)
@@ -1243,7 +1333,11 @@ impl Store {
fn compact(&mut self, file: &str, server: &Server) {
self.compactions += 1;
let Some(generation) = self.files.get(file).and_then(|e| e.log.as_ref()).map(|l| l.generation) else { return };
- match self.rewrite(file, generation + 1, server) {
+ let Some(next) = generation.checked_add(1) else {
+ log::error!("file {file}: compaction failed: the file's generation can't go any higher");
+ return;
+ };
+ match self.rewrite(file, next, server) {
Ok(log) => {
if let Ok(e) = self.entry(file) {
e.log = Some(log);
diff --git a/apps/figcraft-server/src/store_tests.rs b/apps/figcraft-server/src/store_tests.rs
index f380568c..bd1d9c32 100644
--- a/apps/figcraft-server/src/store_tests.rs
+++ b/apps/figcraft-server/src/store_tests.rs
@@ -229,6 +229,17 @@ fn one_server_per_data_directory() {
assert_eq!(again.key(), key, "the key is kept");
}
+#[cfg(unix)]
+#[test]
+fn an_existing_data_directory_is_made_private() {
+ use std::os::unix::fs::PermissionsExt;
+ let dir = TempDir::new("perms");
+ fs::set_permissions(dir.path(), fs::Permissions::from_mode(0o755)).unwrap();
+ assert!(crate::store::lock(dir.path()).unwrap().is_some());
+ let mode = fs::metadata(dir.path()).unwrap().permissions().mode() & 0o777;
+ assert_eq!(mode, 0o700);
+}
+
#[test]
fn temporary_directories_are_removed() {
let path = {
@@ -313,3 +324,124 @@ fn edits_confirmed_after_a_compaction_cut_short_survive_a_restart() {
let name = page_name(&restored);
assert!(at(&name) >= at(&confirmed), "restored {name:?}, confirmed {confirmed:?}");
}
+
+#[test]
+fn a_log_that_cant_be_read_is_never_overwritten() {
+ let dir = TempDir::new("unreadlog");
+ let c = StoreConfig { compact_after: 1000, ..cfg(dir.path()) };
+ let log_path = dir.path().join(FILES);
+ let last = "Confirmed page name number 39 with some padding";
+ let id = {
+ let mut store = Store::open(dir.path(), c.clone()).unwrap();
+ let (id, _, _) = publish(&mut store, "Busy");
+ let mut server = store.open(&id).unwrap();
+ let mut a = join(&mut server, Access::Edit);
+ store.changed(&id, &mut server);
+ for i in 0..40 {
+ rename(&mut server, &mut a, &format!("Confirmed page name number {i} with some padding"));
+ store.changed(&id, &mut server);
+ }
+ assert!(store.flush().is_empty());
+ id
+ };
+ let log_path = log_path.join(&id).join(LOG);
+ let before = fs::read(&log_path).unwrap();
+ // The cap lowered just under the log: it can't be read now, but it must still be there after.
+ let lowered = StoreConfig { max_file_bytes: before.len() as u64 - 1, ..c.clone() };
+ {
+ let mut store = Store::open(dir.path(), lowered).unwrap();
+ let opened = store.open(&id);
+ assert!(opened.is_err(), "the file isn't opened without its log");
+ assert!(!store.problems().is_empty(), "the problem is reported");
+ assert_eq!(fs::read(&log_path).unwrap(), before, "the log is left as it was");
+ }
+ let mut store = Store::open(dir.path(), c).unwrap();
+ let server = store.open(&id).unwrap();
+ assert_eq!(page_name(&server), last, "every confirmed edit comes back");
+}
+
+#[test]
+fn a_log_that_isnt_one_is_moved_aside() {
+ let dir = TempDir::new("badlog");
+ let mut store = Store::open(dir.path(), cfg(dir.path())).unwrap();
+ let (id, _, _) = publish(&mut store, "Busy");
+ let folder = dir.path().join(FILES).join(&id);
+ let junk = b"not a log at all, but maybe worth keeping".to_vec();
+ fs::write(folder.join(LOG), &junk).unwrap();
+ drop(store);
+ let mut store = Store::open(dir.path(), cfg(dir.path())).unwrap();
+ store.open(&id).unwrap();
+ assert!(store.problems().iter().any(|p| p.contains("moved aside")), "{:?}", store.problems());
+ let kept = fs::read_dir(&folder).unwrap().filter_map(|e| e.ok()).any(|e| fs::read(e.path()).is_ok_and(|b| b == junk));
+ assert!(kept, "the old log's bytes are kept beside the file");
+}
+
+const BIDI: [char; 12] =
+ ['\u{61C}', '\u{200E}', '\u{200F}', '\u{202A}', '\u{202B}', '\u{202C}', '\u{202D}', '\u{202E}', '\u{2066}', '\u{2067}', '\u{2068}', '\u{2069}'];
+
+#[test]
+fn names_and_report_reasons_lose_bidi_controls() {
+ let dir = TempDir::new("bidi");
+ let mut store = Store::open(dir.path(), cfg(dir.path())).unwrap();
+ for (n, m) in BIDI.into_iter().enumerate() {
+ let ip: std::net::IpAddr = format!("192.0.2.{}", n + 1).parse().unwrap();
+ let (id, _, _) = publish(&mut store, &format!("a{m}b"));
+ assert_eq!(store.list(&|_| None)[0].name, "ab", "name U+{:04X}", m as u32);
+ store.keep_report(&id, None, ip, &format!("a{m}b")).unwrap();
+ assert_eq!(store.reports().last().unwrap().reason, "a b", "reason U+{:04X}", m as u32);
+ store.remove(&id).unwrap();
+ }
+}
+
+#[test]
+fn a_maxed_out_generation_does_not_wrap() {
+ let dir = TempDir::new("maxgen");
+ let c = StoreConfig { compact_after: 3, ..cfg(dir.path()) };
+ let mut store = Store::open(dir.path(), c.clone()).unwrap();
+ let (id, _, _) = publish(&mut store, "Max");
+ let path = dir.path().join(FILES).join(&id);
+ let (_, state) = disk::decode_snapshot(&fs::read(path.join(SNAPSHOT)).unwrap()).unwrap();
+ // Loading: no log goes with the snapshot, so the next generation would overflow.
+ fs::write(path.join(SNAPSHOT), disk::encode_snapshot(u64::MAX, &state).unwrap()).unwrap();
+ fs::remove_file(path.join(LOG)).unwrap();
+ assert!(store.open(&id).is_err());
+ // Compacting: the open log is at the largest generation.
+ fs::write(path.join(SNAPSHOT), disk::encode_snapshot(u64::MAX - 1, &state).unwrap()).unwrap();
+ let _ = fs::remove_file(path.join(LOG));
+ let mut server = store.open(&id).unwrap();
+ let mut a = join(&mut server, Access::Edit);
+ store.changed(&id, &mut server);
+ for i in 0..4 {
+ rename(&mut server, &mut a, &format!("P{i}"));
+ store.changed(&id, &mut server);
+ store.flush();
+ }
+ let snap = disk::check_snapshot(&fs::read(path.join(SNAPSHOT)).unwrap()).unwrap();
+ assert_eq!(snap, u64::MAX);
+}
+
+#[test]
+fn every_leftover_temporary_file_is_removed_at_startup() {
+ let dir = TempDir::new("leftovers");
+ let id = {
+ let mut store = Store::open(dir.path(), cfg(dir.path())).unwrap();
+ let id = publish(&mut store, "A").0;
+ store.flush();
+ id
+ };
+ let folder = dir.path().join(FILES).join(&id);
+ let leftovers = [
+ dir.path().join("blocked.json.tmp"),
+ dir.path().join("reports.json.tmp"),
+ dir.path().join("server.key.tmp"),
+ folder.join("usage.json.tmp"),
+ folder.join("library-1.bin.tmp"),
+ ];
+ for path in &leftovers {
+ fs::write(path, b"half").unwrap();
+ }
+ let _store = Store::open(dir.path(), cfg(dir.path())).unwrap();
+ for path in &leftovers {
+ assert!(!path.exists(), "leftover not cleaned at startup: {}", path.display());
+ }
+}
diff --git a/apps/figcraft-server/tests/header_recovery.rs b/apps/figcraft-server/tests/it/header_recovery.rs
similarity index 98%
rename from apps/figcraft-server/tests/header_recovery.rs
rename to apps/figcraft-server/tests/it/header_recovery.rs
index d728908d..bb0be1d0 100644
--- a/apps/figcraft-server/tests/header_recovery.rs
+++ b/apps/figcraft-server/tests/it/header_recovery.rs
@@ -2,7 +2,6 @@
//! holds confirmed edits (#408): the log is replayed over the snapshot, which only the changes the
//! snapshot lacks survive, and the damage is reported. A genuine leftover of a compaction cut short
//! still restores silently.
-#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
use figcraft_collab::message::{Access, ClientMsg};
use figcraft_collab::{Client, Outgoing, Replica, Server};
diff --git a/apps/figcraft-server/tests/it/main.rs b/apps/figcraft-server/tests/it/main.rs
new file mode 100644
index 00000000..3027ed99
--- /dev/null
+++ b/apps/figcraft-server/tests/it/main.rs
@@ -0,0 +1,5 @@
+//! The crate's integration tests, built as one test binary.
+
+#[allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
+mod header_recovery;
+mod problem_retention;
diff --git a/apps/figcraft-server/tests/problem_retention.rs b/apps/figcraft-server/tests/it/problem_retention.rs
similarity index 100%
rename from apps/figcraft-server/tests/problem_retention.rs
rename to apps/figcraft-server/tests/it/problem_retention.rs
diff --git a/apps/figcraft-web/Cargo.toml b/apps/figcraft-web/Cargo.toml
index 2f1a8190..ffd44f3b 100644
--- a/apps/figcraft-web/Cargo.toml
+++ b/apps/figcraft-web/Cargo.toml
@@ -26,4 +26,4 @@ eframe = { workspace = true, features = ["default_fonts", "wgpu", "accesskit"] }
wasm-bindgen = "0.2"
js-sys = "0.3"
wasm-bindgen-futures = "0.4"
-web-sys = { version = "0.3", features = ["Window", "Document", "Element", "HtmlCanvasElement", "HtmlElement", "HtmlAnchorElement", "Node", "Blob", "BlobPropertyBag", "Url", "Location", "MediaQueryList", "Navigator", "Gamepad", "GamepadButton", "GamepadMappingType"] }
+web-sys = { version = "0.3", features = ["Window", "Document", "Element", "HtmlCanvasElement", "HtmlElement", "HtmlAnchorElement", "Node", "Blob", "BlobPropertyBag", "File", "FileList", "HtmlInputElement", "EventTarget", "Url", "Location", "MediaQueryList", "Navigator", "Gamepad", "GamepadButton", "GamepadMappingType"] }
diff --git a/apps/figcraft-web/src/web.rs b/apps/figcraft-web/src/web.rs
index 29213621..f08ca90f 100644
--- a/apps/figcraft-web/src/web.rs
+++ b/apps/figcraft-web/src/web.rs
@@ -1,7 +1,7 @@
//! The browser shell: web `Services` and the eframe web runner.
use figcraft_engine::Session;
-use figcraft_ui_egui::{FigApp, Services};
+use figcraft_ui_egui::{ContentsFuture, FigApp, Services};
use wasm_bindgen::JsCast as _;
const CANVAS_ID: &str = "figcraft_canvas";
@@ -75,9 +75,10 @@ impl eframe::App for WebShell {
}
}
-/// Browser services. Open dialogs return nothing for now (the trait's defaults); files are saved
-/// as downloads. Copies go to the system clipboard through egui's output; pastes arrive as paste
-/// events with their text (a page can't read the clipboard when it likes).
+/// Browser services. Files are opened and imported through the browser's file picker, which hands
+/// over their contents (pickers that need a path return nothing, the trait's defaults); files are
+/// saved as downloads. Copies go to the system clipboard through egui's output; pastes arrive as
+/// paste events with their text (a page can't read the clipboard when it likes).
struct WebServices {
/// `prefers-reduced-motion: reduce` (it follows the setting while the page is open).
reduce_motion: Option
,
@@ -85,6 +86,16 @@ struct WebServices {
}
impl Services for WebServices {
+ /// An ` {
+ let accept = exts.iter().map(|e| format!(".{e}")).collect::>().join(",");
+ Some(Box::pin(async move {
+ pick_file(&accept).await.unwrap_or_else(|e| {
+ log::error!("couldn't open a file: {e:?}");
+ None
+ })
+ }))
+ }
fn downloads(&self) -> bool {
true
}
@@ -136,6 +147,90 @@ impl Services for WebServices {
}
}
+/// The file picked in the browser's file picker (`accept`: the extensions it offers), with its
+/// name; `None` when the picker is cancelled, `Some(Err)` with what to tell the user when the file
+/// can't be read.
+async fn pick_file(accept: &str) -> Result), String>>, wasm_bindgen::JsValue> {
+ let window = web_sys::window().ok_or("no window")?;
+ let document = window.document().ok_or("no document")?;
+ let body = document.body().ok_or("no body")?;
+ let input: web_sys::HtmlInputElement = document.create_element("input")?.dyn_into()?;
+ input.set_type("file");
+ input.set_accept(accept);
+ input.set_hidden(true);
+ // Some browsers (older Safari) open the picker only for an input in the page.
+ body.append_child(&input)?;
+ let (closed, picker) = PickerClosed::new(&window, input.clone());
+ input.click();
+ let result = wasm_bindgen_futures::JsFuture::from(closed).await;
+ let file = input.files().and_then(|files| files.get(0));
+ drop(picker);
+ result?;
+ let Some(file) = file else { return Ok(None) };
+ let name = file.name();
+ if let Err(why) = figcraft_ui_egui::browser_can_read(&name, file.size()) {
+ return Ok(Some(Err(why)));
+ }
+ Ok(Some(match wasm_bindgen_futures::JsFuture::from(file.array_buffer()).await {
+ Ok(buffer) => Ok((name, js_sys::Uint8Array::new(&buffer).to_vec())),
+ Err(e) => {
+ log::error!("couldn't read {name}: {e:?}");
+ Err(figcraft_ui_egui::unreadable(&name))
+ }
+ }))
+}
+
+/// How long after the page gets focus back the file picker counts as closed (milliseconds): a
+/// picked file's `change` can come just after the focus, and must win. A `change` later than this
+/// (a slow cloud-backed file in a browser that never sends `cancel`) counts as a cancel.
+const PICKER_FOCUS_SETTLE_MS: i32 = 1_000;
+
+/// Settles a file picker's promise once: on `change` (a file was picked), on `cancel` (closed
+/// without one) or shortly after the page gets focus back, for browsers that never send `cancel`
+/// (Safari before 16.4), where the pick would otherwise stay pending and block every later one.
+/// Dropping it (also when the pick is abandoned) removes the input, the focus listener and its timer.
+struct PickerClosed {
+ window: web_sys::Window,
+ input: web_sys::HtmlInputElement,
+ _settle: wasm_bindgen::closure::Closure,
+ on_focus: wasm_bindgen::closure::Closure,
+ timer: std::rc::Rc>>,
+}
+
+impl PickerClosed {
+ fn new(window: &web_sys::Window, input: web_sys::HtmlInputElement) -> (js_sys::Promise, Self) {
+ let resolve = std::rc::Rc::new(std::cell::RefCell::new(None::));
+ let slot = resolve.clone();
+ let closed = js_sys::Promise::new(&mut |res, _rej| *slot.borrow_mut() = Some(res));
+ let settle = wasm_bindgen::closure::Closure::::new(move || {
+ if let Some(res) = resolve.borrow_mut().take() {
+ let _ = res.call0(&wasm_bindgen::JsValue::NULL);
+ }
+ });
+ let _ = input.add_event_listener_with_callback("change", settle.as_ref().unchecked_ref());
+ let _ = input.add_event_listener_with_callback("cancel", settle.as_ref().unchecked_ref());
+ let timer = std::rc::Rc::new(std::cell::Cell::new(None));
+ let (w, t, f) = (window.clone(), timer.clone(), settle.as_ref().unchecked_ref::().clone());
+ let on_focus = wasm_bindgen::closure::Closure::::new(move || {
+ if t.get().is_none() {
+ t.set(w.set_timeout_with_callback_and_timeout_and_arguments_0(&f, PICKER_FOCUS_SETTLE_MS).ok());
+ }
+ });
+ let _ = window.add_event_listener_with_callback("focus", on_focus.as_ref().unchecked_ref());
+ (closed, Self { window: window.clone(), input, _settle: settle, on_focus, timer })
+ }
+}
+
+impl Drop for PickerClosed {
+ fn drop(&mut self) {
+ if let Some(t) = self.timer.take() {
+ self.window.clear_timeout_with_handle(t);
+ }
+ let _ = self.window.remove_event_listener_with_callback("focus", self.on_focus.as_ref().unchecked_ref());
+ self.input.remove();
+ }
+}
+
fn download(name: &str, bytes: &[u8]) -> Result<(), wasm_bindgen::JsValue> {
let window = web_sys::window().ok_or("no window")?;
let document = window.document().ok_or("no document")?;
diff --git a/apps/figcraft/Cargo.toml b/apps/figcraft/Cargo.toml
index fac4842b..6196d08d 100644
--- a/apps/figcraft/Cargo.toml
+++ b/apps/figcraft/Cargo.toml
@@ -16,6 +16,10 @@ figcraft-ui-egui = { workspace = true }
figcraft-collab-net = { workspace = true }
figcraft-format = { workspace = true }
figcraft-text = { workspace = true }
+# Shared decision of who draws the window frame on Linux (compositor vs. app), replacing the
+# bespoke Wayland xdg-decoration probe. See `[workspace.dependencies]`: pinned to the unmerged
+# craft-libs#217 branch and must be repointed to a merged `rev` before this PR is mergeable.
+craft-window = { workspace = true }
egui = { workspace = true }
eframe = { workspace = true, features = ["default_fonts", "wgpu", "accesskit", "wayland", "x11"] }
serde_json = { workspace = true }
@@ -45,7 +49,6 @@ wat = { workspace = true }
winresource = "0.1"
[target.'cfg(target_os = "linux")'.dependencies]
-# Use vector window controls without a title-font renderer or embedded Cantarell.
+# Use vector window controls without a title-font renderer or embedded Cantarell. The compositor
+# probe that used to need raw-window-handle and wayland-client here now lives in craft-window.
winit = { version = "0.30", default-features = false, features = ["wayland-csd-adwaita-notitle"] }
-raw-window-handle = "0.6"
-wayland-client = "0.31"
diff --git a/apps/figcraft/src/args.rs b/apps/figcraft/src/args.rs
index 3b4136d9..436df61f 100644
--- a/apps/figcraft/src/args.rs
+++ b/apps/figcraft/src/args.rs
@@ -2,12 +2,14 @@
//! [--automation-write-root ]… [files…] [figcraft://join?…]`. An invite link
//! (what the system passes when a `figcraft://` link is opened) joins that session once the window
//! is up; everything else that isn't a flag is a file to open, as a path or a `file://` URL (the
-//! Linux desktop entry passes URLs, `%U`, so that it can also hand over invite links).
+//! Linux desktop entry passes URLs, `%U`, so that it can also hand over invite links). Any other
+//! `--flag` is unknown and stops the app at startup (#836): a mistyped root flag must never leave
+//! the app running unconfined. After a bare `--`, every argument is a file.
/// What the app was started with.
#[derive(Debug, Default, PartialEq, Eq)]
pub struct Args {
- /// `--control `: the JSON-lines control server.
+ /// `--control ` (or `--control=`): the JSON-lines control server.
pub control: Option,
pub files: Vec,
/// The last invite link given.
@@ -17,6 +19,8 @@ pub struct Args {
/// which is refused at startup.
pub read_roots: Vec,
pub write_roots: Vec,
+ /// `--flags` the app doesn't know, as given.
+ pub unknown: Vec,
}
/// An invite link rather than a file (`figcraft:` links, in any case).
@@ -55,6 +59,10 @@ pub fn parse(args: &[String]) -> Args {
let mut out = Args::default();
let mut it = args.iter();
while let Some(a) = it.next() {
+ if a == "--" {
+ out.files.extend(it.by_ref().cloned());
+ break;
+ }
let (flag, inline) = a.split_once('=').map_or((a.as_str(), None), |(f, v)| (f, Some(v.to_string())));
let roots = match flag {
"--automation-read-root" => Some(&mut out.read_roots),
@@ -63,13 +71,15 @@ pub fn parse(args: &[String]) -> Args {
};
if let Some(roots) = roots {
roots.push(inline.or_else(|| it.next().cloned()).unwrap_or_default());
- } else if a == "--control" {
- out.control = it.next().and_then(|p| p.parse().ok());
+ } else if flag == "--control" {
+ out.control = inline.or_else(|| it.next().cloned()).and_then(|p| p.parse().ok());
} else if is_invite(a) {
out.join = Some(a.clone());
} else if let Some(path) = file_url_path(a) {
out.files.push(path);
- } else if !a.starts_with("--") {
+ } else if a.starts_with("--") {
+ out.unknown.push(a.clone());
+ } else {
out.files.push(a.clone());
}
}
diff --git a/apps/figcraft/src/args_tests.rs b/apps/figcraft/src/args_tests.rs
index 2ae29b3c..b274beda 100644
--- a/apps/figcraft/src/args_tests.rs
+++ b/apps/figcraft/src/args_tests.rs
@@ -9,13 +9,21 @@ fn args(a: &[&str]) -> Vec {
#[test]
fn files_and_the_control_port() {
assert_eq!(parse(&args(&[])), Args::default());
- let a = parse(&args(&["--control", "4242", "a.figcraft", "--verbose", "b.svg"]));
+ let a = parse(&args(&["--control", "4242", "a.figcraft", "b.svg"]));
assert_eq!(a, Args { control: Some(4242), files: args(&["a.figcraft", "b.svg"]), ..Args::default() });
// A missing or bad port is ignored, not taken as a file.
assert_eq!(parse(&args(&["--control"])), Args::default());
assert_eq!(parse(&args(&["--control", "nope"])).control, None);
}
+#[test]
+fn the_control_port_accepts_the_equals_form() {
+ let a = parse(&args(&["--control=7980", "a.figcraft"]));
+ assert_eq!(a, Args { control: Some(7980), files: args(&["a.figcraft"]), ..Args::default() });
+ // A bad port is ignored, not taken as a file.
+ assert_eq!(parse(&args(&["--control=nope"])), Args::default());
+}
+
#[test]
fn automation_roots_repeat_and_are_never_files() {
let a = parse(&args(&["--automation-read-root", "in", "--automation-write-root=out", "--automation-read-root=more", "a.figcraft"]));
@@ -26,6 +34,19 @@ fn automation_roots_repeat_and_are_never_files() {
assert_eq!(parse(&args(&["--automation-write-root"])).write_roots, args(&[""]));
}
+#[test]
+fn unknown_flags_are_refused_never_ignored() {
+ // #836: a mistyped root flag (or one an older release lacks) must stop the app, not start it
+ // unconfined. Both forms, with and without `=`.
+ let a = parse(&args(&["--automation-write-roots", "out", "--automation-write-dir=out", "--verbose", "a.figcraft"]));
+ assert_eq!(a.unknown, args(&["--automation-write-roots", "--automation-write-dir=out", "--verbose"]));
+ assert!(a.write_roots.is_empty());
+ // Single-dash arguments are left as they were (files); after `--` everything is a file.
+ let a = parse(&args(&["--control", "1", "--", "--odd.figcraft", "--automation-write-root=x"]));
+ assert_eq!(a.files, args(&["--odd.figcraft", "--automation-write-root=x"]));
+ assert!(a.unknown.is_empty() && a.write_roots.is_empty());
+}
+
#[test]
fn invite_links_join_instead_of_opening() {
let link = "figcraft://join?host=192.168.1.20:47900&file=abc&token=AbCdEfGhIjKlMnOpQrStUv";
diff --git a/apps/figcraft/src/control_server.rs b/apps/figcraft/src/control_server.rs
index 1c91840f..ff9c2fbe 100644
--- a/apps/figcraft/src/control_server.rs
+++ b/apps/figcraft/src/control_server.rs
@@ -16,6 +16,10 @@ const MAX_LINE: usize = 32 * 1024 * 1024;
const MAX_CONNECTIONS: usize = 8;
const MAX_QUEUED_REQUESTS: usize = 8;
const TIMEOUT: Duration = Duration::from_secs(60);
+/// How long the accepting thread waits after a failed accept. Accepting can keep failing, for
+/// example while the process has no file descriptors left, and retrying at once would keep a
+/// core busy until it recovers.
+const ACCEPT_RETRY: Duration = Duration::from_millis(100);
/// Deferred requests for a hidden window must not make the UI's queue grow without a bound.
pub fn drain_queue(queue: &Queue, target: &mut Vec) {
@@ -38,7 +42,7 @@ pub fn start(port: u16, queue: Queue, ctx: CtxSlot) {
eprintln!("FigCraft control server listening on 127.0.0.1:{port}");
let spawned = std::thread::Builder::new().name("figcraft-control".into()).spawn(move || {
let mut workers = Vec::new();
- for stream in listener.incoming().flatten() {
+ for stream in accepted(listener.incoming(), || std::thread::sleep(ACCEPT_RETRY)) {
spawn_connection(stream, queue.clone(), ctx.clone(), &mut workers, TIMEOUT);
}
});
@@ -47,6 +51,11 @@ pub fn start(port: u16, queue: Queue, ctx: CtxSlot) {
}
}
+/// The connections `incoming` accepts, calling `wait` after each failed accept.
+fn accepted(incoming: impl Iterator- >, mut wait: impl FnMut()) -> impl Iterator
- {
+ incoming.filter_map(move |stream| stream.map_err(|_| wait()).ok())
+}
+
fn spawn_connection(stream: TcpStream, queue: Queue, ctx: CtxSlot, workers: &mut Vec
>, timeout: Duration) {
workers.retain(|worker| !worker.is_finished());
if workers.len() >= MAX_CONNECTIONS {
diff --git a/apps/figcraft/src/control_server_tests.rs b/apps/figcraft/src/control_server_tests.rs
index 008170fb..011b0613 100644
--- a/apps/figcraft/src/control_server_tests.rs
+++ b/apps/figcraft/src/control_server_tests.rs
@@ -131,6 +131,18 @@ fn idle_and_partial_frame_connections_expire() {
}
}
+/// A failed accept is followed by a wait before the next one, so a listener that keeps failing
+/// does not spin, and the connections around the failures still come through.
+#[test]
+fn a_failed_accept_waits_before_the_next() {
+ let failed = || Err(std::io::Error::other("no file descriptors left"));
+ let incoming = vec![failed(), Ok(1), failed(), failed(), Ok(2)];
+ let mut waits = 0;
+ let connections: Vec = accepted(incoming.into_iter(), || waits += 1).collect();
+ assert_eq!(connections, [1, 2]);
+ assert_eq!(waits, 3, "one wait per failed accept");
+}
+
#[test]
fn connection_limit_rejects_excess_clients_and_reuses_finished_slots() {
let pending = queue();
diff --git a/apps/figcraft/src/linux_window.rs b/apps/figcraft/src/linux_window.rs
deleted file mode 100644
index f47b61e0..00000000
--- a/apps/figcraft/src/linux_window.rs
+++ /dev/null
@@ -1,112 +0,0 @@
-//! Request winit's frame only on Wayland compositors without xdg-decoration.
-//! Desktop/session names cannot identify the backend of an individual window.
-
-use std::os::unix::net::UnixStream;
-use std::path::PathBuf;
-use std::sync::mpsc;
-use std::time::Duration;
-
-use raw_window_handle::{HasDisplayHandle, RawDisplayHandle};
-use wayland_client::globals::{GlobalListContents, registry_queue_init};
-use wayland_client::protocol::wl_registry;
-use wayland_client::{Connection, Dispatch, QueueHandle};
-
-/// Capture the socket path before winit consumes an inherited WAYLAND_SOCKET.
-/// Never consume, duplicate or query that inherited connection: there may be no
-/// independently addressable display, or WAYLAND_DISPLAY may name another server.
-pub fn display_socket() -> Option {
- if std::env::var_os("WAYLAND_SOCKET").is_some_and(|s| !s.is_empty()) {
- return None;
- }
- let display = std::env::var_os("WAYLAND_DISPLAY").filter(|s| !s.is_empty())?;
- let path = PathBuf::from(display);
- if path.is_absolute() {
- Some(path)
- } else {
- std::env::var_os("XDG_RUNTIME_DIR").filter(|s| !s.is_empty()).map(|dir| PathBuf::from(dir).join(path))
- }
-}
-
-pub fn needs_native_frame(cc: &eframe::CreationContext<'_>, socket: Option) -> bool {
- let wayland = cc.display_handle().is_ok_and(|h| matches!(h.as_raw(), RawDisplayHandle::Wayland(_)));
- if !wayland {
- log::debug!("window controls: non-Wayland window, retaining custom controls");
- return false;
- }
- let server_decorations = socket.and_then(probe);
- log::debug!("window controls: Wayland xdg-decoration available: {server_decorations:?}");
- native_frame(wayland, server_decorations)
-}
-
-fn native_frame(wayland: bool, server_decorations: Option) -> bool {
- wayland && server_decorations == Some(false)
-}
-
-fn probe(socket: PathBuf) -> Option {
- // The compositor must not be able to block startup on a registry roundtrip.
- // On failure/timeout retain FigCraft's own working title bar and buttons.
- let (send, receive) = mpsc::sync_channel(1);
- std::thread::Builder::new()
- .name("wayland-decorations".into())
- .spawn(move || {
- let _ = send.send(registry_has_decorations(socket));
- })
- .ok()?;
- receive.recv_timeout(Duration::from_millis(500)).ok().flatten()
-}
-
-fn registry_has_decorations(socket: PathBuf) -> Option {
- // A fresh connection leaves winit's event queue and inherited descriptors alone.
- let stream = UnixStream::connect(socket).ok()?;
- let connection = Connection::from_socket(stream).ok()?;
- let (globals, _queue) = registry_queue_init::(&connection).ok()?;
- Some(globals.contents().with_list(|list| list.iter().any(|g| g.interface == "zxdg_decoration_manager_v1")))
-}
-
-struct Registry;
-
-impl Dispatch for Registry {
- fn event(
- _state: &mut Self,
- _registry: &wl_registry::WlRegistry,
- _event: wl_registry::Event,
- _data: &GlobalListContents,
- _connection: &Connection,
- _queue: &QueueHandle,
- ) {
- }
-}
-
-#[cfg(test)]
-mod tests {
- #[test]
- fn only_wayland_without_server_decorations_uses_the_frame() {
- for (wayland, server_decorations, expected) in [
- (false, None, false),
- (false, Some(false), false),
- (false, Some(true), false),
- (true, Some(true), false),
- (true, Some(false), true),
- (true, None, false),
- ] {
- assert_eq!(super::native_frame(wayland, server_decorations), expected);
- }
- }
-
- #[test]
- fn an_unavailable_display_keeps_the_custom_controls() {
- assert_eq!(super::probe("/nonexistent/figcraft-wayland-test".into()), None);
- }
-
- #[test]
- fn an_unresponsive_display_cannot_block_window_startup() -> std::io::Result<()> {
- let socket = std::env::temp_dir().join(format!("figcraft-decoration-timeout-{}", std::process::id()));
- let listener = std::os::unix::net::UnixListener::bind(&socket)?;
- let start = std::time::Instant::now();
- assert_eq!(super::probe(socket.clone()), None);
- assert!(start.elapsed() < std::time::Duration::from_secs(2));
- drop(listener);
- let _ = std::fs::remove_file(socket);
- Ok(())
- }
-}
diff --git a/apps/figcraft/src/main.rs b/apps/figcraft/src/main.rs
index ddb70204..0b71149a 100644
--- a/apps/figcraft/src/main.rs
+++ b/apps/figcraft/src/main.rs
@@ -10,7 +10,8 @@
//! `--automation-read-root ` / `--automation-write-root ` (each repeatable) confine the
//! files the window and the control channel read and write (`figcraft_engine::file_access`); the
//! app's own folders (settings, recovery copies, installed plugins) and opening the files given on
-//! the command line are not. A root that isn't an existing folder stops the app at startup.
+//! the command line are not. A root that isn't an existing folder stops the app at startup, and so
+//! does any flag the app doesn't know (a mistyped root flag must not start the app unconfined).
#![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)]
#![cfg_attr(all(target_os = "windows", not(debug_assertions)), windows_subsystem = "windows")]
@@ -20,8 +21,6 @@ mod args;
mod control_server;
mod gamepad;
mod graphics;
-#[cfg(target_os = "linux")]
-mod linux_window;
mod recovery;
mod services;
mod startup;
@@ -129,6 +128,12 @@ fn main() -> eframe::Result {
return Ok(());
}
let args = args::parse(&args);
+ if let Some(flag) = args.unknown.first() {
+ eprintln!(
+ "FigCraft: unknown option {flag}\nUsage: figcraft [--control PORT] [--automation-read-root DIR]... [--automation-write-root DIR]... [FILE | figcraft://join?...]..."
+ );
+ std::process::exit(2);
+ }
let roots = match (
args.read_roots.is_empty() && args.write_roots.is_empty(),
figcraft_engine::file_access::Roots::new(&args.read_roots, &args.write_roots),
@@ -186,10 +191,8 @@ fn main() -> eframe::Result {
// default, never a build from source unless asked).
session.live.links = figcraft_collab_net::links::system();
session.invite_links_startup();
- // A first run (no settings kept yet, nothing to open) starts on the home screen, with its
- // tips and templates; later runs start in a new file.
let first_run = svc.prefs.is_none() && args.join.is_none();
- if session.docs.is_empty() && !first_run {
+ if session.docs.is_empty() && opens_new_file(first_run, session.prefs.start_on_home, port.is_some()) {
let _ = session.execute("file.new", &json!({}));
}
// The interface language from the first frame on, and for the message when the window can't
@@ -217,8 +220,13 @@ fn main() -> eframe::Result {
.with_inner_size([1440.0, 900.0])
.with_min_inner_size([800.0, 500.0])
.with_drag_and_drop(true);
- // Start frameless on Linux; the app creator checks the actual display backend
- // before enabling a client-side frame. Other windows inherit that decision.
+ // Who draws the window frame is decided once, before the viewport is built, by the shared
+ // craft-window crate (the rest of the Craft suite uses it too). On macOS the system frame is
+ // kept with FigCraft's inset traffic lights; on Windows it is the system frame; on Linux the
+ // decision follows the desktop: a Wayland compositor with server-side decorations (KDE, Sway,
+ // Hyprland, COSMIC) or an X11 window manager keeps the native frame, while GNOME's Mutter —
+ // which draws no server-side frame — leaves it to the app's own custom title bar. This replaces
+ // the old bespoke xdg-decoration probe that always drew FigCraft's custom title bar on KDE.
fig.ui.title_bar = desktop_title_bar();
viewport = window_chrome(viewport, fig.ui.title_bar);
if let Some(icon) = icon {
@@ -227,8 +235,6 @@ fn main() -> eframe::Result {
let mut options = eframe::NativeOptions { viewport, renderer: eframe::Renderer::Wgpu, ..Default::default() };
graphics::configure(&mut options.wgpu_options);
figcraft_ui_egui::windows::install(fig);
- #[cfg(target_os = "linux")]
- let linux_display = linux_window::display_socket();
// Registered before the event loop starts, so it catches the Finder event that launched the app
// as well as later ones. Lives until the event loop returns; the app creator only borrows it.
#[cfg(target_os = "macos")]
@@ -239,11 +245,6 @@ fn main() -> eframe::Result {
"FigCraft",
options,
Box::new(move |_cc| {
- #[cfg(target_os = "linux")]
- if linux_window::needs_native_frame(_cc, linux_display) {
- let _ = with_app(|fig| fig.ui.title_bar = figcraft_ui_egui::TitleBar::Native);
- _cc.egui_ctx.send_viewport_cmd(egui::ViewportCommand::Decorations(true));
- }
Ok(Box::new(App {
queue,
ctx_slot,
@@ -261,9 +262,43 @@ fn main() -> eframe::Result {
result
}
+/// With nothing to open, whether the window starts in a new file rather than on the home screen.
+/// A first run (no settings kept yet) shows the home screen's tips and templates, and later runs
+/// start in a new file unless the preference asks for Home, which `--control` overrides: its
+/// callers expect a document to act on.
+fn opens_new_file(first_run: bool, start_on_home: bool, control: bool) -> bool {
+ !first_run && (!start_on_home || control)
+}
+
+/// The title bar FigCraft starts with, decided by the shared craft-window crate so every Craft app
+/// agrees on who draws the frame per desktop. The override variable is `FIGCRAFT_TITLEBAR`
+/// (`app` / `system`). macOS keeps its inset traffic lights unchanged (craft-window returns the
+/// desktop frame there); Windows keeps the system frame; on Linux the compositor/window manager
+/// decides (KDE/Sway/Hyprland/COSMIC and X11 keep the native frame, GNOME gets the custom one).
fn desktop_title_bar() -> figcraft_ui_egui::TitleBar {
+ let choice = craft_window::Choice::probe(craft_window::Prefix::new("FIGCRAFT"));
+ title_bar_for(choice.into_frame())
+}
+
+/// Map craft-window's [`craft_window::Frame`] onto FigCraft's own [`figcraft_ui_egui::TitleBar`].
+///
+/// `Frame::App` means the app draws its own frame — FigCraft's custom title bar. `Frame::Desktop`
+/// means the desktop draws it, but FigCraft keeps each platform's existing look there:
+/// - macOS: the inset title bar with its traffic lights (`TitleBar::Inset`), unchanged.
+/// - Windows: FigCraft's own custom title bar (`TitleBar::Custom`), unchanged — Windows never used
+/// the plain native frame, and craft-window returning `Desktop` on Windows must not change that.
+/// - Linux and the BSDs: the compositor's native frame (`TitleBar::Native`). This is the only
+/// behaviour change: KDE and the other server-side-decoration compositors now keep their frame.
+fn title_bar_for(frame: craft_window::Frame) -> figcraft_ui_egui::TitleBar {
use figcraft_ui_egui::TitleBar;
- if cfg!(target_os = "macos") { TitleBar::Inset } else { TitleBar::Custom }
+ match frame {
+ craft_window::Frame::Desktop if cfg!(target_os = "macos") => TitleBar::Inset,
+ // Windows kept FigCraft's own title bar before this change; keep it.
+ craft_window::Frame::Desktop if cfg!(target_os = "windows") => TitleBar::Custom,
+ craft_window::Frame::Desktop => TitleBar::Native,
+ // The app draws the frame (GNOME's Wayland session, or a `FIGCRAFT_TITLEBAR=app` override).
+ craft_window::Frame::App(_) => TitleBar::Custom,
+ }
}
fn window_chrome(viewport: egui::ViewportBuilder, title_bar: figcraft_ui_egui::TitleBar) -> egui::ViewportBuilder {
@@ -275,13 +310,66 @@ fn window_chrome(viewport: egui::ViewportBuilder, title_bar: figcraft_ui_egui::T
}
}
-#[cfg(all(test, target_os = "linux"))]
-mod linux_window_tests {
+#[cfg(test)]
+mod title_bar_tests {
+ use figcraft_ui_egui::TitleBar;
+
+ /// craft-window's app frame (GNOME's Wayland session, or a `FIGCRAFT_TITLEBAR=app` override)
+ /// becomes FigCraft's custom title bar on every platform, and `window_chrome` then drops the
+ /// decorations so FigCraft draws its own.
#[test]
- fn linux_starts_with_the_existing_frameless_title_bar() {
- let bar = super::desktop_title_bar();
- assert_eq!(bar, figcraft_ui_egui::TitleBar::Custom);
+ fn the_app_frame_maps_to_the_custom_title_bar() {
+ let layout = craft_window::Layout::default();
+ let bar = super::title_bar_for(craft_window::Frame::App(layout));
+ assert_eq!(bar, TitleBar::Custom);
let viewport = super::window_chrome(egui::ViewportBuilder::default(), bar);
assert_eq!(viewport.decorations, Some(false));
}
+
+ /// craft-window's desktop frame keeps each platform's existing look: macOS its inset traffic
+ /// lights, Windows FigCraft's own custom title bar (unchanged), and Linux/BSD the compositor's
+ /// native frame. The Linux case is the only behaviour change: KDE and the other
+ /// server-side-decoration compositors now keep their native frame.
+ #[test]
+ fn the_desktop_frame_is_mapped_per_platform() {
+ let bar = super::title_bar_for(craft_window::Frame::Desktop);
+ if cfg!(target_os = "macos") {
+ assert_eq!(bar, TitleBar::Inset);
+ } else if cfg!(target_os = "windows") {
+ // Windows kept its own title bar before and must keep it now.
+ assert_eq!(bar, TitleBar::Custom);
+ let viewport = super::window_chrome(egui::ViewportBuilder::default(), bar);
+ assert_eq!(viewport.decorations, Some(false));
+ } else {
+ assert_eq!(bar, TitleBar::Native);
+ let viewport = super::window_chrome(egui::ViewportBuilder::default(), bar);
+ assert_eq!(viewport.decorations, Some(true));
+ }
+ }
+
+ /// macOS is untouched by this change: its inset title bar with the system traffic lights stays,
+ /// and `window_chrome` still asks for the full-size content view rather than toggling the
+ /// window decorations.
+ #[test]
+ #[cfg(target_os = "macos")]
+ fn macos_keeps_its_inset_title_bar() {
+ let bar = super::desktop_title_bar();
+ assert_eq!(bar, TitleBar::Inset);
+ let viewport = super::window_chrome(egui::ViewportBuilder::default(), bar);
+ assert_eq!(viewport.fullsize_content_view, Some(true));
+ assert_eq!(viewport.title_shown, Some(false));
+ }
+}
+
+#[cfg(test)]
+mod start_tests {
+ use super::opens_new_file;
+
+ #[test]
+ fn the_home_preference_starts_on_home_except_for_control_callers() {
+ assert!(opens_new_file(false, false, false), "a new file by default");
+ assert!(!opens_new_file(false, true, false), "Home when the preference asks");
+ assert!(opens_new_file(false, true, true), "--control still starts with a document");
+ assert!(!opens_new_file(true, false, false), "a first run shows the home screen");
+ }
}
diff --git a/apps/figcraft/src/recovery.rs b/apps/figcraft/src/recovery.rs
index 62243bc7..06b0cbeb 100644
--- a/apps/figcraft/src/recovery.rs
+++ b/apps/figcraft/src/recovery.rs
@@ -120,8 +120,7 @@ impl Recovery {
(0..10).find_map(|n| {
let dir = root.join(if n == 0 { pid.to_string() } else { format!("{pid}-{n}") });
std::fs::create_dir_all(&dir).ok()?;
- let lock = File::options().write(true).create(true).truncate(false).open(dir.join(LOCK)).ok()?;
- lock.try_lock().ok()?;
+ let lock = lock_folder(&dir).ok()?;
Some(Self { dir, _lock: lock, written: HashMap::new(), next: 0.0, waiting: Vec::new() })
})
}
@@ -293,6 +292,17 @@ fn remove_kept(w: Waiting) {
/// The extension of the note beside the copy of a document that is one of your online files.
const ONLINE: &str = "online";
+/// How long the startup waits, once, for folder locks that may free themselves (#334).
+#[cfg(unix)]
+const LOCK_WAIT: std::time::Duration = std::time::Duration::from_millis(100);
+
+/// Lock the folder `dir` (`WouldBlock` while another process holds it).
+fn lock_folder(dir: &Path) -> Result {
+ let lock = File::options().write(true).create(true).truncate(false).open(dir.join(LOCK)).map_err(std::fs::TryLockError::Error)?;
+ lock.try_lock()?;
+ Ok(lock)
+}
+
/// The copy at `file` is of one of your online files: join that file again as its owner, keeping
/// the copy to compare with what arrives. The session, or `None` when the copy isn't one (or its
/// file isn't recorded any more, or is open already): then it opens as any other copy.
@@ -362,6 +372,7 @@ pub fn recover_all(root: &Path, s: &mut Session) -> Recovered {
}
}
};
+ let (mut free, mut held) = (Vec::new(), Vec::new());
for e in entries.flatten() {
let path = e.path();
if !path.is_dir() {
@@ -369,10 +380,22 @@ pub fn recover_all(root: &Path, s: &mut Session) -> Recovered {
continue;
}
// Still running (another window of the app), or not ours to take.
- let Ok(lock) = File::options().write(true).create(true).truncate(false).open(path.join(LOCK)) else { continue };
- if lock.try_lock().is_err() {
- continue;
+ match lock_folder(&path) {
+ Ok(lock) => free.push((path, lock)),
+ Err(std::fs::TryLockError::WouldBlock) => held.push(path),
+ Err(_) => {}
}
+ }
+ // A child between its `fork` and its `exec` shares the run's open descriptors, and a `flock`
+ // lasts while any of them is open, so an ended run's folder can look held for a moment. Wait
+ // once, however many folders are held, and try those again (#334). Windows doesn't pass the
+ // lock to child processes.
+ #[cfg(unix)]
+ if !held.is_empty() {
+ std::thread::sleep(LOCK_WAIT);
+ free.extend(held.into_iter().filter_map(|path| lock_folder(&path).ok().map(|lock| (path, lock))));
+ }
+ for (path, lock) in free {
let lock = Arc::new(lock);
let files: Vec = std::fs::read_dir(&path).into_iter().flatten().flatten().map(|f| f.path()).collect();
for f in &files {
diff --git a/apps/figcraft/src/recovery_tests.rs b/apps/figcraft/src/recovery_tests.rs
index 8f384b87..0322e237 100644
--- a/apps/figcraft/src/recovery_tests.rs
+++ b/apps/figcraft/src/recovery_tests.rs
@@ -203,6 +203,29 @@ fn a_run_whose_folder_name_is_still_held_takes_another() {
let _ = std::fs::remove_dir_all(&root);
}
+/// #334: a lock that frees itself is not a run that is still going. A child between its `fork` and
+/// its `exec` inherits the run's open descriptors and a `flock` lasts while any descriptor for the
+/// file is open, so a crashed run's copies must still come back once that child has exec'd.
+#[cfg(unix)]
+#[test]
+fn a_lock_freed_a_moment_later_is_not_a_run_that_is_still_going() {
+ let root = root("fork-window");
+ crashed(&edited(), &root);
+ // Hold the crashed run's folder lock on a second descriptor, the way a child forked before its
+ // exec holds it, and free it shortly after.
+ let lock = std::fs::File::options().write(true).create(true).truncate(false).open(root.join("crashed").join("lock")).unwrap();
+ lock.try_lock().unwrap();
+ let freed = std::thread::spawn(move || {
+ std::thread::sleep(std::time::Duration::from_millis(10));
+ drop(lock);
+ });
+ // The next start waits for that lock rather than reading the run as still going.
+ let mut next = Session::empty();
+ assert_eq!(recover(&root, &mut next), 1, "the copies come back once the lock frees itself");
+ freed.join().unwrap();
+ let _ = std::fs::remove_dir_all(&root);
+}
+
/// The rectangles in `doc`.
fn rectangles(doc: &figcraft_engine::doc::Document) -> usize {
doc.nodes().filter(|n| matches!(n.kind, figcraft_engine::doc::NodeKind::Rectangle)).count()
diff --git a/contributors/people.toml b/contributors/people.toml
index 8b14373e..6a92a2a9 100644
--- a/contributors/people.toml
+++ b/contributors/people.toml
@@ -24,6 +24,10 @@ display_name = "VanTan"
real_name = "Tyler Jennings"
display_name = "tylerjenningsw"
+[people.SiadeLucas]
+real_name = "Siade Lucas"
+sync_github_name = true
+
[people.Silvertree2010]
display_name = "Netter"
sync_github_name = false
@@ -37,6 +41,11 @@ real_name = "Justin John"
[people.Losminek]
+[people.alrifatsabbir]
+real_name = "Al Rifat Sabbir"
+display_name = "Al Rifat Sabbir"
+sync_github_name = true
+
[people.RevDonz]
[people.Nael-Nathanael]
@@ -56,3 +65,14 @@ sync_github_name = true
[people.pechnikov2026-star]
sync_github_name = true
+
+[people.MortenHusted]
+sync_github_name = true
+
+[people.AganzeFelicite]
+sync_github_name = true
+
+[people.switch87]
+real_name = "Gert Pellin"
+display_name = "Gert Pellin"
+sync_github_name = false
diff --git a/crates/collab-net/src/barred_tests.rs b/crates/collab-net/src/barred_tests.rs
index c9355a5f..7942e766 100644
--- a/crates/collab-net/src/barred_tests.rs
+++ b/crates/collab-net/src/barred_tests.rs
@@ -51,3 +51,47 @@ fn a_closed_file_forgets_whom_it_barred() {
assert!(!hub.barred.contains_key("f"), "and its barred addresses went with it");
assert!(hub.barred.contains_key("other"), "another file's stay");
}
+
+#[test]
+fn a_kicked_connection_with_a_full_queue_is_shut() {
+ use std::io::Read;
+ use std::net::TcpListener;
+ use std::sync::Arc;
+ use std::sync::atomic::AtomicUsize;
+ use std::sync::mpsc::sync_channel;
+ use std::time::Duration;
+
+ use super::{Conn, Kind, Line, Out};
+
+ let listener = TcpListener::bind("127.0.0.1:0").unwrap();
+ let mut client = std::net::TcpStream::connect(listener.local_addr().unwrap()).unwrap();
+ let (server_side, _) = listener.accept().unwrap();
+ client.set_read_timeout(Some(Duration::from_secs(2))).unwrap();
+ // Stands in for the writer thread's handle: it keeps the socket open after the Conn is gone.
+ let _writer = server_side.try_clone().unwrap();
+ let (tx, _rx) = sync_channel(2);
+ while tx.try_send(Out::Bytes(Default::default(), None)).is_ok() {}
+ let out = Line {
+ tx,
+ queued: Arc::default(),
+ block: Arc::new(AtomicUsize::new(0)),
+ all: Arc::new(AtomicUsize::new(0)),
+ max: 1 << 20,
+ max_block: usize::MAX,
+ max_all: usize::MAX,
+ };
+ let ip = IpAddr::V4(Ipv4Addr::LOCALHOST);
+ let mut hub = Hub {
+ in_flight: InFlight(Default::default()),
+ backend: Closes,
+ rooms: HashMap::new(),
+ conns: HashMap::from([(1, Conn { out, sock: server_side, kind: Kind::Managing, ip })]),
+ local: None,
+ outbox: Vec::new(),
+ barred: HashMap::new(),
+ };
+ hub.kick(&[1], "kicked");
+ assert!(hub.conns.is_empty());
+ let mut buf = [0u8; 1];
+ assert_eq!(client.read(&mut buf).ok(), Some(0), "the kicked socket must be shut (client sees EOF)");
+}
diff --git a/crates/collab-net/src/code_tests.rs b/crates/collab-net/src/code_tests.rs
index 4880242f..7fe766ec 100644
--- a/crates/collab-net/src/code_tests.rs
+++ b/crates/collab-net/src/code_tests.rs
@@ -141,7 +141,9 @@ fn old_server() -> (Endpoint, std::thread::JoinHandle<()>) {
let t = std::thread::spawn(move || {
for stream in listener.incoming().take(2).flatten() {
let Ok(mut ws) = tungstenite::accept(stream) else { continue };
- let _ = ws.read();
+ // read() returns Result, not a lock guard; this test server deliberately
+ // ignores whatever the client sent first.
+ let _ = ws.read(); // NOSONAR
let refused = ServerMsg::Refused { reason: "that message couldn't be read".into() };
let _ = ws.send(Message::Binary(Bytes::from(message::encode(&refused).unwrap())));
let _ = ws.close(None);
diff --git a/crates/collab-net/src/driver.rs b/crates/collab-net/src/driver.rs
index b8f6c154..4ebbec15 100644
--- a/crates/collab-net/src/driver.rs
+++ b/crates/collab-net/src/driver.rs
@@ -16,7 +16,7 @@ use figcraft_engine::live::{Event, Status};
use web_time::Instant;
use crate::inbox::Inbox;
-use crate::join::{GuestConfig, Next, Outcome, Resuming, Seen, Taken, after, closed, hello, resolved, take, unresolved};
+use crate::join::{GuestConfig, Next, Outcome, Resuming, Seen, Taken, after, closed, hello, resolved, take, too_large, unresolved};
use crate::throttle::{PRESENCE_INTERVAL, Throttle, earliest};
/// A WebSocket the driver opens, writes and closes; what it receives comes back through the
@@ -114,6 +114,9 @@ impl Driver {
/// A binary message from the host.
pub(crate) fn message(&mut self, bytes: &[u8], now: Instant) {
let Some(c) = self.conn.as_mut() else { return };
+ if bytes.len() > self.cfg.limits.max_server_message {
+ return self.end(too_large(&self.cfg.limits), now);
+ }
c.last_heard = now;
let taken = match message::decode::(bytes, self.cfg.limits.max_server_message) {
// The join code's answer: join the file it opens, on a new connection.
diff --git a/crates/collab-net/src/driver_tests.rs b/crates/collab-net/src/driver_tests.rs
index ca6563c5..5e395b98 100644
--- a/crates/collab-net/src/driver_tests.rs
+++ b/crates/collab-net/src/driver_tests.rs
@@ -10,7 +10,7 @@ use std::time::{Duration, Instant};
use figcraft_collab::message::{self, ClientMsg, Presence, ServerMsg};
use figcraft_collab::{Client, Limits, Outgoing, Server};
use figcraft_doc::{Document, NodeId};
-use figcraft_engine::live::{Event, Status};
+use figcraft_engine::live::{Event, Status, TOO_LARGE_TO_JOIN};
use tungstenite::protocol::WebSocket;
use tungstenite::{Bytes, Message};
@@ -262,6 +262,15 @@ fn refusals_and_the_end_of_the_session_are_final() {
assert!(d.done());
assert!(matches!(statuses(&inbox.drain()).last(), Some(Status::Failed { reason }) if reason.starts_with("The host refused")));
}
+ // A message over the size limit: the file is too large for this app, not refused by the host.
+ let inbox = Inbox::new(Arc::new(|| {}));
+ let mut cfg = GuestConfig::new(invite(), "Ada".into());
+ cfg.limits.max_server_message = 2 << 20;
+ let mut d = Driver::start(Script::default(), cfg, inbox.clone(), t0);
+ d.opened(t0);
+ d.message(&vec![0; (2 << 20) + 1], t0);
+ assert!(d.done());
+ assert!(matches!(statuses(&inbox.drain()).last(), Some(Status::Failed { reason }) if *reason == TOO_LARGE_TO_JOIN.replace("{mb}", "2")));
}
#[test]
diff --git a/crates/collab-net/src/guest.rs b/crates/collab-net/src/guest.rs
index eb899b8d..2e1d5046 100644
--- a/crates/collab-net/src/guest.rs
+++ b/crates/collab-net/src/guest.rs
@@ -26,7 +26,7 @@ use tungstenite::{Bytes, Message};
use crate::inbox::Inbox;
use crate::invite::{Endpoint, Invite};
pub use crate::join::GuestConfig;
-use crate::join::{Next, Outcome, Resuming, Seen, Taken, after, closed, hello, resolved, take, unresolved};
+use crate::join::{Next, Outcome, Resuming, Seen, Taken, after, closed, hello, resolved, take, too_large, unresolved};
use crate::manage;
use crate::net::{Duplex, NetLimits, config, open, shutdown};
use crate::throttle::{PRESENCE_INTERVAL, Throttle, earliest};
@@ -367,7 +367,7 @@ fn read_loop(mut ws: WebSocket, ctx: &ReaderCtx) {
Ok(Message::Close(f)) => break f.map_or_else(|| closed(0, ""), |f| closed(f.code.into(), &f.reason)),
Ok(Message::Text(_)) => break Outcome::Refused("the host sent a text message".into()),
Ok(_) => {}
- Err(tungstenite::Error::Capacity(_)) => break Outcome::Refused("the host sent a message over the size limit".into()),
+ Err(tungstenite::Error::Capacity(_)) => break too_large(&ctx.cfg.limits),
Err(e) => break Outcome::Retry(e.to_string()),
}
};
diff --git a/crates/collab-net/src/hub.rs b/crates/collab-net/src/hub.rs
index 5cf3e519..2f87334d 100644
--- a/crates/collab-net/src/hub.rs
+++ b/crates/collab-net/src/hub.rs
@@ -402,6 +402,8 @@ enum HubIn {
sock: TcpStream,
/// Its size (in flight until handled).
bytes: usize,
+ /// Told when the hub takes the connection in (dropped unsent when it doesn't).
+ admitted: SyncSender<()>,
},
Msg {
conn: u64,
@@ -811,17 +813,22 @@ fn encode(msg: &ServerMsg) -> Option {
/// Queue `Refused {reason}` and a close for one connection (small: not counted against its caps).
fn refuse(out: &Line, why: &str) {
+ refused(out, why);
+}
+
+/// [`refuse`], and whether the close was queued (it isn't when the queue is full).
+fn refused(out: &Line, why: &str) -> bool {
if let Some(b) = encode(&ServerMsg::Refused { reason: why.to_string() }) {
let _ = out.tx.try_send(Out::Bytes(b, None));
}
- let _ = out.tx.try_send(Out::Close(CloseCode::Policy, reason(why)));
+ out.tx.try_send(Out::Close(CloseCode::Policy, reason(why))).is_ok()
}
/// What the server tells a client when it is too busy to take more from it.
const BUSY: &str = "the server is busy: try again in a moment";
-/// Read the next binary message (skipping pings) and its size, or why the connection should end.
-fn next_message(ws: &mut WebSocket, max: usize) -> Result, String> {
+/// Read the next binary message (skipping pings, until `deadline`) and its size, or why the connection should end.
+fn next_message(ws: &mut WebSocket, max: usize, deadline: Option) -> Result, String> {
loop {
return match ws.read() {
Ok(Message::Binary(b)) => {
@@ -830,6 +837,10 @@ fn next_message(ws: &mut WebSocket, max: usize) -> Result(&b, max).map(|m| Some((m, b.len()))).map_err(|_| "that message couldn't be read".to_string())
}
Ok(Message::Text(_)) => Err("only binary messages are spoken here".into()),
+ // Pings keep the per-read timeout alive, but not the overall deadline (slowloris).
+ Ok(Message::Ping(_) | Message::Pong(_) | Message::Frame(_)) if deadline.is_some_and(|d| Instant::now() >= d) => {
+ Err("no hello in time".into())
+ }
Ok(Message::Ping(_) | Message::Pong(_) | Message::Frame(_)) => continue,
Ok(Message::Close(_)) => Ok(None),
Err(tungstenite::Error::Capacity(_)) => Err(too_large(max)),
@@ -851,6 +862,7 @@ fn too_large(max: usize) -> String {
/// One connection's reader (the writer runs on its own thread).
fn serve(mut stream: TcpStream, conn: u64, hub: &Sender, limits: NetLimits, open: Open, shared: &Shared) {
let _ = stream.set_nodelay(true);
+ let hello_deadline = Instant::now() + limits.hello_timeout;
if stream.set_read_timeout(Some(limits.hello_timeout)).is_err() || stream.set_write_timeout(Some(limits.write_timeout)).is_err() {
return;
}
@@ -923,7 +935,7 @@ fn serve(mut stream: TcpStream, conn: u64, hub: &Sender, limits: NetLimit
log::info!("event=refused ip={ip} reason=connections_per_address");
end(Some("too many connections from your address: close some and try again"));
} else {
- match next_message(&mut ws, limits.max_hello) {
+ match next_message(&mut ws, limits.max_hello, Some(hello_deadline)) {
Ok(Some((
first @ (ClientMsg::Hello(_)
| ClientMsg::Manage(_)
@@ -946,9 +958,13 @@ fn serve(mut stream: TcpStream, conn: u64, hub: &Sender, limits: NetLimit
if reserved || !shared.in_flight.take(bytes, limits.max_in_flight) {
end(Some(BUSY));
} else {
- ws.set_config(|c| *c = config(max));
- let opened = sock.try_clone().is_ok_and(|s| hub.send(HubIn::Open { conn, ip, first, out: out.clone(), sock: s, bytes }).is_ok());
- if opened && ws.get_ref().set_read_timeout(Some(idle)).is_ok() {
+ let (admitted, verdict) = sync_channel(1);
+ let opened =
+ sock.try_clone().is_ok_and(|s| hub.send(HubIn::Open { conn, ip, first, out: out.clone(), sock: s, bytes, admitted }).is_ok());
+ // Nothing more is read until the hub took the connection in (its token checked):
+ // only then may it send messages of the full size.
+ if opened && verdict.recv().is_ok() && ws.get_ref().set_read_timeout(Some(idle)).is_ok() {
+ ws.set_config(|c| *c = config(max));
read_loop(&mut ws, conn, hub, limits, max, &shared.in_flight, &end);
let _ = hub.send(HubIn::Gone { conn });
}
@@ -981,7 +997,7 @@ fn read_loop(
let mut bucket = Bucket::new(limits.rate, limits.burst);
let mut signals = Bucket::new(SIGNAL_RATE, SIGNAL_BURST);
loop {
- match next_message(ws, max) {
+ match next_message(ws, max, None) {
Ok(Some((msg, bytes))) => {
let now = Instant::now();
if !bucket.take(now) {
@@ -1074,6 +1090,8 @@ struct Pending {
out: Line,
sock: TcpStream,
ip: IpAddr,
+ /// Told when it is taken in.
+ admitted: SyncSender<()>,
}
/// A connection the hub took in.
@@ -1195,7 +1213,7 @@ impl Hub {
fn handle(&mut self, m: HubIn) {
match m {
- HubIn::Open { conn, ip, first, out, sock, bytes } => {
+ HubIn::Open { conn, ip, first, out, sock, bytes, admitted } => {
self.in_flight.give(bytes);
// The operator (with the server key) gets in from anywhere; everyone else is
// checked (blocked addresses, connection rates).
@@ -1204,7 +1222,7 @@ impl Hub {
log::info!("event=refused ip={ip} reason={why:?}");
return refuse(&out, &why);
}
- let c = Pending { out, sock, ip };
+ let c = Pending { out, sock, ip, admitted };
match first {
ClientMsg::Hello(hello) => self.join(conn, hello, c),
ClientMsg::Manage(m) => self.manage(conn, &m, c),
@@ -1399,6 +1417,7 @@ impl Hub {
if let Some(c) = old.and_then(|old| self.conns.remove(&old)) {
shutdown(&c.sock);
}
+ let _ = c.admitted.try_send(());
self.conns
.insert(conn, Conn { out: c.out, sock: c.sock, kind: Kind::Joined { file: file.clone(), id, link: admission.link }, ip: c.ip });
self.queue(&file, more);
@@ -1429,7 +1448,9 @@ impl Hub {
barred.insert(c.ip);
}
log::info!("event=removed file={file} client={id} ip={}", c.ip);
- let _ = c.out.tx.try_send(Out::Close(CloseCode::Away, REMOVED.into()));
+ if c.out.tx.try_send(Out::Close(CloseCode::Away, REMOVED.into())).is_err() {
+ shutdown(&c.sock);
+ }
self.gone(conn);
Ok(())
}
@@ -1444,6 +1465,7 @@ impl Hub {
/// Take in connection `c` as `kind` and send it `first`.
fn take_in(&mut self, conn: u64, c: Pending, kind: Kind, first: &ServerMsg) {
+ let _ = c.admitted.try_send(());
self.conns.insert(conn, Conn { out: c.out, sock: c.sock, kind, ip: c.ip });
self.answer(conn, first);
}
@@ -1543,8 +1565,10 @@ impl Hub {
// People in the file are told the session is over for them, as when a host stops (they
// keep their copy; nothing retries); a library request is refused.
for conn in &people {
- if let Some(c) = self.conns.get(conn) {
- let _ = c.out.tx.try_send(Out::Close(CloseCode::Away, STOPPED.into()));
+ if let Some(c) = self.conns.get(conn)
+ && c.out.tx.try_send(Out::Close(CloseCode::Away, STOPPED.into())).is_err()
+ {
+ shutdown(&c.sock);
}
self.gone(*conn);
}
@@ -1593,8 +1617,10 @@ impl Hub {
/// Refuse connections with `why` and drop them at once (nothing more they send counts).
fn kick(&mut self, conns: &[u64], why: &str) {
for conn in conns {
- if let Some(c) = self.conns.get(conn) {
- refuse(&c.out, why);
+ if let Some(c) = self.conns.get(conn)
+ && !refused(&c.out, why)
+ {
+ shutdown(&c.sock);
}
self.gone(*conn);
}
@@ -1747,3 +1773,7 @@ mod queue_tests;
#[cfg(test)]
#[path = "barred_tests.rs"]
mod barred_tests;
+
+#[cfg(test)]
+#[path = "preauth_tests.rs"]
+mod preauth_tests;
diff --git a/crates/collab-net/src/inbox.rs b/crates/collab-net/src/inbox.rs
index fb505a0a..1ec00e67 100644
--- a/crates/collab-net/src/inbox.rs
+++ b/crates/collab-net/src/inbox.rs
@@ -11,11 +11,18 @@ use figcraft_engine::live::{Event, Presence};
pub type Waker = Arc;
/// Most discrete events kept between two drains (joins, leaves, status); the oldest go first.
+/// Document sync events don't count and are never dropped: the sync client treats a missing
+/// batch as a fatal sequence gap, so losing one would end the session.
const MAX_EVENTS: usize = 10_000;
#[derive(Default)]
struct State {
- events: VecDeque,
+ /// Arrival number of the next event, so [`Inbox::drain`] can merge the two queues in order.
+ next: u64,
+ /// [`Event::Sync`] events, never dropped.
+ syncs: VecDeque<(u64, Event)>,
+ /// Every other event, capped at [`MAX_EVENTS`].
+ others: VecDeque<(u64, Event)>,
presence: BTreeMap,
}
@@ -43,11 +50,17 @@ impl Inbox {
if let Event::PeerLeft(id) = &e {
s.presence.remove(id);
}
- if s.events.len() >= MAX_EVENTS {
- log::warn!("live session: {MAX_EVENTS} events not taken; dropping the oldest");
- s.events.pop_front();
+ let n = s.next;
+ s.next += 1;
+ if matches!(e, Event::Sync(_)) {
+ s.syncs.push_back((n, e));
+ return;
}
- s.events.push_back(e);
+ if s.others.len() >= MAX_EVENTS {
+ log::warn!("live session: {MAX_EVENTS} events not taken; dropping the oldest");
+ s.others.pop_front();
+ }
+ s.others.push_back((n, e));
});
}
@@ -62,8 +75,70 @@ impl Inbox {
/// peer.
pub fn drain(&self) -> Vec {
let mut s = self.state.lock().unwrap_or_else(PoisonError::into_inner);
- let mut out: Vec = s.events.drain(..).collect();
+ let mut syncs = std::mem::take(&mut s.syncs).into_iter().peekable();
+ let mut others = std::mem::take(&mut s.others).into_iter().peekable();
+ let mut out = Vec::with_capacity(syncs.len() + others.len() + s.presence.len());
+ loop {
+ let sync_first = match (syncs.peek(), others.peek()) {
+ (Some((a, _)), Some((b, _))) => a < b,
+ (Some(_), None) => true,
+ (None, Some(_)) => false,
+ (None, None) => break,
+ };
+ let next = if sync_first { syncs.next() } else { others.next() };
+ out.extend(next.map(|(_, e)| e));
+ }
out.extend(std::mem::take(&mut s.presence).into_iter().map(|(id, p)| Event::Presence(id, p)));
out
}
}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use figcraft_collab::message::ServerMsg;
+
+ fn reject(batch_id: u64) -> Event {
+ Event::Sync(ServerMsg::Reject { batch_id, reason: String::new(), fixes: Vec::new() })
+ }
+
+ fn sync_ids(events: &[Event]) -> Vec {
+ events
+ .iter()
+ .filter_map(|e| match e {
+ Event::Sync(ServerMsg::Reject { batch_id, .. }) => Some(*batch_id),
+ _ => None,
+ })
+ .collect()
+ }
+
+ #[test]
+ fn a_full_inbox_never_drops_sync_events() {
+ let inbox = Inbox::new(Arc::new(|| {}));
+ inbox.push(reject(1));
+ for _ in 0..MAX_EVENTS {
+ inbox.push(Event::PeerLeft(7));
+ }
+ inbox.push(reject(2));
+ for _ in 0..MAX_EVENTS {
+ inbox.push(Event::PeerLeft(7));
+ }
+ let out = inbox.drain();
+ assert_eq!(sync_ids(&out), vec![1, 2]);
+ assert!(out.len() <= MAX_EVENTS + 2, "{} events kept", out.len());
+ }
+
+ #[test]
+ fn sync_events_past_the_cap_are_all_kept_in_order() {
+ let inbox = Inbox::new(Arc::new(|| {}));
+ let n = MAX_EVENTS as u64 + 5;
+ for id in 0..n {
+ inbox.push(reject(id));
+ }
+ inbox.push(Event::PeerLeft(7));
+ let out = inbox.drain();
+ let ids = sync_ids(&out);
+ assert_eq!(ids.len() as u64, n, "Sync events dropped");
+ assert!(ids.iter().copied().eq(0..n), "Sync events out of order");
+ }
+}
diff --git a/crates/collab-net/src/invite.rs b/crates/collab-net/src/invite.rs
index 617ad518..e5d86bf2 100644
--- a/crates/collab-net/src/invite.rs
+++ b/crates/collab-net/src/invite.rs
@@ -220,7 +220,8 @@ fn valid_host(s: &str) -> bool {
return true;
}
let Some((name, port)) = s.rsplit_once(':') else { return false };
- port.parse::().is_ok_and(|p| p != 0)
+ port.bytes().all(|b| b.is_ascii_digit())
+ && port.parse::().is_ok_and(|p| p != 0)
&& (1..=253).contains(&name.len())
&& name.bytes().all(|b| b.is_ascii_alphanumeric() || b == b'-' || b == b'.')
&& !name.starts_with(['-', '.'])
@@ -239,6 +240,9 @@ fn percent_decode(s: &str) -> Option {
while let Some(&b) = bytes.get(i) {
if b == b'%' {
let hex = bytes.get(i + 1..i + 3)?;
+ if !hex.iter().all(u8::is_ascii_hexdigit) {
+ return None;
+ }
out.push(u8::from_str_radix(std::str::from_utf8(hex).ok()?, 16).ok()?);
i += 3;
} else {
diff --git a/crates/collab-net/src/invite_tests.rs b/crates/collab-net/src/invite_tests.rs
index 02017517..b7618dc2 100644
--- a/crates/collab-net/src/invite_tests.rs
+++ b/crates/collab-net/src/invite_tests.rs
@@ -123,3 +123,19 @@ proptest! {
prop_assert_eq!(Invite::parse(&i.url()), Ok(i));
}
}
+
+#[test]
+fn plus_or_sign_inside_a_percent_escape_is_broken() {
+ assert!(Endpoint::parse("ws://example.org/a/?key=%41").is_ok());
+ for bad in ["%+1", "%-1", "%1", "%+a"] {
+ assert!(Endpoint::parse(&format!("ws://example.org/a/?key={bad}")).is_err(), "{bad}");
+ }
+}
+
+#[test]
+fn port_must_be_all_digits() {
+ assert!(Endpoint::parse("ws://localhost:80/").is_ok());
+ for bad in ["ws://localhost:+80/", "ws://localhost:-80/", "ws://localhost:/"] {
+ assert!(Endpoint::parse(bad).is_err(), "accepted {bad}");
+ }
+}
diff --git a/crates/collab-net/src/join.rs b/crates/collab-net/src/join.rs
index 81cd2437..cc3be839 100644
--- a/crates/collab-net/src/join.rs
+++ b/crates/collab-net/src/join.rs
@@ -7,7 +7,7 @@ use std::time::Duration;
use figcraft_collab::Client;
use figcraft_collab::message::{ClientMsg, Peer, Resume, ServerMsg};
-use figcraft_engine::live::{Event, Role, SessionInfo, Status};
+use figcraft_engine::live::{Event, Role, SessionInfo, Status, TOO_LARGE_TO_JOIN};
use crate::inbox::Inbox;
use crate::invite::Invite;
@@ -95,6 +95,12 @@ pub(crate) fn unresolved(cfg: &GuestConfig, outcome: Outcome) -> Outcome {
})
}
+/// The host sent a message over this app's size limit (the file's welcome, usually): final, and
+/// not the host's doing.
+pub(crate) fn too_large(limits: &NetLimits) -> Outcome {
+ Outcome::Failed(TOO_LARGE_TO_JOIN.replace("{mb}", &(limits.max_server_message >> 20).to_string()))
+}
+
/// The server's answer to the join code: the invite is whole now.
pub(crate) fn resolved(cfg: &mut GuestConfig, file: String, token: String) -> Result<(), Outcome> {
if !crate::invite::valid_id(&file, 1, 64) || !crate::invite::valid_id(&token, 16, 128) {
diff --git a/crates/collab-net/src/loopback_tests.rs b/crates/collab-net/src/loopback_tests.rs
index 32c86bd0..464d8714 100644
--- a/crates/collab-net/src/loopback_tests.rs
+++ b/crates/collab-net/src/loopback_tests.rs
@@ -10,7 +10,7 @@ use std::time::{Duration, Instant};
use figcraft_collab::message::{self, ClientMsg, Hello, Presence, ServerMsg, Signal};
use figcraft_collab::{Client, Limits};
use figcraft_doc::{Document, NodeId};
-use figcraft_engine::live::{Event, PEOPLE, Status};
+use figcraft_engine::live::{Event, PEOPLE, Status, TOO_LARGE_TO_JOIN};
use tungstenite::protocol::WebSocket;
use tungstenite::{Bytes, Message};
@@ -642,3 +642,62 @@ fn the_host_removes_someone_and_they_cant_come_back() {
host.stop();
assert_eq!(host.connections(), 0);
}
+
+#[test]
+fn a_welcome_over_the_size_limit_says_the_file_is_too_large() {
+ let mut doc = Document::new("B".repeat(1 << 20));
+ doc.repair();
+ let probe = Probe::new();
+ let cfg = HostConfig {
+ addr: SocketAddr::from(([127, 0, 0, 1], 0)),
+ any_port_if_taken: false,
+ file: FILE.into(),
+ token: TOKEN.into(),
+ doc,
+ name: "Hana".into(),
+ limits: fast_limits(),
+ core: Limits::default(),
+ };
+ let mut host = Host::start(cfg, probe.inbox.clone()).unwrap();
+ let invite = Invite::new(host.addr().to_string(), FILE, TOKEN);
+
+ let mut guest_cfg = quick(GuestConfig::new(invite, "Ada".into()));
+ guest_cfg.limits = NetLimits { max_server_message: 1 << 20, ..fast_limits() };
+ let mut gp = Probe::new();
+ let _g = Guest::start(guest_cfg, gp.inbox.clone()).unwrap();
+ let too_large = TOO_LARGE_TO_JOIN.replace("{mb}", "1");
+ gp.wait("the file too large to join", |e| e.iter().any(|ev| matches!(ev, Event::Status(Status::Failed { reason }) if *reason == too_large)));
+ assert!(!welcomed(&gp.events));
+ host.stop();
+}
+
+#[test]
+fn pings_do_not_keep_a_connection_without_a_hello_alive() {
+ let (mut host, _hp, invite) = start_with(NetLimits { hello_timeout: Duration::from_secs(1), ..fast_limits() }, Limits::default());
+ let addr: SocketAddr = invite.server.host.parse().unwrap();
+ let mut r = Raw::connect(addr);
+ let t0 = Instant::now();
+ let mut closed = None;
+ while t0.elapsed() < Duration::from_secs(6) {
+ if r.0.send(Message::Ping(Bytes::new())).is_err() || r.0.flush().is_err() {
+ closed = Some(t0.elapsed());
+ break;
+ }
+ std::thread::sleep(Duration::from_millis(300));
+ // Drain what the host sent back (pongs, the close); an error means it hung up.
+ r.0.get_mut().set_read_timeout(Some(Duration::from_millis(10))).unwrap();
+ match r.0.read() {
+ Ok(Message::Close(_)) | Err(tungstenite::Error::ConnectionClosed | tungstenite::Error::AlreadyClosed) => {
+ closed = Some(t0.elapsed());
+ break;
+ }
+ Err(tungstenite::Error::Io(e)) if !matches!(e.kind(), std::io::ErrorKind::WouldBlock | std::io::ErrorKind::TimedOut) => {
+ closed = Some(t0.elapsed());
+ break;
+ }
+ _ => {}
+ }
+ }
+ assert!(closed.is_some_and(|t| t < Duration::from_secs(3)), "pinged pre-hello connection survived: {closed:?}");
+ host.stop();
+}
diff --git a/crates/collab-net/src/manage.rs b/crates/collab-net/src/manage.rs
index 6e995bdb..dc3ec315 100644
--- a/crates/collab-net/src/manage.rs
+++ b/crates/collab-net/src/manage.rs
@@ -206,10 +206,15 @@ fn connect(server: &Endpoint, limits: &NetLimits, timeout: Duration) -> Result Result<(), String> {
@@ -240,3 +245,31 @@ fn reply(ws: &mut Ws, limits: &NetLimits, pick: impl Fn(ServerMsg) -> Option<
};
}
}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ /// A server that keeps pinging and never answers the close must not pin `close` forever.
+ #[test]
+ fn close_returns_against_a_server_that_keeps_pinging() {
+ let listener = std::net::TcpListener::bind("127.0.0.1:0").unwrap();
+ let addr = listener.local_addr().unwrap();
+ std::thread::spawn(move || {
+ let (s, _) = listener.accept().unwrap();
+ let Ok(mut ws) = tungstenite::accept(s) else { return };
+ while ws.send(Message::Ping(Bytes::new())).is_ok() {
+ std::thread::sleep(Duration::from_millis(10));
+ }
+ });
+ let limits = NetLimits { idle_timeout: Duration::from_millis(300), ..NetLimits::default() };
+ let server = Endpoint { host: addr.to_string(), path: "/".into(), secure: false };
+ let ws = connect(&server, &limits, Duration::from_secs(2)).unwrap();
+ let (tx, rx) = std::sync::mpsc::channel();
+ std::thread::spawn(move || {
+ close(ws);
+ let _ = tx.send(());
+ });
+ assert!(rx.recv_timeout(Duration::from_secs(3)).is_ok(), "close() kept draining a pinging server");
+ }
+}
diff --git a/crates/collab-net/src/preauth_tests.rs b/crates/collab-net/src/preauth_tests.rs
new file mode 100644
index 00000000..5ae91665
--- /dev/null
+++ b/crates/collab-net/src/preauth_tests.rs
@@ -0,0 +1,72 @@
+//! A connection whose hello the backend hasn't admitted yet is held to the hello's size limit: it
+//! can't have a message of the full size read while its token is unchecked.
+
+use std::net::{SocketAddr, TcpListener, TcpStream};
+use std::sync::mpsc::{Receiver, channel};
+use std::time::{Duration, Instant};
+
+use figcraft_collab::message::{self, ClientMsg, ServerMsg, Signal};
+use figcraft_collab::{Client, Server};
+use tungstenite::{Bytes, Message};
+
+use super::{Admission, Backend, Closing, Hosting};
+use crate::net::NetLimits;
+
+/// A backend that refuses every hello, once it is told to.
+struct Slow(Receiver<()>);
+
+impl Backend for Slow {
+ fn admit(&mut self, _file: &str, _token: &str) -> Result {
+ let _ = self.0.recv();
+ Err("wrong token".into())
+ }
+
+ fn open(&mut self, _file: &str) -> Result {
+ Err("no".into())
+ }
+
+ fn closing(&self) -> Closing {
+ Closing::Ended
+ }
+}
+
+fn connect(addr: SocketAddr) -> tungstenite::WebSocket {
+ let s = TcpStream::connect(addr).unwrap();
+ s.set_read_timeout(Some(Duration::from_secs(10))).unwrap();
+ tungstenite::client::client(format!("ws://{addr}/"), s).unwrap().0
+}
+
+#[test]
+fn an_unadmitted_connection_cant_send_a_large_message() {
+ let limits = NetLimits { hello_timeout: Duration::from_secs(5), ..NetLimits::default() };
+ let (release, wait) = channel();
+ let mut hosting = Hosting::serve(TcpListener::bind("127.0.0.1:0").unwrap(), Slow(wait), limits).unwrap();
+ let addr = hosting.addr();
+ let sender = std::thread::spawn(move || {
+ let mut ws = connect(addr);
+ let hello = message::encode(&Client::hello("0123456789abcdef", "bad", "x", "")).unwrap();
+ ws.send(Message::Binary(Bytes::from(hello))).unwrap();
+ let big = ClientMsg::Signal(Signal { kind: Signal::CHAT.into(), text: "x".repeat(1 << 20) });
+ let _ = ws.send(Message::Binary(Bytes::from(message::encode(&big).unwrap())));
+ let mut refused = None;
+ while let Ok(m) = ws.read() {
+ if let Message::Binary(b) = m
+ && let Ok(ServerMsg::Refused { reason }) = message::decode(&b, 64 << 20)
+ {
+ refused = Some(reason);
+ }
+ }
+ refused
+ });
+ let mut peak = 0;
+ let until = Instant::now() + Duration::from_secs(2);
+ while Instant::now() < until {
+ peak = peak.max(hosting.in_flight_bytes());
+ std::thread::sleep(Duration::from_millis(2));
+ }
+ release.send(()).unwrap();
+ let refused = sender.join().unwrap();
+ hosting.stop();
+ assert!(peak <= limits.max_hello, "a message of {peak} bytes was read before the token was checked");
+ assert_eq!(refused.as_deref(), Some("wrong token"));
+}
diff --git a/crates/collab/Cargo.toml b/crates/collab/Cargo.toml
index 89a79687..ed85201d 100644
--- a/crates/collab/Cargo.toml
+++ b/crates/collab/Cargo.toml
@@ -13,6 +13,7 @@ figcraft-doc = { workspace = true }
serde = { workspace = true }
serde_json = { workspace = true }
thiserror = { workspace = true }
+chrono = { workspace = true }
imbl = { workspace = true }
base64 = { workspace = true }
postcard = { workspace = true }
diff --git a/crates/collab/src/board_sync_tests.rs b/crates/collab/src/board_sync_tests.rs
new file mode 100644
index 00000000..3dbff8bb
--- /dev/null
+++ b/crates/collab/src/board_sync_tests.rs
@@ -0,0 +1,45 @@
+//! Boards sync: the file kind reaches joiners in their snapshot, and a layer's board metadata (a
+//! connector's ends, a sticky's author) syncs as one property, through both encodings.
+
+use figcraft_doc::{BoardItem, Connector, Document, End, FileKind, NodeKind, Routing, Side};
+
+use crate::change::{Change, DocProp, Prop};
+use crate::replica::{Mode, Replica};
+use crate::{diff, message};
+
+#[test]
+fn a_boards_kind_and_its_objects_metadata_sync() {
+ let mut doc = Document::new("Board");
+ doc.kind = FileKind::Board;
+ let page = doc.first_page().unwrap();
+ let a = doc.create(page, NodeKind::Frame, "Sticky", 0.0, 0.0, 200.0, 200.0).unwrap();
+ doc.node_mut(a).unwrap().board = Some(BoardItem::Sticky { author: "Ada".into() });
+ let host = Replica::new(doc);
+ // A joiner's copy, built from the snapshot, is a board with the sticky's metadata.
+ let snap = host.snapshot().unwrap();
+ assert!(snap.iter().any(|c| matches!(c, Change::SetDoc { prop: DocProp::Kind, .. })));
+ let joiner = Replica::from_snapshot(&snap).unwrap();
+ assert_eq!(joiner.document().kind, FileKind::Board);
+ assert_eq!(joiner.document().node(a).unwrap().board, host.document().node(a).unwrap().board);
+ // Re-attaching a connector's end is one property write, the same after the wire.
+ let mut edited = host.document().clone();
+ let c = edited.create(page, NodeKind::Vector { network: Default::default() }, "Connector", 0.0, 0.0, 1.0, 1.0).unwrap();
+ edited.node_mut(c).unwrap().board = Some(BoardItem::Connector(Connector {
+ from: End::Node { node: a, side: Side::Auto },
+ to: End::Point { x: 5.0, y: 5.0 },
+ routing: Routing::Elbow,
+ }));
+ let mut r = host.clone();
+ r.apply(&diff(&host, &edited).unwrap().changes, Mode::Strict).unwrap();
+ let mut moved = r.document().clone();
+ moved.node_mut(c).unwrap().board = Some(BoardItem::Connector(Connector {
+ from: End::Node { node: a, side: Side::Top },
+ to: End::Point { x: 9.0, y: 1.0 },
+ routing: Routing::Straight,
+ }));
+ let d = diff(&r, &moved).unwrap();
+ assert!(matches!(d.changes.as_slice(), [Change::Set { prop: Prop::Board, .. }]), "{:?}", d.changes);
+ let wire: Vec = message::decode(&message::encode(&d.changes).unwrap(), usize::MAX).unwrap();
+ r.apply(&wire, Mode::Strict).unwrap();
+ assert_eq!(r.document(), &moved);
+}
diff --git a/crates/collab/src/change.rs b/crates/collab/src/change.rs
index 32a49184..57bb9cf2 100644
--- a/crates/collab/src/change.rs
+++ b/crates/collab/src/change.rs
@@ -87,8 +87,9 @@ macro_rules! node_props {
($($variant:ident => $field:ident),* $(,)?) => {
/// A node property: the tree position (`parent`, `position`) or one saved field of
/// [`Node`]. List-valued fields (fills, text runs, vector networks…) are one property each,
- /// replaced whole (three-way merges line fills, strokes and effects up item by item, see
- /// [`merge`](crate::merge)). New properties go at the end (the binary form numbers them).
+ /// replaced whole (three-way merges line the lists whose items stand on their own, such as
+ /// fills, up item by item, see [`merge`](crate::merge)). New properties go at the end (the
+ /// binary form numbers them).
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub enum Prop {
@@ -180,6 +181,7 @@ node_props! {
Annotations => annotations,
CodeLinks => code_links,
DevResources => dev_resources,
+ Board => board,
}
/// A document-level property. Lists of entries with ids (styles, comments, variable collections,
@@ -218,6 +220,8 @@ pub enum DocProp {
Variables,
/// Variable ids in order.
VariableOrder,
+ /// A design file or a board.
+ Kind,
}
/// A document-level entry, by id.
diff --git a/crates/collab/src/code.rs b/crates/collab/src/code.rs
index c046682a..6eebe9f7 100644
--- a/crates/collab/src/code.rs
+++ b/crates/collab/src/code.rs
@@ -135,7 +135,7 @@ impl Local {
let query = link.strip_prefix("figcraft://join?")?;
let get = |key: &str| query.split('&').find_map(|kv| kv.split_once('=').filter(|(k, _)| *k == key).map(|(_, v)| v));
let addr: std::net::SocketAddrV4 = get("host")?.parse().ok()?;
- let hex = get("token")?.strip_prefix(TOKEN_PREFIX).filter(|h| h.len() == 11)?;
+ let hex = get("token")?.strip_prefix(TOKEN_PREFIX).filter(|h| h.len() == 11 && h.bytes().all(|b| b.is_ascii_hexdigit()))?;
let local = Local { ip: *addr.ip(), port: addr.port(), secret: u64::from_str_radix(hex, 16).ok()? };
(get("file") == Some(LOCAL_FILE) && local.port != 0).then_some(local)
}
diff --git a/crates/collab/src/code_tests.rs b/crates/collab/src/code_tests.rs
index 2dd902b3..31bd3488 100644
--- a/crates/collab/src/code_tests.rs
+++ b/crates/collab/src/code_tests.rs
@@ -104,6 +104,7 @@ fn only_local_session_links_have_a_code() {
"figcraft://join?host=[::1]:47900&file=local&token=local-0123456789a",
"figcraft://join?host=192.168.1.20:0&file=local&token=local-0123456789a",
"figcraft://join?host=192.168.1.20:47900&file=local&token=local-0123456789az",
+ "figcraft://join?host=10.0.0.1:47900&file=local&token=local-+0000000001",
"figcraft://join?server=wss://example.org/&file=local&token=local-0123456789a",
"ws://192.168.1.20:47900/?file=local&token=local-0123456789a",
"",
diff --git a/crates/collab/src/docprops.rs b/crates/collab/src/docprops.rs
index 535c333e..9b35e05d 100644
--- a/crates/collab/src/docprops.rs
+++ b/crates/collab/src/docprops.rs
@@ -213,6 +213,7 @@ doc_scalars! {
ImagePresets => image_presets,
AnnotationCategories => annotation_categories,
Libraries => libraries,
+ Kind => kind,
}
/// Keyed maps (no order): changed and added entries are put, missing ones removed.
diff --git a/crates/collab/src/lib.rs b/crates/collab/src/lib.rs
index 2c693bc4..fa271f35 100644
--- a/crates/collab/src/lib.rs
+++ b/crates/collab/src/lib.rs
@@ -123,6 +123,8 @@ impl Recompute for NoRecompute {
fn recompute(&self, _: &mut Document, _: &Document, _: &BTreeSet) {}
}
+#[cfg(test)]
+mod board_sync_tests;
#[cfg(test)]
mod client_tests;
#[cfg(test)]
diff --git a/crates/collab/src/merge.rs b/crates/collab/src/merge.rs
index bb18e661..5132ce75 100644
--- a/crates/collab/src/merge.rs
+++ b/crates/collab/src/merge.rs
@@ -4,12 +4,13 @@
//!
//! A conflict is the same property (or document-level entry) changed on both sides to different
//! values, or a layer deleted on one side while the other side edited it or something inside it
-//! (including adding layers to it or moving layers into or out of it). Fills, strokes and effects
-//! merge item by item: both sides changing different items of the list (or one adding items at its
-//! end) is no conflict, only the same item changed both ways or the list shortened on a side
-//! while the other changed it. Nothing that conflicts is
-//! merged until it is resolved: each conflict is resolved for one side, and the other side's
-//! changes to it are left out. Everything else from both sides is kept.
+//! (including adding layers to it or moving layers into or out of it). The layer lists whose items
+//! stand on their own (fills, strokes, effects, layout grids, export settings, guides, prototype
+//! interactions, accessibility annotations and Dev Mode resources) merge item by item: both sides
+//! changing different items of the list (or one adding items at its end) is no conflict, only the
+//! same item changed both ways or the list shortened on a side while the other changed it. Nothing
+//! that conflicts is merged until it is resolved: each conflict is resolved for one side, and the
+//! other side's changes to it are left out. Everything else from both sides is kept.
use std::collections::{BTreeMap, BTreeSet};
use std::fmt;
@@ -159,8 +160,23 @@ fn by_key(changes: &[Change]) -> BTreeMap> {
out
}
-/// List properties whose items merge one by one.
-const PER_ITEM: &[Prop] = &[Prop::Fills, Prop::Strokes, Prop::Effects];
+/// List properties whose items merge one by one: the items stand on their own, so both sides
+/// changing different ones (or one side adding at its end) is no conflict. Sets and keyed maps
+/// (`bound`, `varModes`, `overrides`, `propRefs`, `pluginData`) are not here: their items line up
+/// by key, not by position.
+const PER_ITEM: &[Prop] = &[
+ Prop::Fills,
+ Prop::Strokes,
+ Prop::Effects,
+ Prop::Grids,
+ Prop::Exports,
+ Prop::Guides,
+ Prop::Interactions,
+ Prop::Annotations,
+ // Not `CodeLinks`: there is one per language, and lining them up by position could leave two
+ // for one language (the second hidden), so they merge whole.
+ Prop::DevResources,
+];
/// Both sides' writes `b` and `m` of list property `key` merged item by item against the base
/// (see [`merge_items`]); `None` when `key` isn't such a list or the writes conflict.
diff --git a/crates/collab/src/merge_list_tests.rs b/crates/collab/src/merge_list_tests.rs
index 436e6b6f..e92f6bbb 100644
--- a/crates/collab/src/merge_list_tests.rs
+++ b/crates/collab/src/merge_list_tests.rs
@@ -1,8 +1,10 @@
-//! Fills, strokes and effects merge item by item: different items changed on each side merge,
-//! the same item changed both ways conflicts.
+//! The layer lists whose items stand on their own (fills, strokes, effects, layout grids, export
+//! settings, guides, prototype interactions, accessibility annotations and Dev Mode resources)
+//! merge item by item: different items changed on each side merge, the same item changed both ways
+//! conflicts.
use figcraft_color::{Color, Paint};
-use figcraft_doc::{Document, Effect, NodeId, NodeKind};
+use figcraft_doc::{Document, Effect, LayoutGrid, NodeId, NodeKind, proto};
use serde_json::{Value, json};
use crate::merge::{Key, Side, merge_items, plan};
@@ -100,19 +102,113 @@ fn the_same_item_changed_both_ways_conflicts() {
}
#[test]
-fn other_lists_still_conflict_as_a_whole() {
- // Docs silent: lists other than fills, strokes and effects (export settings here) still
- // conflict whole when both sides change them.
+fn the_other_item_lists_merge_one_by_one_too() {
+ // Layout grids, export settings, guides, accessibility annotations and Dev Mode resources are
+ // item lists like fills: both sides changing different items merges.
let (mut base, _, _, r) = files();
let export = |suffix: &str| figcraft_doc::ExportSetting { suffix: suffix.into(), ..Default::default() };
- base.get_mut(r).unwrap().exports = vec![export("@1"), export("@2")];
+ let guide = |vertical: bool, offset: f64| figcraft_doc::Guide { vertical, offset };
+ let annot = |label: &str| figcraft_doc::Annotation { label: label.into(), properties: Vec::new(), category: None };
+ let grid = |size: f64| LayoutGrid { size, ..Default::default() };
+ let res = |url: &str| figcraft_doc::DevResource { url: url.into(), name: String::new() };
+ let n = base.get_mut(r).unwrap();
+ n.exports = vec![export("@1"), export("@2")];
+ n.guides = vec![guide(true, 10.0), guide(false, 20.0)];
+ n.annotations = vec![annot("a1"), annot("a2")];
+ n.grids = vec![grid(10.0), grid(20.0)];
+ n.dev_resources = vec![res("https://a.test"), res("https://b.test")];
let (mut branch, mut main) = (base.clone(), base.clone());
branch.set_client_id(base.highest_id_space() + 1);
- branch.get_mut(r).unwrap().exports[0] = export("@b");
- main.get_mut(r).unwrap().exports[1] = export("@m");
+ // The branch changes the first item of each list; main the second.
+ let b = branch.get_mut(r).unwrap();
+ (b.exports[0].suffix, b.guides[0].offset, b.annotations[0].label, b.grids[0].size, b.dev_resources[0].url) =
+ ("@b".into(), 11.0, "b1".into(), 12.0, "https://branch.test".into());
+ let m = main.get_mut(r).unwrap();
+ (m.exports[1].suffix, m.guides[1].offset, m.annotations[1].label, m.grids[1].size, m.dev_resources[1].url) =
+ ("@m".into(), 22.0, "m2".into(), 24.0, "https://main.test".into());
+ both_ways(&base, &branch, &main, |doc| {
+ let n = doc.node(r).unwrap();
+ let suffixes: Vec<&str> = n.exports.iter().map(|e| e.suffix.as_str()).collect();
+ assert_eq!(suffixes, ["@b", "@m"], "export settings");
+ let offsets: Vec = n.guides.iter().map(|g| g.offset).collect();
+ assert_eq!(offsets, [11.0, 22.0], "guides");
+ let labels: Vec<&str> = n.annotations.iter().map(|a| a.label.as_str()).collect();
+ assert_eq!(labels, ["b1", "m2"], "annotations");
+ let sizes: Vec = n.grids.iter().map(|g| g.size).collect();
+ assert_eq!(sizes, [12.0, 24.0], "layout grids");
+ let urls: Vec<&str> = n.dev_resources.iter().map(|d| d.url.as_str()).collect();
+ assert_eq!(urls, ["https://branch.test", "https://main.test"], "dev resources");
+ });
+}
+
+#[test]
+fn the_same_item_of_another_list_changed_both_ways_conflicts() {
+ let (mut base, _, _, r) = files();
+ let link = |language: &str| figcraft_doc::CodeLink { language: language.into(), ..Default::default() };
+ let n = base.get_mut(r).unwrap();
+ n.exports = vec![
+ figcraft_doc::ExportSetting { suffix: "@1".into(), ..Default::default() },
+ figcraft_doc::ExportSetting { suffix: "@2".into(), ..Default::default() },
+ ];
+ n.code_links = vec![link("react"), link("vue")];
+ let (mut branch, mut main) = (base.clone(), base.clone());
+ branch.set_client_id(base.highest_id_space() + 1);
+ branch.get_mut(r).unwrap().exports[0].suffix = "@b".into();
+ main.get_mut(r).unwrap().exports[0].suffix = "@m".into();
+ // Code links are one per language, not an item list: different links changed still conflict.
+ branch.get_mut(r).unwrap().code_links[0].name = "B".into();
+ main.get_mut(r).unwrap().code_links[1].name = "M".into();
let p = plan(&base, &branch, &main).unwrap();
- let keys: Vec = p.conflicts.iter().map(|c| c.key.to_string()).collect();
- assert_eq!(keys, [format!("{r}/exports")]);
+ let mut keys: Vec = p.conflicts.iter().map(|c| c.key.to_string()).collect();
+ keys.sort();
+ let mut want = [format!("{r}/codeLinks"), format!("{r}/exports")];
+ want.sort();
+ assert_eq!(keys, want);
+}
+
+#[test]
+fn interactions_merge_item_by_item() {
+ let ia = |duration_ms: u32| proto::Interaction {
+ trigger: Default::default(),
+ actions: vec![proto::Action::Back],
+ transition: Default::default(),
+ duration_ms,
+ easing: Default::default(),
+ delay_ms: 0,
+ };
+ let durations = |doc: &Document, r: NodeId| doc.node(r).unwrap().interactions.iter().map(|i| i.duration_ms).collect::>();
+ let (mut base, _, _, r) = files();
+ base.get_mut(r).unwrap().interactions = vec![ia(100), ia(200)];
+ let fork = || {
+ let (mut branch, main) = (base.clone(), base.clone());
+ branch.set_client_id(base.highest_id_space() + 1);
+ (branch, main)
+ };
+ // The branch changes the first interaction and adds one; main changes the second.
+ let (mut branch, mut main) = fork();
+ branch.get_mut(r).unwrap().interactions[0].duration_ms = 150;
+ branch.get_mut(r).unwrap().interactions.push(ia(300));
+ main.get_mut(r).unwrap().interactions[1].duration_ms = 250;
+ both_ways(&base, &branch, &main, |doc| assert_eq!(durations(doc, r), [150, 250, 300]));
+ // The branch deletes one while main leaves them alone.
+ let (mut branch, mut main) = fork();
+ branch.get_mut(r).unwrap().interactions.remove(0);
+ main.get_mut(r).unwrap().fills[0] = red();
+ both_ways(&base, &branch, &main, |doc| assert_eq!(durations(doc, r), [200]));
+ // The same interaction changed both ways, or one deleted while the other side changed the
+ // list, conflicts.
+ for delete in [false, true] {
+ let (mut branch, mut main) = fork();
+ if delete {
+ branch.get_mut(r).unwrap().interactions.remove(0);
+ } else {
+ branch.get_mut(r).unwrap().interactions[1].duration_ms = 220;
+ }
+ main.get_mut(r).unwrap().interactions[1].duration_ms = 250;
+ let p = plan(&base, &branch, &main).unwrap();
+ let keys: Vec = p.conflicts.iter().map(|c| c.key.to_string()).collect();
+ assert_eq!(keys, [format!("{r}/interactions")], "delete: {delete}");
+ }
}
#[test]
diff --git a/crates/collab/src/message.rs b/crates/collab/src/message.rs
index d035042b..4fda776a 100644
--- a/crates/collab/src/message.rs
+++ b/crates/collab/src/message.rs
@@ -696,22 +696,38 @@ pub enum ServerMsg {
},
}
+/// (days since 1970-01-01, seconds-of-day, nanos) → (proleptic Gregorian year, the same wall-clock
+/// instant moved into chrono's range by whole 400-year cycles). The calendar repeats every 400
+/// years (146_097 days), so month, day and time of day come from chrono and only the year is
+/// carried, which keeps the result exact for any `i64` day count. This is not hand-rolled calendar
+/// math: chrono still does the date, the cycle count just shifts the year.
+fn utc_parts(days: i64, sod: u32, nanos: u32) -> (i64, chrono::NaiveDateTime) {
+ use chrono::Datelike;
+ let (cycles, rest) = (days.div_euclid(146_097), days.rem_euclid(146_097));
+ // `rest + 719_163` (1970-01-01 is CE day 719_163) is always a valid CE day, and `sod` < 86_400.
+ let date = i32::try_from(rest + 719_163).ok().and_then(chrono::NaiveDate::from_num_days_from_ce_opt);
+ let time = chrono::NaiveTime::from_num_seconds_from_midnight_opt(sod.min(86_399), nanos.min(999_999_999));
+ match (date, time) {
+ (Some(d), Some(t)) => {
+ let y = i128::from(d.year()) + i128::from(cycles) * 400;
+ (i64::try_from(y).unwrap_or(if y < 0 { i64::MIN } else { i64::MAX }), d.and_time(t))
+ }
+ _ => (1970, chrono::NaiveDateTime::default()), // unreachable
+ }
+}
+
/// `YYYY-MM-DD HH:MM UTC` for seconds since 1970 (how servers and apps show the times in these
-/// messages).
+/// messages). Years past chrono's own range (262143) keep converting: the instant is moved into
+/// range by whole 400-year cycles and the real year restored, so every `u64` reads as the date the
+/// old hand-rolled conversion produced (e.g. `u64::MAX` → `584554051223-11-09 07:00 UTC`).
pub fn utc_date(secs: u64) -> String {
- let days = i64::try_from(secs / 86_400).unwrap_or(0);
- let (h, m) = ((secs % 86_400) / 3600, (secs % 3600) / 60);
- // Days to a civil date (proleptic Gregorian).
- let z = days + 719_468;
- let era = z.div_euclid(146_097);
- let doe = z.rem_euclid(146_097);
- let yoe = (doe - doe / 1460 + doe / 36_524 - doe / 146_096) / 365;
- let doy = doe - (365 * yoe + yoe / 4 - yoe / 100);
- let mp = (5 * doy + 2) / 153;
- let d = doy - (153 * mp + 2) / 5 + 1;
- let mo = if mp < 10 { mp + 3 } else { mp - 9 };
- let y = yoe + era * 400 + i64::from(mo <= 2);
- format!("{y:04}-{mo:02}-{d:02} {h:02}:{m:02} UTC")
+ // The day count of any `u64` seconds fits in `i64` (`u64::MAX / 86_400` ≈ 2.1e14), and the
+ // seconds-of-day is < 86_400, so the conversion is always exact (no epoch fallback). Splitting
+ // with `u64` arithmetic (as the old code did) avoids the `i64` seconds overflow near `u64::MAX`.
+ let (days, sod) = (i64::try_from(secs / 86_400).unwrap_or(i64::MAX), (secs % 86_400) as u32);
+ let (y, t) = utc_parts(days, sod, 0);
+ // `{y:04}` rather than `%Y`, which writes a `+` before years past 9999 (the old code did not).
+ format!("{y:04}-{}", t.format("%m-%d %H:%M UTC"))
}
/// The binary form of `msg`: [`WIRE_VERSION`], then postcard.
@@ -752,3 +768,25 @@ pub fn decode_json(text: &str, max_bytes: usize) -> Result<
}
serde_json::from_str(text).map_err(|e| Error::Decode(e.to_string()))
}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ /// `utc_date` keeps the exact `YYYY-MM-DD HH:MM UTC` output the hand-rolled civil-from-days
+ /// code produced (leap days and all).
+ #[test]
+ fn utc_date_formats_seconds_since_1970() {
+ assert_eq!(utc_date(0), "1970-01-01 00:00 UTC");
+ assert_eq!(utc_date(1_000_000), "1970-01-12 13:46 UTC");
+ assert_eq!(utc_date(951_782_400), "2000-02-29 00:00 UTC");
+ assert_eq!(utc_date(1_709_164_800), "2024-02-29 00:00 UTC");
+ assert_eq!(utc_date(1_791_208_980), "2026-10-05 14:03 UTC");
+ // A year past 9999 keeps the plain zero-padded year (no `+`), as the old `{y:04}` did.
+ assert_eq!(utc_date(253_402_300_800), "10000-01-01 00:00 UTC");
+ // Past chrono's own year range (262143) the instant is moved into range by whole 400-year
+ // cycles and the real year restored, so it keeps the old hand-rolled output instead of
+ // falling back to the epoch.
+ assert_eq!(utc_date(u64::MAX), "584554051223-11-09 07:00 UTC");
+ }
+}
diff --git a/crates/color/src/lib.rs b/crates/color/src/lib.rs
index d6859a51..84149dfb 100644
--- a/crates/color/src/lib.rs
+++ b/crates/color/src/lib.rs
@@ -61,7 +61,7 @@ impl<'de> Deserialize<'de> for Color {
}
fn clamp01(v: f32) -> f32 {
- if v.is_finite() { v.clamp(0.0, 1.0) } else { 0.0 }
+ if v.is_nan() { 0.0 } else { v.clamp(0.0, 1.0) }
}
impl Default for Color {
@@ -162,7 +162,13 @@ impl Color {
p.parse::().ok().map(|v| v / 255.0)
}
};
- let alpha = parts.get(3).and_then(|a| parse_alpha(a)).unwrap_or(1.0);
+ let alpha = match parts.get(3) {
+ Some(a) => parse_alpha(a)?,
+ None => 1.0,
+ };
+ if parts.len() > 4 {
+ return None;
+ }
return Some(Self::new(num(0)?, num(1)?, num(2)?, alpha));
}
if let Some(inner) = t.strip_prefix("hsla(").or_else(|| t.strip_prefix("hsl(")).and_then(|r| r.strip_suffix(')')) {
@@ -170,7 +176,13 @@ impl Color {
let h = parts.first()?.trim_end_matches("deg").parse::().ok()?;
let s = parts.get(1)?.trim_end_matches('%').parse::().ok()? / 100.0;
let l = parts.get(2)?.trim_end_matches('%').parse::().ok()? / 100.0;
- let alpha = parts.get(3).and_then(|a| parse_alpha(a)).unwrap_or(1.0);
+ let alpha = match parts.get(3) {
+ Some(a) => parse_alpha(a)?,
+ None => 1.0,
+ };
+ if parts.len() > 4 {
+ return None;
+ }
return Some(Hsl { h, s, l }.to_color().with_alpha(alpha));
}
if t == "transparent" {
@@ -537,7 +549,7 @@ pub enum PaintKind {
}
/// One fill or stroke paint.
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct Paint {
#[serde(flatten)]
pub kind: PaintKind,
@@ -547,6 +559,17 @@ pub struct Paint {
pub visible: bool,
#[serde(default)]
pub blend: BlendMode,
+ /// The opacity holds the alpha of a typed solid colour (see [`Paint::solid`]) rather than an
+ /// opacity set on its own: a colour variable bound to the paint replaces it.
+ #[serde(default, rename = "colorAlpha", skip_serializing_if = "std::ops::Not::not")]
+ pub color_alpha: bool,
+}
+
+/// Paints compare by what they paint; where the opacity came from doesn't matter.
+impl PartialEq for Paint {
+ fn eq(&self, other: &Self) -> bool {
+ self.kind == other.kind && self.opacity == other.opacity && self.visible == other.visible && self.blend == other.blend
+ }
}
fn yes() -> bool {
@@ -555,11 +578,17 @@ fn yes() -> bool {
impl Paint {
pub fn solid(color: Color) -> Self {
- Self { kind: PaintKind::Solid { color: color.with_alpha(1.0) }, opacity: color.a, visible: true, blend: BlendMode::Normal }
+ Self {
+ kind: PaintKind::Solid { color: color.with_alpha(1.0) },
+ opacity: color.a,
+ visible: true,
+ blend: BlendMode::Normal,
+ color_alpha: color.a < 1.0,
+ }
}
pub fn gradient(g: Gradient) -> Self {
- Self { kind: PaintKind::Gradient(g), opacity: 1.0, visible: true, blend: BlendMode::Normal }
+ Self { kind: PaintKind::Gradient(g), opacity: 1.0, visible: true, blend: BlendMode::Normal, color_alpha: false }
}
pub fn image(hash: impl Into, mode: ImageScaleMode) -> Self {
@@ -575,12 +604,13 @@ impl Paint {
opacity: 1.0,
visible: true,
blend: BlendMode::Normal,
+ color_alpha: false,
}
}
/// Layer `source` (a node id) tiled at its own size.
pub fn pattern(source: u64) -> Self {
- Self { kind: PaintKind::Pattern(PatternPaint::new(source)), opacity: 1.0, visible: true, blend: BlendMode::Normal }
+ Self { kind: PaintKind::Pattern(PatternPaint::new(source)), opacity: 1.0, visible: true, blend: BlendMode::Normal, color_alpha: false }
}
/// The solid colour (with the paint opacity folded into alpha), if solid.
diff --git a/crates/color/src/tests.rs b/crates/color/src/tests.rs
index 68a838e0..2216b6fa 100644
--- a/crates/color/src/tests.rs
+++ b/crates/color/src/tests.rs
@@ -80,7 +80,7 @@ fn blend_names() {
#[test]
fn nan_inputs_are_sanitized() {
let c = Color::new(f32::NAN, 2.0, -1.0, f32::INFINITY);
- assert_eq!(c.to_rgba8(), [0, 255, 0, 0]);
+ assert_eq!(c.to_rgba8(), [0, 255, 0, 255]);
}
#[test]
@@ -106,3 +106,21 @@ fn crop_defaults_to_fill_and_roundtrips() {
assert!((a - b).abs() < 1e-9);
}
}
+
+#[test]
+fn infinite_channels_clamp() {
+ let c = Color::parse_css("rgb(1e40, 0, 0)").unwrap();
+ assert_eq!(c.r, 1.0);
+ let c = Color::new(f32::INFINITY, f32::NEG_INFINITY, f32::NAN, f32::INFINITY);
+ assert_eq!((c.r, c.g, c.b, c.a), (1.0, 0.0, 0.0, 1.0));
+}
+
+#[test]
+fn malformed_alpha_or_extra_args_rejected() {
+ assert_eq!(Color::parse_css("rgba(0,0,0,abc)"), None);
+ assert_eq!(Color::parse_css("hsla(0,0%,0%,abc)"), None);
+ assert_eq!(Color::parse_css("rgb(1,2,3,4,5)"), None);
+ assert_eq!(Color::parse_css("hsl(0,0%,0%,0.5,1)"), None);
+ assert_eq!(Color::parse_css("rgb(1,2,3)").unwrap().a, 1.0);
+ assert_eq!(Color::parse_css("rgba(1,2,3,0.5)").unwrap().a, 0.5);
+}
diff --git a/crates/doc/src/board.rs b/crates/doc/src/board.rs
new file mode 100644
index 00000000..28ed0c1d
--- /dev/null
+++ b/crates/doc/src/board.rs
@@ -0,0 +1,433 @@
+//! Boards: a file kind for whiteboarding, and the small piece of metadata board objects carry.
+//!
+//! Board objects are ordinary nodes (frames, vectors, text) with a [`BoardItem`] on them, so
+//! rendering, hit testing, undo, saving, export, copy and paste and live sessions treat them like
+//! any other layer. The metadata says what the object is for: which text a sticky note fits, what
+//! a connector joins, who placed a stamp.
+
+use figcraft_color::Color;
+use figcraft_geom::kurbo::{Ellipse, RoundedRect};
+use figcraft_geom::{BezPath, Point, Rect, Shape};
+use serde::{Deserialize, Serialize};
+
+use crate::NodeId;
+
+/// What a file is for: designing screens, or a board to think together on.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub enum FileKind {
+ #[default]
+ Design,
+ Board,
+}
+
+impl FileKind {
+ pub fn is_design(&self) -> bool {
+ *self == FileKind::Design
+ }
+ pub fn id(self) -> &'static str {
+ match self {
+ FileKind::Design => "design",
+ FileKind::Board => "board",
+ }
+ }
+}
+
+/// What a board object is.
+#[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.
+ Sticky {
+ #[serde(default, skip_serializing_if = "String::is_empty")]
+ author: String,
+ },
+ /// A shape with text: a frame holding the outline (a vector) and a centred text.
+ Shape { shape: BoardShape },
+ /// A line between two objects or points (a vector, re-routed when they move).
+ Connector(Connector),
+ /// The label in the middle of connector `connector` (a frame holding its text).
+ Label { connector: NodeId },
+ /// A stamp, and who placed it.
+ Stamp {
+ stamp: Stamp,
+ #[serde(default, skip_serializing_if = "String::is_empty")]
+ author: String,
+ },
+ /// A marker or highlighter stroke (what the eraser takes).
+ Ink,
+}
+
+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 { .. })
+ }
+
+ /// 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 { .. })
+ }
+
+ /// Who made it (stickies and stamps; empty when unknown).
+ pub fn author(&self) -> &str {
+ match self {
+ BoardItem::Sticky { author } | BoardItem::Stamp { author, .. } => author,
+ _ => "",
+ }
+ }
+
+ /// Point the layers this object refers to (a connector's ends, a label's connector) at their
+ /// copies in `map`; the others stay.
+ pub fn remap(&mut self, map: &std::collections::BTreeMap) {
+ match self {
+ BoardItem::Connector(c) => {
+ for end in [&mut c.from, &mut c.to] {
+ if let End::Node { node, .. } = end
+ && let Some(m) = map.get(node)
+ {
+ *node = *m;
+ }
+ }
+ }
+ BoardItem::Label { connector } => {
+ if let Some(m) = map.get(connector) {
+ *connector = *m;
+ }
+ }
+ _ => {}
+ }
+ }
+
+ pub fn kind_id(&self) -> &'static str {
+ match self {
+ BoardItem::Sticky { .. } => "sticky",
+ BoardItem::Shape { .. } => "shape",
+ BoardItem::Connector(_) => "connector",
+ BoardItem::Label { .. } => "label",
+ BoardItem::Stamp { .. } => "stamp",
+ BoardItem::Ink => "ink",
+ }
+ }
+}
+
+/// The colours stickies, shapes and connectors come in: soft tints that dark text reads on.
+pub const BOARD_COLORS: [(&str, Color); 8] = [
+ ("yellow", Color::from_rgb8_const(0xFF, 0xE7, 0x8A)),
+ ("orange", Color::from_rgb8_const(0xFF, 0xC9, 0x94)),
+ ("red", Color::from_rgb8_const(0xFF, 0xAE, 0xA6)),
+ ("pink", Color::from_rgb8_const(0xF7, 0xB9, 0xDA)),
+ ("violet", Color::from_rgb8_const(0xD4, 0xC2, 0xFC)),
+ ("blue", Color::from_rgb8_const(0xAC, 0xD3, 0xFA)),
+ ("green", Color::from_rgb8_const(0xC2, 0xE8, 0xA6)),
+ ("gray", Color::from_rgb8_const(0xE3, 0xE1, 0xDD)),
+];
+
+/// A board colour by name ("yellow") or as hex ("#FFE78A").
+pub fn board_color(s: &str) -> Option {
+ let s = s.trim();
+ BOARD_COLORS.iter().find(|(n, _)| n.eq_ignore_ascii_case(s)).map(|(_, c)| *c).or_else(|| Color::from_hex(s))
+}
+
+/// The page colour boards start with: a warm light grey the colours stand out on.
+pub const BOARD_PAGE: Color = Color::from_rgb8_const(0xF4, 0xF3, 0xF0);
+
+/// The outlines shapes with text come in.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub enum BoardShape {
+ #[default]
+ Rectangle,
+ RoundedRectangle,
+ Ellipse,
+ Diamond,
+ Triangle,
+ SpeechBubble,
+ Chevron,
+}
+
+impl BoardShape {
+ pub const ALL: [BoardShape; 7] = [
+ BoardShape::Rectangle,
+ BoardShape::RoundedRectangle,
+ BoardShape::Ellipse,
+ BoardShape::Diamond,
+ BoardShape::Triangle,
+ BoardShape::SpeechBubble,
+ BoardShape::Chevron,
+ ];
+
+ pub fn id(self) -> &'static str {
+ match self {
+ BoardShape::Rectangle => "rectangle",
+ BoardShape::RoundedRectangle => "roundedRectangle",
+ BoardShape::Ellipse => "ellipse",
+ BoardShape::Diamond => "diamond",
+ BoardShape::Triangle => "triangle",
+ BoardShape::SpeechBubble => "speechBubble",
+ BoardShape::Chevron => "chevron",
+ }
+ }
+
+ pub fn from_id(s: &str) -> Option {
+ BoardShape::ALL.into_iter().find(|b| b.id().eq_ignore_ascii_case(s))
+ }
+
+ pub fn label(self) -> &'static str {
+ match self {
+ BoardShape::Rectangle => "Rectangle",
+ BoardShape::RoundedRectangle => "Rounded rectangle",
+ BoardShape::Ellipse => "Ellipse",
+ BoardShape::Diamond => "Diamond",
+ BoardShape::Triangle => "Triangle",
+ BoardShape::SpeechBubble => "Speech bubble",
+ BoardShape::Chevron => "Chevron",
+ }
+ }
+
+ /// The outline in a `w` × `h` box at the origin.
+ pub fn path(self, w: f64, h: f64) -> BezPath {
+ let poly = |pts: &[(f64, f64)]| {
+ let mut p = BezPath::new();
+ for (i, (x, y)) in pts.iter().enumerate() {
+ let q = Point::new(x * w, y * h);
+ if i == 0 { p.move_to(q) } else { p.line_to(q) }
+ }
+ p.close_path();
+ p
+ };
+ let r = w.min(h);
+ match self {
+ BoardShape::Rectangle => Rect::new(0.0, 0.0, w, h).to_path(0.1),
+ BoardShape::RoundedRectangle => RoundedRect::new(0.0, 0.0, w, h, r * 0.16).to_path(0.1),
+ BoardShape::Ellipse => Ellipse::from_rect(Rect::new(0.0, 0.0, w, h)).to_path(0.1),
+ BoardShape::Diamond => poly(&[(0.5, 0.0), (1.0, 0.5), (0.5, 1.0), (0.0, 0.5)]),
+ BoardShape::Triangle => poly(&[(0.5, 0.0), (1.0, 1.0), (0.0, 1.0)]),
+ BoardShape::Chevron => poly(&[(0.0, 0.0), (0.72, 0.0), (1.0, 0.5), (0.72, 1.0), (0.0, 1.0), (0.28, 0.5)]),
+ BoardShape::SpeechBubble => {
+ // A rounded body over the bottom fifth, with a tail down to the left.
+ let (b, c) = (h * 0.8, r * 0.14);
+ let mut p = BezPath::new();
+ p.move_to((c, 0.0));
+ p.line_to((w - c, 0.0));
+ p.quad_to((w, 0.0), (w, c));
+ p.line_to((w, b - c));
+ p.quad_to((w, b), (w - c, b));
+ p.line_to((w * 0.42, b));
+ p.line_to((w * 0.18, h));
+ p.line_to((w * 0.24, b));
+ p.line_to((c, b));
+ p.quad_to((0.0, b), (0.0, b - c));
+ p.line_to((0.0, c));
+ p.quad_to((0.0, 0.0), (c, 0.0));
+ p.close_path();
+ p
+ }
+ }
+ }
+
+ /// Where the text goes, as insets of the box (top, right, bottom, left, in fractions of its
+ /// size): inside the outline's widest part.
+ pub fn text_insets(self) -> [f64; 4] {
+ match self {
+ BoardShape::Rectangle | BoardShape::RoundedRectangle => [0.08, 0.08, 0.08, 0.08],
+ BoardShape::Ellipse => [0.16, 0.16, 0.16, 0.16],
+ BoardShape::Diamond => [0.25, 0.25, 0.25, 0.25],
+ BoardShape::Triangle => [0.45, 0.22, 0.06, 0.22],
+ BoardShape::SpeechBubble => [0.08, 0.08, 0.28, 0.08],
+ BoardShape::Chevron => [0.12, 0.3, 0.12, 0.3],
+ }
+ }
+}
+
+/// The stamps: round badges with a mark.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub enum Stamp {
+ #[default]
+ ThumbsUp,
+ Heart,
+ PlusOne,
+ Star,
+ Question,
+ Check,
+}
+
+/// One part of a stamp's mark: SVG path data on the badge's 40-unit box, filled or stroked.
+pub struct MarkPart {
+ pub d: &'static str,
+ pub filled: bool,
+}
+
+/// A stamp badge's size.
+pub const STAMP_SIZE: f64 = 40.0;
+
+impl Stamp {
+ pub const ALL: [Stamp; 6] = [Stamp::ThumbsUp, Stamp::Heart, Stamp::PlusOne, Stamp::Star, Stamp::Question, Stamp::Check];
+
+ pub fn id(self) -> &'static str {
+ match self {
+ Stamp::ThumbsUp => "thumbsUp",
+ Stamp::Heart => "heart",
+ Stamp::PlusOne => "plusOne",
+ Stamp::Star => "star",
+ Stamp::Question => "question",
+ Stamp::Check => "check",
+ }
+ }
+
+ pub fn from_id(s: &str) -> Option {
+ Stamp::ALL.into_iter().find(|b| b.id().eq_ignore_ascii_case(s))
+ }
+
+ pub fn label(self) -> &'static str {
+ match self {
+ Stamp::ThumbsUp => "Thumbs up",
+ Stamp::Heart => "Heart",
+ Stamp::PlusOne => "Plus one",
+ Stamp::Star => "Star",
+ Stamp::Question => "Question",
+ Stamp::Check => "Check",
+ }
+ }
+
+ /// The badge's colour (the mark is white on it).
+ pub fn color(self) -> Color {
+ match self {
+ Stamp::ThumbsUp => Color::from_rgb8_const(0x3B, 0x82, 0xE8),
+ Stamp::Heart => Color::from_rgb8_const(0xE5, 0x48, 0x5F),
+ Stamp::PlusOne => Color::from_rgb8_const(0x2E, 0xA0, 0x63),
+ Stamp::Star => Color::from_rgb8_const(0xEE, 0x9B, 0x1A),
+ Stamp::Question => Color::from_rgb8_const(0x84, 0x5E, 0xD8),
+ Stamp::Check => Color::from_rgb8_const(0x14, 0x96, 0x8C),
+ }
+ }
+
+ /// The mark, drawn for FigCraft from lines, arcs and simple outlines.
+ pub fn mark(self) -> &'static [MarkPart] {
+ match self {
+ // A cuff and a raised hand with its thumb up.
+ Stamp::ThumbsUp => &[
+ MarkPart { d: "M10.5 19 H15 V29 H10.5 Z", filled: true },
+ MarkPart {
+ d: "M16.5 19 L20.6 11.4 C21.6 9.8 24.6 10.6 24.2 13 L23.4 17 H28.2 C29.8 17 30.9 18.5 30.4 20 L28.4 27.3 C28 28.4 27.1 29 25.9 29 H16.5 Z",
+ filled: true,
+ },
+ ],
+ // Two round lobes meeting in a point.
+ Stamp::Heart => &[MarkPart {
+ d: "M20 29.5 C12.5 24.5 9.5 20.6 10.4 16.4 C11.3 12.2 16.8 11.2 20 15.4 C23.2 11.2 28.7 12.2 29.6 16.4 C30.5 20.6 27.5 24.5 20 29.5 Z",
+ filled: true,
+ }],
+ Stamp::PlusOne => &[MarkPart { d: "M10 20 H20 M15 15 V25", filled: false }, MarkPart { d: "M24.5 15 L27.5 12.5 V27.5", filled: false }],
+ Stamp::Star => &[MarkPart {
+ d: "M20 10.5 L22.8 16.7 L29.5 17.4 L24.5 21.9 L25.9 28.6 L20 25.2 L14.1 28.6 L15.5 21.9 L10.5 17.4 L17.2 16.7 Z",
+ filled: true,
+ }],
+ Stamp::Question => &[
+ MarkPart { d: "M15.6 16.2 C15.6 10.6 24.4 10.6 24.4 16 C24.4 19.6 20 19.9 20 23.6", filled: false },
+ MarkPart { d: "M18.2 28 A1.8 1.8 0 1 0 21.8 28 A1.8 1.8 0 1 0 18.2 28 Z", filled: true },
+ ],
+ Stamp::Check => &[MarkPart { d: "M12.5 20.5 L18 26 L28 14.5", filled: false }],
+ }
+ }
+}
+
+/// How a connector runs between its ends.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub enum Routing {
+ #[default]
+ Straight,
+ /// Right angles only: out of each end along its side's normal, turning once or twice.
+ Elbow,
+}
+
+impl Routing {
+ pub fn id(self) -> &'static str {
+ match self {
+ Routing::Straight => "straight",
+ Routing::Elbow => "elbow",
+ }
+ }
+ pub fn from_id(s: &str) -> Option {
+ [Routing::Straight, Routing::Elbow].into_iter().find(|r| r.id().eq_ignore_ascii_case(s))
+ }
+}
+
+/// The side of an object a connector end is attached to (at its middle).
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub enum Side {
+ /// The side facing the other end.
+ #[default]
+ Auto,
+ Top,
+ Right,
+ Bottom,
+ Left,
+}
+
+impl Side {
+ pub fn from_id(s: &str) -> Option {
+ Some(match s.to_ascii_lowercase().as_str() {
+ "auto" => Side::Auto,
+ "top" => Side::Top,
+ "right" => Side::Right,
+ "bottom" => Side::Bottom,
+ "left" => Side::Left,
+ _ => return None,
+ })
+ }
+
+ /// The side's middle on `b`.
+ pub fn point(self, b: Rect) -> Point {
+ let c = b.center();
+ match self {
+ Side::Top => Point::new(c.x, b.y0),
+ Side::Right => Point::new(b.x1, c.y),
+ Side::Bottom => Point::new(c.x, b.y1),
+ Side::Left => Point::new(b.x0, c.y),
+ Side::Auto => c,
+ }
+ }
+
+ pub fn horizontal(self) -> bool {
+ matches!(self, Side::Left | Side::Right)
+ }
+}
+
+/// One end of a connector: attached to a layer, or a free point on the page.
+#[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]
+#[serde(untagged)]
+pub enum End {
+ Node {
+ node: NodeId,
+ #[serde(default)]
+ side: Side,
+ },
+ Point {
+ x: f64,
+ y: f64,
+ },
+}
+
+impl End {
+ pub fn node(&self) -> Option {
+ match self {
+ End::Node { node, .. } => Some(*node),
+ End::Point { .. } => None,
+ }
+ }
+}
+
+/// What a connector joins and how it runs (its arrowheads are its stroke's caps).
+#[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Connector {
+ pub from: End,
+ pub to: End,
+ #[serde(default)]
+ pub routing: Routing,
+}
diff --git a/crates/doc/src/geometry.rs b/crates/doc/src/geometry.rs
index 2a7b42a6..b4f89dbc 100644
--- a/crates/doc/src/geometry.rs
+++ b/crates/doc/src/geometry.rs
@@ -72,7 +72,16 @@ fn hits_node_itself(doc: &Document, id: NodeId, n: &Node, pt: Point, tol: f64, o
NodeKind::Frame | NodeKind::Component { .. } | NodeKind::ComponentSet { .. } | NodeKind::Instance { .. } | NodeKind::Section { .. } => {
n.local_rect().inflate(tol_l, tol_l).contains(lp)
}
- _ => shape_path(n).is_some_and(|path| hits_path(n, &path, lp, tol_l, !outline && is_closed(n) && path.winding(lp) != 0)),
+ _ => shape_path(n).is_some_and(|path| hits_path(n, &path, lp, tol_l, !outline && is_closed(n) && fills_point(n, &path, lp))),
+ }
+}
+
+/// Whether the fill of `n`, drawn as `path`, covers `lp` (vectors follow the rule of
+/// [`VectorNetwork::fill_contains`](crate::VectorNetwork::fill_contains): even-odd when any region asks for it).
+fn fills_point(n: &Node, path: &BezPath, lp: Point) -> bool {
+ match &n.kind {
+ NodeKind::Vector { network } => network.fill_contains(lp),
+ _ => path.winding(lp) != 0,
}
}
@@ -255,6 +264,18 @@ pub fn select_target(doc: &Document, leaf: NodeId, context: &[NodeId], deep: boo
if deep {
return leaf;
}
+ let target = level_target(doc, leaf, context);
+ // A board object is picked whole (a sticky, not its text), unless a layer inside it is selected.
+ let mut chain = doc.ancestors(target);
+ chain.reverse();
+ chain.push(target);
+ chain
+ .into_iter()
+ .find(|c| doc.node(*c).is_some_and(Node::is_board_atom) && !context.iter().any(|s| s != c && doc.is_ancestor(*c, *s)))
+ .unwrap_or(target)
+}
+
+fn level_target(doc: &Document, leaf: NodeId, context: &[NodeId]) -> NodeId {
// Chain from the page's child down to the leaf.
let mut chain: Vec = doc.ancestors(leaf);
chain.reverse();
diff --git a/crates/doc/src/lib.rs b/crates/doc/src/lib.rs
index 07700e8c..1eb1fb0b 100644
--- a/crates/doc/src/lib.rs
+++ b/crates/doc/src/lib.rs
@@ -8,6 +8,7 @@
//! live in higher crates.
#![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)]
+pub mod board;
pub mod colors;
pub mod comments;
pub mod geometry;
@@ -23,6 +24,7 @@ pub mod vector;
pub mod vector_faces;
pub mod vector_regions;
+pub use board::*;
pub use colors::*;
pub use comments::*;
pub use figcraft_color as color;
@@ -157,6 +159,9 @@ pub struct ImageData {
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Document {
pub name: String,
+ /// A design file or a board (files from before boards are design files).
+ #[serde(default, skip_serializing_if = "FileKind::is_design")]
+ pub kind: FileKind,
/// Page ids in order.
pub pages: Vec,
nodes: imbl::OrdMap>,
@@ -221,6 +226,7 @@ impl Document {
pub fn without_pages(name: impl Into) -> Self {
Self {
name: name.into(),
+ kind: FileKind::Design,
pages: Vec::new(),
nodes: imbl::OrdMap::new(),
dirty: Dirty::default(),
@@ -269,7 +275,16 @@ impl Document {
/// A fresh unused id (in this document's client space during a collaboration session; see
/// [`set_client_id`](Self::set_client_id)).
pub fn alloc_id(&mut self) -> NodeId {
- self.next_id.alloc()
+ // A file's saved `next_id` can be stale (behind ids already in use): skip taken ids.
+ let mut id = self.next_id.alloc();
+ while self.nodes.contains_key(&id) {
+ let next = self.next_id.alloc();
+ if next == id {
+ break;
+ }
+ id = next;
+ }
+ id
}
/// The id [`alloc_id`](Self::alloc_id) returns next.
@@ -453,8 +468,9 @@ impl Document {
return true;
}
guard += 1;
- if guard > 10_000 {
- return false;
+ // More hops than nodes means the parent chain loops; fail closed so callers reject the move.
+ if guard > self.nodes.len() {
+ return true;
}
cur = self.node(c).and_then(|n| n.parent);
}
@@ -821,6 +837,10 @@ impl Document {
return Err(DocError::NotContainer(parent));
}
let new_root = *map.get(&root).ok_or(DocError::NoNode(root))?;
+ // Never overwrite an existing node with a copy.
+ if let Some(taken) = nodes.iter().filter_map(|n| map.get(&n.id)).find(|i| self.nodes.contains_key(*i)) {
+ return Err(DocError::Invalid(format!("node {taken} already exists")));
+ }
for n in nodes {
let Some(new_id) = map.get(&n.id) else { continue };
let mut c = n.clone();
@@ -835,6 +855,10 @@ impl Document {
{
*component = *m;
}
+ // A connector (or label) copied with what it joins joins the copies.
+ if let Some(b) = c.board.as_mut() {
+ b.remap(map);
+ }
// A pattern tiling a layer of the copy tiles the copy's layer.
for p in c.fills.iter_mut().chain(c.strokes.iter_mut()) {
if let figcraft_color::PaintKind::Pattern(pt) = &mut p.kind
@@ -949,56 +973,81 @@ impl Document {
self.styles.iter().find(|s| s.id == id || s.name == id)
}
- /// The effective variable modes for a node (walking up its ancestors).
+ /// The effective variable modes for a node: the ones it sets over [`Self::inherited_modes`].
pub fn modes_for(&self, id: NodeId) -> BTreeMap {
- let mut out = BTreeMap::new();
- let mut chain = vec![id];
- chain.extend(self.ancestors(id));
- for c in chain.into_iter().rev() {
- if let Some(n) = self.node(c) {
- for (k, v) in &n.var_modes {
- out.insert(k.clone(), v.clone());
- }
- }
+ let mut out = self.inherited_modes(id);
+ if let Some(n) = self.node(id) {
+ out.extend(n.var_modes.iter().map(|(k, v)| (k.clone(), v.clone())));
}
out
}
+ /// The modes a node is on where it sets none (Auto): its ancestors', and for an instance the
+ /// ones its main component sets, which are closer than any container's.
+ pub fn inherited_modes(&self, id: NodeId) -> BTreeMap {
+ let mut out = BTreeMap::new();
+ for c in self.ancestors(id).into_iter().rev() {
+ if let Some(n) = self.node(c) {
+ out.extend(self.main_modes(n).chain(&n.var_modes).map(|(k, v)| (k.clone(), v.clone())));
+ }
+ }
+ if let Some(n) = self.node(id) {
+ out.extend(self.main_modes(n).map(|(k, v)| (k.clone(), v.clone())));
+ }
+ out
+ }
+
+ /// The modes an instance's main component sets (none for other layers).
+ fn main_modes<'a>(&'a self, n: &Node) -> impl Iterator- {
+ let main = match n.kind {
+ NodeKind::Instance { component, .. } => self.node(component),
+ _ => None,
+ };
+ main.into_iter().flat_map(|m| &m.var_modes)
+ }
+
/// Check structural invariants (used by tests and after loading untrusted files).
pub fn validate(&self) -> Vec
{
+ // Hostile files can break an invariant per child; keep only the first few reports.
+ const MAX_ISSUES: usize = 100;
+ fn note(issues: &mut Vec, msg: impl FnOnce() -> String) {
+ if issues.len() < MAX_ISSUES {
+ issues.push(msg());
+ }
+ }
let mut issues = Vec::new();
for (id, n) in self.nodes.iter() {
if n.id != *id {
- issues.push(format!("node key {id} has id {}", n.id));
+ note(&mut issues, || format!("node key {id} has id {}", n.id));
}
let mut seen = std::collections::BTreeSet::new();
for c in &n.children {
if !seen.insert(*c) {
- issues.push(format!("child {c} listed twice in {id}"));
+ note(&mut issues, || format!("child {c} listed twice in {id}"));
}
match self.node(*c) {
Some(cn) if cn.parent == Some(*id) => {}
- Some(_) => issues.push(format!("child {c} of {id} has another parent")),
- None => issues.push(format!("child {c} of {id} missing")),
+ Some(_) => note(&mut issues, || format!("child {c} of {id} has another parent")),
+ None => note(&mut issues, || format!("child {c} of {id} missing")),
}
}
if let Some(p) = n.parent
&& !self.node(p).is_some_and(|pn| pn.children.contains(id))
{
- issues.push(format!("{id} not listed in parent {p}"));
+ note(&mut issues, || format!("{id} not listed in parent {p}"));
}
// The library store's root is a page that is never listed.
let listed = self.pages.contains(id) || (n.is_page() && self.libraries.store == Some(*id));
if n.is_page() != listed {
- issues.push(format!("page list mismatch for {id}"));
+ note(&mut issues, || format!("page list mismatch for {id}"));
}
if n.is_page() && n.parent.is_some() {
- issues.push(format!("page {id} has a parent"));
+ note(&mut issues, || format!("page {id} has a parent"));
}
}
let reachable = self.reachable();
for id in self.nodes.keys().filter(|k| !reachable.contains(*k)) {
- issues.push(format!("{id} is not under a page (cycle or detached)"));
+ note(&mut issues, || format!("{id} is not under a page (cycle or detached)"));
}
issues
}
diff --git a/crates/doc/src/node.rs b/crates/doc/src/node.rs
index 00f7d559..649d5e56 100644
--- a/crates/doc/src/node.rs
+++ b/crates/doc/src/node.rs
@@ -518,6 +518,9 @@ pub struct Node {
/// Dev resources: links for developers (docs, code, tickets…), in the order they were added.
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub dev_resources: Vec,
+ /// On a board: what this object is (a sticky note, a connector, a stamp…).
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub board: Option,
}
pub(crate) fn yes() -> bool {
@@ -628,6 +631,7 @@ impl Node {
annotations: Vec::new(),
code_links: Vec::new(),
dev_resources: Vec::new(),
+ board: None,
}
}
@@ -653,6 +657,11 @@ impl Node {
matches!(self.kind, NodeKind::Page { .. })
}
+ /// A board object selected and moved as a whole (a sticky, a shape with text, a stamp…).
+ pub fn is_board_atom(&self) -> bool {
+ self.board.as_ref().is_some_and(crate::BoardItem::is_atom)
+ }
+
/// A section whose contents are hidden: only its name and outline show; its children are
/// skipped when rendering and hit testing.
pub fn hides_contents(&self) -> bool {
diff --git a/crates/doc/src/proto_expr.rs b/crates/doc/src/proto_expr.rs
index f4404dc7..d5441b28 100644
--- a/crates/doc/src/proto_expr.rs
+++ b/crates/doc/src/proto_expr.rs
@@ -169,7 +169,12 @@ impl Expr {
})
.collect();
match (op, parts.as_slice()) {
- (ExprOp::Not, [x]) => format!("not {x}"),
+ // `not done` reads as a variable named "not done" if there is one: then
+ // `not (done)`.
+ (ExprOp::Not, [x]) => {
+ let bare = format!("not {x}");
+ if x.starts_with('(') || Expr::parse(&bare, vars).is_ok_and(|e| e == *self) { bare } else { format!("not ({x})") }
+ }
(ExprOp::Negate, [x]) => format!("-{x}"),
_ => parts.join(&format!(" {} ", op.symbol())),
}
diff --git a/crates/doc/src/proto_expr_parse.rs b/crates/doc/src/proto_expr_parse.rs
index 5214a2d6..54615ee0 100644
--- a/crates/doc/src/proto_expr_parse.rs
+++ b/crates/doc/src/proto_expr_parse.rs
@@ -459,16 +459,19 @@ impl Parser<'_> {
if self.at_keyword("mode") && self.next_after(4) == Some('(') {
return self.mode_of();
}
- if let Some((id, n)) = self.variable_here() {
- self.i += n;
- return self.in_mode(id);
- }
+ let var = self.variable_here();
+ // A bare `true`/`false` is the literal, also when a variable has that name (it reads
+ // as `{true}`); longer names that start with it ("true value") stay variables.
for (word, v) in [("true", true), ("false", false)] {
- if self.at_keyword(word) {
+ if self.at_keyword(word) && var.as_ref().is_none_or(|(_, n)| *n <= word.len()) {
self.i += word.len();
return Ok(Expr::Value(VariableValue::Boolean(v)));
}
}
+ if let Some((id, n)) = var {
+ self.i += n;
+ return self.in_mode(id);
+ }
let word: String = self.s.iter().skip(self.i).take_while(|c| ident(**c)).collect();
if word.is_empty() { Err(self.err(format!("Unexpected {c}"))) } else { Err(self.err(format!("No variable `{word}`"))) }
}
diff --git a/crates/doc/src/proto_expr_parse_tests.rs b/crates/doc/src/proto_expr_parse_tests.rs
index e106121d..1cac9f53 100644
--- a/crates/doc/src/proto_expr_parse_tests.rs
+++ b/crates/doc/src/proto_expr_parse_tests.rs
@@ -195,3 +195,49 @@ fn names_that_look_like_literals_read_back_as_variables() {
assert_eq!(parse("1"), n(1.0));
assert_eq!(parse("\"q\""), Expr::Value(VariableValue::String("q".into())));
}
+
+#[test]
+fn not_of_a_variable_reads_back_when_a_name_starts_with_not() {
+ use ExprOp::*;
+ let mut v = vars();
+ let b = v.variables.iter().find(|x| x.id == "b").unwrap().clone();
+ for (id, name) in [("done", "done"), ("nd", "not done")] {
+ let mut x = b.clone();
+ x.id = id.into();
+ x.name = name.into();
+ v.variables.push(x);
+ }
+ let not_done = Expr::op(Not, vec![Expr::var("done")]);
+ for e in [
+ not_done.clone(),
+ Expr::op(And, vec![Expr::var("b"), not_done.clone()]),
+ Expr::op(Equals, vec![not_done.clone(), Expr::Value(VariableValue::Boolean(true))]),
+ Expr::op(Not, vec![not_done.clone()]),
+ ] {
+ let shown = e.display(&v);
+ assert_eq!(Expr::parse(&shown, &v), Ok(e.clone()), "shown as {shown:?}");
+ }
+ assert_eq!(Expr::op(Not, vec![Expr::var("b")]).display(&vars()), "not b-name", "plain names stay bare");
+}
+
+#[test]
+fn literal_true_false_survive_variables_named_true_false() {
+ use ExprOp::*;
+ let lit = |x: bool| Expr::Value(VariableValue::Boolean(x));
+ for name in ["true", "false", "TRUE"] {
+ let mut v = vars();
+ if let Some(var) = v.variables.iter_mut().find(|x| x.id == "b") {
+ var.name = name.into();
+ }
+ for e in [
+ Expr::op(Equals, vec![Expr::var("b"), lit(true)]),
+ Expr::op(Equals, vec![Expr::var("b"), lit(false)]),
+ Expr::op(Not, vec![lit(false)]),
+ Expr::var("b"),
+ ] {
+ let shown = e.display(&v);
+ assert_eq!(Expr::parse(&shown, &v), Ok(e.clone()), "{name:?} shown as {shown:?}");
+ }
+ assert_eq!(Expr::parse(&format!("{{{name}}}"), &v), Ok(Expr::var("b")));
+ }
+}
diff --git a/crates/doc/src/tests.rs b/crates/doc/src/tests.rs
index a5ead3b7..38cab817 100644
--- a/crates/doc/src/tests.rs
+++ b/crates/doc/src/tests.rs
@@ -326,6 +326,20 @@ fn repair_drops_cycles_and_repeated_children() {
assert_eq!(bad.subtree(p), vec![p, r]);
}
+#[test]
+fn validate_caps_the_issue_list() {
+ let mut d = Document::new("x");
+ let p = page(&d);
+ let f = d.create(p, NodeKind::Frame, "F", 0.0, 0.0, 100.0, 100.0).unwrap();
+ let g = d.create(f, NodeKind::Frame, "G", 0.0, 0.0, 10.0, 10.0).unwrap();
+ let mut v = serde_json::to_value(&d).unwrap();
+ v["nodes"][f.to_string()]["children"] = serde_json::json!(vec![g; 5000]);
+ let bad: Document = serde_json::from_value(v).unwrap();
+ let issues = bad.validate();
+ assert!(!issues.is_empty());
+ assert!(issues.len() <= 100, "{}", issues.len());
+}
+
#[test]
fn auto_layout_loads_files_without_grid_tracks() {
// Saved before grid tracks, cells and spans existed.
@@ -464,3 +478,78 @@ fn text_style_empty_range_links_and_unlinks_all() {
e.unlink_text_style(0, 0);
assert!(e.style.style_id.is_none());
}
+
+#[test]
+fn stale_next_id_never_overwrites_existing_nodes() {
+ let mut d = Document::new("x");
+ let p = page(&d);
+ let f = d.create(p, NodeKind::Frame, "F", 0.0, 0.0, 100.0, 100.0).unwrap();
+ let a = d.create(f, NodeKind::Rectangle, "A", 0.0, 0.0, 10.0, 10.0).unwrap();
+ let mut v = serde_json::to_value(&d).unwrap();
+ v["next_id"] = serde_json::json!(1);
+ let mut bad: Document = serde_json::from_value(v).unwrap();
+ let before: Vec<(NodeId, String, Option)> =
+ [p, f, a].iter().map(|i| (*i, bad.node(*i).unwrap().name.clone(), bad.node(*i).unwrap().parent)).collect();
+ let n = bad.node_count();
+ let copy = bad.duplicate_into(f, p, None).unwrap();
+ assert!(![p, f, a].contains(©));
+ assert_eq!(bad.node_count(), n + 2);
+ let copies = bad.duplicate_all_into(&[f], p).unwrap();
+ assert_eq!(bad.node_count(), n + 4);
+ assert!(copies.iter().all(|c| ![p, f, a, copy].contains(c)));
+ for (i, name, parent) in &before {
+ let node = bad.node(*i).unwrap();
+ assert_eq!((&node.name, node.parent), (name, *parent));
+ }
+ assert!(bad.validate().is_empty(), "{:?}", bad.validate());
+
+ // A paste whose id map points at an existing node fails and changes nothing.
+ let nodes: Vec = bad.subtree(f).into_iter().filter_map(|i| bad.node(i).cloned()).collect();
+ let mut map: BTreeMap = nodes.iter().map(|n| (n.id, bad.alloc_id())).collect();
+ map.insert(a, p);
+ let snapshot = bad.clone();
+ assert!(bad.paste_nodes(&nodes, &map, f, p, None).is_err());
+ assert_eq!(bad, snapshot);
+ assert_eq!(bad.node(p).unwrap().name, snapshot.node(p).unwrap().name);
+ assert!(bad.validate().is_empty(), "{:?}", bad.validate());
+}
+
+#[test]
+fn hit_test_even_odd_vector_hole_misses() {
+ let ring = |rule| {
+ let sq = |o: f64, s: f64, base: usize| {
+ (
+ [(o, o), (o + s, o), (o + s, o + s), (o, o + s)].map(|(x, y)| Vertex::new(x, y)),
+ [Segment::line(base, base + 1), Segment::line(base + 1, base + 2), Segment::line(base + 2, base + 3), Segment::line(base + 3, base)],
+ )
+ };
+ let (v1, s1) = sq(0.0, 200.0, 0);
+ let (v2, s2) = sq(60.0, 80.0, 4);
+ VectorNetwork {
+ vertices: v1.into_iter().chain(v2).collect(),
+ segments: s1.into_iter().chain(s2).collect(),
+ regions: vec![Region { loops: vec![vec![0, 1, 2, 3], vec![4, 5, 6, 7]], winding: rule }],
+ }
+ };
+ let mut d = Document::new("x");
+ let p = page(&d);
+ let eo = d.create(p, NodeKind::Vector { network: ring(WindingRule::EvenOdd) }, "V", 0.0, 0.0, 200.0, 200.0).unwrap();
+ assert_eq!(d.hit_test(p, Point::new(20.0, 100.0), 0.0, None), Some(eo));
+ assert_eq!(d.hit_test(p, Point::new(100.0, 100.0), 0.0, None), None, "the hole is not filled");
+ let mut d = Document::new("x");
+ let p = page(&d);
+ let nz = d.create(p, NodeKind::Vector { network: ring(WindingRule::NonZero) }, "V", 0.0, 0.0, 200.0, 200.0).unwrap();
+ assert_eq!(d.hit_test(p, Point::new(100.0, 100.0), 0.0, None), Some(nz));
+}
+
+#[test]
+fn is_ancestor_holds_for_very_deep_chains() {
+ let mut d = Document::new("x");
+ let root = d.create(page(&d), NodeKind::Frame, "root", 0.0, 0.0, 1.0, 1.0).unwrap();
+ let mut leaf = root;
+ for _ in 0..10_005 {
+ leaf = d.create(leaf, NodeKind::Frame, "n", 0.0, 0.0, 1.0, 1.0).unwrap();
+ }
+ assert!(d.is_ancestor(root, leaf));
+ assert!(matches!(d.reparent(root, leaf, None), Err(DocError::Cycle(..))));
+}
diff --git a/crates/doc/src/text.rs b/crates/doc/src/text.rs
index 097dd189..458426ad 100644
--- a/crates/doc/src/text.rs
+++ b/crates/doc/src/text.rs
@@ -60,6 +60,9 @@ impl LetterSpacing {
}
pub fn trim_num(v: f64) -> String {
+ if v.abs() >= 9.0e18 {
+ return format!("{v}");
+ }
let r = (v * 100.0).round() / 100.0;
if r.fract().abs() < 1e-9 { format!("{}", r as i64) } else { format!("{r}") }
}
@@ -760,6 +763,15 @@ impl TextData {
mod case_tests {
use super::*;
+ #[test]
+ fn trim_num_prints_huge_whole_numbers() {
+ assert_eq!(trim_num(1e19), "10000000000000000000");
+ assert_eq!(trim_num(-1e19), "-10000000000000000000");
+ assert_eq!(trim_num(12.0), "12");
+ let v = 12345678901234567890.0_f64;
+ assert_eq!(trim_num(v).parse::().unwrap(), v);
+ }
+
#[test]
fn title_case_respects_context() {
assert_eq!(TextCase::Title.apply("hello wORLD don't 3d x-ray"), "Hello WORLD Don't 3d X-Ray");
diff --git a/crates/engine/src/a11y_keys_tests.rs b/crates/engine/src/a11y_keys_tests.rs
index 6687886c..e4892bca 100644
--- a/crates/engine/src/a11y_keys_tests.rs
+++ b/crates/engine/src/a11y_keys_tests.rs
@@ -55,3 +55,51 @@ fn reduce_motion_is_a_preference_that_persists() {
let old: crate::Prefs = serde_json::from_value(json!({"theme": "dark"})).unwrap();
assert!(!old.reduce_motion);
}
+
+#[test]
+fn interface_size_is_relative_to_the_system_and_persists() {
+ let mut s = Session::new();
+ assert_eq!(s.prefs.ui_scale, 1.0, "the system's own size by default");
+ assert_eq!(s.execute("pref.uiScale", &json!({})).unwrap()["scale"], 1.0);
+ assert_eq!(s.execute("pref.uiScale", &json!({"scale": 1.25})).unwrap()["scale"], 1.25);
+ assert_eq!(s.prefs.ui_scale, 1.25);
+ // Reading changes nothing; "auto" (older scripts) is the system's own size.
+ assert_eq!(s.execute("pref.uiScale", &json!({})).unwrap()["scale"], 1.25);
+ assert_eq!(s.execute("pref.uiScale", &json!({"scale": "Auto"})).unwrap()["scale"], 1.0);
+ // Nothing to undo: the document didn't change.
+ assert!(!s.ds().map(|d| d.is_dirty()).unwrap_or(false));
+ // Saved with the other preferences and read back.
+ s.prefs.ui_scale = 0.9;
+ let v = serde_json::to_value(&s.prefs).unwrap();
+ assert_eq!(v["ui_scale"], 0.9);
+ let back: crate::Prefs = serde_json::from_value(v).unwrap();
+ assert_eq!(back.ui_scale, 0.9);
+}
+
+#[test]
+fn interface_size_stops_at_the_ends_and_junk_never_changes_it() {
+ let mut s = Session::new();
+ assert_eq!(s.execute("pref.uiScale", &json!({"scale": 0.01})).unwrap()["scale"], crate::UI_SCALE_MIN);
+ assert_eq!(s.execute("pref.uiScale", &json!({"scale": -4})).unwrap()["scale"], crate::UI_SCALE_MIN);
+ assert_eq!(s.execute("pref.uiScale", &json!({"scale": 1e308})).unwrap()["scale"], crate::UI_SCALE_MAX);
+ // The size is a factor (1.25), not a percentage: 125 is far past the end and stops there.
+ assert_eq!(s.execute("pref.uiScale", &json!({"scale": 125})).unwrap()["scale"], crate::UI_SCALE_MAX);
+ s.prefs.ui_scale = 1.5;
+ for junk in [json!({"scale": "NaN"}), json!({"scale": "big"}), json!({"scale": [1]}), json!({"scale": {"x": 1}})] {
+ assert!(s.execute("pref.uiScale", &junk).is_err(), "{junk}");
+ assert_eq!(s.prefs.ui_scale, 1.5, "{junk}");
+ }
+}
+
+#[test]
+fn a_settings_file_without_or_with_a_wrong_interface_size_reads_as_the_systems_size_and_keeps_the_rest() {
+ let old: crate::Prefs = serde_json::from_value(json!({"theme": "dark"})).unwrap();
+ assert_eq!(old.ui_scale, 1.0);
+ for bad in [json!("big"), json!(null), json!([2]), json!(true)] {
+ let p: crate::Prefs = serde_json::from_value(json!({"theme": "dark", "ui_scale": bad})).unwrap();
+ assert_eq!((p.ui_scale, p.theme.as_str()), (1.0, "dark"), "{bad}");
+ }
+ // A number out of range is clamped rather than refused.
+ let p: crate::Prefs = serde_json::from_value(json!({"ui_scale": 99, "theme": "dark"})).unwrap();
+ assert_eq!((p.ui_scale, p.theme.as_str()), (crate::UI_SCALE_MAX, "dark"));
+}
diff --git a/crates/engine/src/annotations_tests.rs b/crates/engine/src/annotations_tests.rs
index 7fc7376f..00065049 100644
--- a/crates/engine/src/annotations_tests.rs
+++ b/crates/engine/src/annotations_tests.rs
@@ -171,7 +171,7 @@ fn ready_for_dev_lists_frames_by_status() {
};
let ready = ex(&mut s, "inspect.readyForDev", json!({}));
assert_eq!(names(&ready), vec!["Login", "Onboarding", "Profile"], "every page, page and layer order");
- assert_eq!(ready["items"][0], json!({"id": a.0, "name": "Login", "page": page.0, "status": "readyForDev"}));
+ assert_eq!(ready["items"][0], json!({"id": a.0, "name": "Login", "page": page.0, "status": "readyForDev", "changed": false}));
assert_eq!(names(&ex(&mut s, "inspect.readyForDev", json!({"status": "completed"}))), vec!["Signup"]);
assert_eq!(names(&ex(&mut s, "inspect.readyForDev", json!({"status": "any", "page": page}))), vec!["Login", "Signup", "Onboarding"]);
assert!(s.execute("inspect.readyForDev", &json!({"status": "none"})).is_err());
diff --git a/crates/engine/src/binding_lists_tests.rs b/crates/engine/src/binding_lists_tests.rs
index 493c8f60..8b221efd 100644
--- a/crates/engine/src/binding_lists_tests.rs
+++ b/crates/engine/src/binding_lists_tests.rs
@@ -97,3 +97,77 @@ fn effect_moves_and_removals_reject_junk() {
ex(&mut s, "effect.remove", json!({"ids": [r], "index": 7}));
assert_eq!(s.doc().unwrap().node(r).unwrap().effects.len(), 1);
}
+
+fn fill_hex(s: &Session, r: NodeId) -> Vec {
+ s.doc().unwrap().node(r).unwrap().fills.iter().filter_map(|p| p.solid_color()).map(|c| c.to_hex()).collect()
+}
+
+fn brand_id(s: &Session) -> String {
+ s.doc().unwrap().variables.get("brand").unwrap().id.clone()
+}
+
+#[test]
+fn explicit_paint_edits_detach_the_colour_binding() {
+ // An edit that reported success keeps its colour: the binding it overwrote lets go (as
+ // selection colours already do), instead of putting the variable's colour back.
+ let edits = [
+ ("fill.set", json!({"color": "#00FF00"})),
+ ("node.set", json!({"props": {"fill": "#00FF00"}})),
+ ("node.set", json!({"props": {"fills": ["#00FF00"]}})),
+ ];
+ for (cmd, mut p) in edits {
+ let (mut s, r) = setup();
+ ex(&mut s, "variable.bind", json!({"ids": [r], "field": "fill", "variable": "brand"}));
+ p["ids"] = json!([r]);
+ ex(&mut s, cmd, p.clone());
+ assert_eq!(fill_hex(&s, r), ["00FF00"], "{cmd} {p}");
+ assert!(bound(&s, r).is_empty(), "{cmd} {p}");
+ ex(&mut s, "variable.set", json!({"variable": "brand", "value": "#123456"}));
+ assert_eq!(fill_hex(&s, r), ["00FF00"], "{cmd} {p}: no longer follows the variable");
+ }
+ for (cmd, mut p) in [("stroke.set", json!({"color": "#00FF00"})), ("node.set", json!({"props": {"stroke": "#00FF00"}}))] {
+ let (mut s, r) = setup();
+ ex(&mut s, "node.set", json!({"ids": [r], "props": {"strokes": ["#000000"]}}));
+ ex(&mut s, "variable.bind", json!({"ids": [r], "field": "stroke", "variable": "brand"}));
+ p["ids"] = json!([r]);
+ ex(&mut s, cmd, p);
+ let n = s.doc().unwrap().node(r).unwrap();
+ assert_eq!(n.strokes[0].solid_color().map(|c| c.to_hex()).as_deref(), Some("00FF00"), "{cmd}");
+ assert!(n.bound.is_empty(), "{cmd}");
+ }
+}
+
+#[test]
+fn clearing_bound_fills_adds_no_paint_back() {
+ let (mut s, r) = setup();
+ ex(&mut s, "variable.bind", json!({"ids": [r], "field": "fill", "variable": "brand"}));
+ ex(&mut s, "node.set", json!({"ids": [r], "props": {"fills": []}}));
+ assert!(s.doc().unwrap().node(r).unwrap().fills.is_empty());
+ assert!(bound(&s, r).is_empty());
+ ex(&mut s, "variable.set", json!({"variable": "brand", "value": "#123456"}));
+ assert!(s.doc().unwrap().node(r).unwrap().fills.is_empty(), "the variable doesn't bring the fill back");
+}
+
+#[test]
+fn paint_opacity_edits_keep_the_colour_binding() {
+ let (mut s, r) = setup();
+ ex(&mut s, "variable.bind", json!({"ids": [r], "field": "fill", "variable": "brand"}));
+ ex(&mut s, "fill.set", json!({"ids": [r], "opacity": 0.5}));
+ ex(&mut s, "variable.set", json!({"variable": "brand", "value": "#0000FF"}));
+ assert_eq!(fill_hex(&s, r), ["0000FF"], "the colour still follows the variable");
+ assert_eq!(s.doc().unwrap().node(r).unwrap().fills[0].opacity, 0.5);
+ // The same colour with another opacity, through node.set, keeps it too.
+ ex(&mut s, "node.set", json!({"ids": [r], "props": {"fills": [{"type": "solid", "color": "#0000FF", "opacity": 0.25}]}}));
+ assert_eq!(bound(&s, r).len(), 1);
+ assert_eq!(s.doc().unwrap().node(r).unwrap().fills[0].opacity, 0.25);
+}
+
+#[test]
+fn paints_set_with_their_binding_in_the_same_call_keep_it() {
+ let (mut s, r) = setup();
+ ex(&mut s, "variable.bind", json!({"ids": [r], "field": "fill", "variable": "brand"}));
+ let brand = brand_id(&s);
+ ex(&mut s, "node.set", json!({"ids": [r], "props": {"fills": ["#00FF00"], "boundVariables": {"fill": brand}}}));
+ assert_eq!(bound(&s, r), [("fill".to_string(), brand)]);
+ assert_eq!(fill_hex(&s, r), ["FF0000"], "the binding given with the paints applies");
+}
diff --git a/crates/engine/src/board.rs b/crates/engine/src/board.rs
new file mode 100644
index 00000000..317b0889
--- /dev/null
+++ b/crates/engine/src/board.rs
@@ -0,0 +1,1307 @@
+//! Boards: files for thinking together, with sticky notes, shapes with text, connectors, ink and
+//! stamps. Board objects are ordinary layers with a [`BoardItem`] on them; [`settle_text`] and
+//! [`settle_routes`] keep what follows from it (a sticky's text size, a shape's text room,
+//! connectors' routes and their labels) up to date in the normalize pass, so local edits, undo and
+//! live-session edits from others all end in the same geometry.
+
+use std::collections::{BTreeMap, BTreeSet};
+
+use figcraft_color::{BlendMode, Color, Paint};
+use figcraft_doc::{
+ AutoLayout, BOARD_COLORS, BoardItem, BoardShape, Connector, Constraints, CrossAlign, DocError, Document, Effect, EffectKind, End, FileKind,
+ HConstraint, LayoutMode, MainAlign, Node, NodeId, NodeKind, Routing, STAMP_SIZE, Shadow, Side, Sizing, Stamp, StrokeAlign, StrokeCap, StrokeJoin,
+ TextAlignH, TextAutoResize, TextData, VConstraint, VectorNetwork, board_color,
+};
+use figcraft_geom::{Affine, Point, Rect};
+use serde_json::{Value, json};
+
+use crate::cmd::CommandSpec;
+use crate::params::{boolean, color_of, get, id, id_of, num, num_or, opt_id, req_num, req_string, req_targets, string};
+use crate::tools::{Gesture, PointerEvent, ToolId};
+use crate::{EngineError, Result, Session, bad, spec, textedit};
+
+/// Why a board command refuses on a design file.
+pub const NEEDS_BOARD: &str = "this is for boards: make one with File ▸ New board";
+/// Why prototyping and Dev Mode refuse on a board.
+pub const NOT_ON_BOARDS: &str = "boards have no prototypes or Dev Mode: use a design file for those";
+
+/// A sticky note's side (it grows taller for long notes).
+pub const STICKY: f64 = 200.0;
+const STICKY_PAD: f64 = 16.0;
+/// The room between a sticky and the next one made beside it.
+const STICKY_GAP: f64 = 24.0;
+/// A new shape's size.
+const SHAPE: f64 = 160.0;
+/// Text on board objects, and the author line under a sticky's note.
+const INK: Color = Color::from_rgb8_const(0x1E, 0x1E, 0x1E);
+const AUTHOR_INK: Color = Color::from_rgb8_const(0x5C, 0x5A, 0x55);
+/// Connectors' default colour and weight.
+const LINE: Color = Color::from_rgb8_const(0x3A, 0x39, 0x36);
+const LINE_WEIGHT: f64 = 2.0;
+/// Marker and highlighter strokes: (weight, opacity).
+const MARKER: (f64, f32) = (4.0, 1.0);
+const HIGHLIGHTER: (f64, f32) = (20.0, 0.45);
+/// How far the eraser reaches around the pointer (screen pixels).
+const ERASER_PX: f64 = 8.0;
+/// The text sizes the contextual bar offers.
+pub const TEXT_SIZES: [(&str, f64); 4] = [("S", 12.0), ("M", 16.0), ("L", 24.0), ("XL", 36.0)];
+
+/// The board tools' choices: the colour new stickies get, the shape and stamp the tools place,
+/// how new connectors run and the marker's and highlighter's colours.
+#[derive(Clone, Debug)]
+pub struct BoardTool {
+ pub sticky: Color,
+ pub shape: BoardShape,
+ pub stamp: Stamp,
+ pub routing: Routing,
+ pub marker: Color,
+ pub highlighter: Color,
+}
+
+impl Default for BoardTool {
+ fn default() -> Self {
+ let first = BOARD_COLORS.first().map_or(Color::WHITE, |c| c.1);
+ Self {
+ sticky: first,
+ shape: BoardShape::Rectangle,
+ stamp: Stamp::ThumbsUp,
+ routing: Routing::Elbow,
+ marker: INK,
+ highlighter: Color::from_rgb8_const(0xFF, 0xD2, 0x1F),
+ }
+ }
+}
+
+pub fn specs() -> Vec {
+ vec![
+ spec!(
+ "board.sticky",
+ "Sticky note",
+ "{x, y (its top-left, in the parent), text?, color? (yellow|orange|red|pink|violet|blue|green|gray or hex; default the sticky tool's), author? (a name, or false for none; default yours), parent?} → {id, text}",
+ true,
+ sticky_cmd
+ ),
+ spec!(
+ "board.nextSticky",
+ "Next sticky note",
+ "{id? (a sticky; default the selected or edited one), side?: right|below|left|above (default right), edit? (start typing in it; default false)} → {id, text} a sticky of the same colour beside it",
+ true,
+ next_sticky
+ ),
+ spec!(
+ "board.shape",
+ "Shape with text",
+ "{shape: rectangle|roundedRectangle|ellipse|diamond|triangle|speechBubble|chevron, x, y, width?, height? (default 160), text?, color?, parent?} → {id, text}",
+ true,
+ shape_cmd
+ ),
+ spec!(
+ "board.connector",
+ "Connector",
+ "{from, to (each a layer id or {x, y} on the page), fromSide?, toSide? (auto|top|right|bottom|left), style?: straight|elbow, startCap?, endCap? (none|lineArrow|triangleArrow|circleFilled|diamondFilled…; default an arrow at the end), label?} → {id, label?} a line that follows the layers it joins",
+ true,
+ connector_cmd
+ ),
+ spec!("board.label", "Connector label", "{id (a connector; default the selection), text (empty removes it)} → {id, label}", true, label_cmd),
+ spec!(
+ "board.stamp",
+ "Stamp",
+ "{x, y (its centre on the page), stamp: thumbsUp|heart|plusOne|star|question|check} → {id} a badge with your name on hover",
+ true,
+ stamp_cmd
+ ),
+ spec!(
+ "board.ink",
+ "Marker stroke",
+ "{path (SVG path data on the page) | points [[x,y],..], highlighter? (wide and see-through), color?, select? (default true)} → {id}",
+ true,
+ ink_cmd
+ ),
+ spec!(
+ "board.setColor",
+ "Board color",
+ "{ids?, color (a board colour name or hex)} stickies and shapes take it as their fill, connectors and ink as their line",
+ true,
+ set_color
+ ),
+ spec!(
+ "board.setStyle",
+ "Board style",
+ "{ids?, shape? (shapes with text), fontSize? (their text), style?: straight|elbow, startCap?, endCap? (connectors)}",
+ true,
+ set_style
+ ),
+ spec!("tool.sticky", "Sticky note", "{color?} (a click places a sticky and starts typing in it)", false, |s, p| {
+ if let Some(c) = color_param("tool.sticky", p)? {
+ s.tool.board.sticky = c;
+ }
+ board_tool(s, ToolId::Sticky)
+ }),
+ spec!("tool.shape", "Shapes", "{shape?} (a click places a shape with text)", false, |s, p| {
+ if let Some(v) = string(p, "shape") {
+ s.tool.board.shape = shape_of("tool.shape", &v)?;
+ }
+ board_tool(s, ToolId::BoardShape)
+ }),
+ spec!("tool.connector", "Connector", "{style?: straight|elbow} (drag from one object to another)", false, |s, p| {
+ if let Some(v) = string(p, "style") {
+ s.tool.board.routing = routing_of("tool.connector", &v)?;
+ }
+ board_tool(s, ToolId::Connector)
+ }),
+ spec!("tool.marker", "Marker", "{color?}", false, |s, p| {
+ if let Some(c) = color_param("tool.marker", p)? {
+ s.tool.board.marker = c;
+ }
+ board_tool(s, ToolId::Marker)
+ }),
+ spec!("tool.highlighter", "Highlighter", "{color?}", false, |s, p| {
+ if let Some(c) = color_param("tool.highlighter", p)? {
+ s.tool.board.highlighter = c;
+ }
+ board_tool(s, ToolId::Highlighter)
+ }),
+ spec!("tool.eraser", "Eraser", "{} (drag over marker and highlighter strokes to remove them)", false, |s, _| board_tool(s, ToolId::Eraser)),
+ spec!("tool.stamp", "Stamp", "{stamp?} (a click places the stamp)", false, |s, p| {
+ if let Some(v) = string(p, "stamp") {
+ s.tool.board.stamp = stamp_of("tool.stamp", &v)?;
+ }
+ board_tool(s, ToolId::Stamp)
+ }),
+ ]
+}
+
+pub fn is_board(doc: &Document) -> bool {
+ doc.kind == FileKind::Board
+}
+
+/// Refuse `cmd` unless the active file is a board.
+pub(crate) fn require(s: &Session, cmd: &str) -> Result<()> {
+ if s.doc().is_ok_and(is_board) { Ok(()) } else { Err(EngineError::Disabled(cmd.into(), NEEDS_BOARD.into())) }
+}
+
+/// Prototyping and Dev Mode: not on boards.
+fn design_only(cmd: &str) -> bool {
+ cmd.starts_with("proto.") || cmd.starts_with("dev.") || matches!(cmd, "view.prototype" | "view.designPrototype" | "view.devMode")
+}
+
+/// Refuse `cmd` on a board when it is prototyping or Dev Mode.
+pub(crate) fn refuse_on_board(s: &Session, cmd: &str) -> Result<()> {
+ if design_only(cmd) && s.doc().is_ok_and(is_board) { Err(EngineError::Disabled(cmd.into(), NOT_ON_BOARDS.into())) } else { Ok(()) }
+}
+
+fn board_tool(s: &mut Session, t: ToolId) -> Result {
+ require(s, &format!("tool.{}", t.id()))?;
+ crate::cmd::view::tool(s, t)
+}
+
+fn shape_of(cmd: &str, v: &str) -> Result {
+ BoardShape::from_id(v)
+ .ok_or_else(|| bad(cmd, format!("unknown shape `{v}` (rectangle|roundedRectangle|ellipse|diamond|triangle|speechBubble|chevron)")))
+}
+
+fn stamp_of(cmd: &str, v: &str) -> Result {
+ Stamp::from_id(v).ok_or_else(|| bad(cmd, format!("unknown stamp `{v}` (thumbsUp|heart|plusOne|star|question|check)")))
+}
+
+fn routing_of(cmd: &str, v: &str) -> Result {
+ Routing::from_id(v).ok_or_else(|| bad(cmd, format!("`style` is straight or elbow, not `{v}`")))
+}
+
+fn cap_of(cmd: &str, p: &Value, key: &str) -> Result> {
+ match get(p, key) {
+ None | Some(Value::Null) => Ok(None),
+ Some(v) => crate::cmd::props::enum_of::(v).map(Some).ok_or_else(|| bad(cmd, format!("`{key}`: unknown cap"))),
+ }
+}
+
+/// `color`: a board colour's name, or any colour.
+fn color_param(cmd: &str, p: &Value) -> Result> {
+ match get(p, "color") {
+ None | Some(Value::Null) => Ok(None),
+ Some(Value::String(s)) if board_color(s).is_some() => Ok(board_color(s)),
+ Some(v) => color_of(v).map(Some).ok_or_else(|| bad(cmd, "`color` is a board colour (yellow, blue…) or a colour such as #FFE78A")),
+ }
+}
+
+/// The deeper shade of a board colour lines are drawn in (light tints are too faint as lines).
+fn line_shade(c: Color) -> Color {
+ let palette = BOARD_COLORS.iter().any(|(_, b)| *b == c);
+ if palette { Color::new(c.r * 0.55, c.g * 0.55, c.b * 0.55, c.a) } else { c }
+}
+
+/// Your name on what you make: the name from Preferences, else the one a live session gave you
+/// (none for the default name outside a session).
+fn author(s: &Session) -> String {
+ let name = crate::live::display_name(&s.prefs);
+ if name.is_empty() { s.live().info.as_ref().map(|i| i.name.clone()).unwrap_or_default() } else { name }
+}
+
+/// The parent a command places into, and that parent's page-to-local transform.
+fn parent_of(cmd: &str, s: &Session, p: &Value) -> Result {
+ let page = s.page()?;
+ let parent = opt_id(cmd, p, "parent")?.unwrap_or(page);
+ let doc = s.doc()?;
+ let n = doc.get(parent)?;
+ let takes = n.is_page() || matches!(n.kind, NodeKind::Section { .. }) || (n.kind.is_frame_like() && !n.is_board_atom());
+ if !takes {
+ return Err(bad(cmd, "`parent` is the page, a section or a frame"));
+ }
+ Ok(parent)
+}
+
+/// A new layer at the top of `parent`, at `at` in it, made by `f`.
+fn add(
+ doc: &mut Document,
+ parent: NodeId,
+ kind: NodeKind,
+ name: &str,
+ at: (f64, f64),
+ size: (f64, f64),
+ f: impl FnOnce(&mut Node),
+) -> Result {
+ let id = doc.alloc_id();
+ let mut n = Node::new(id, kind, name, size.0, size.1);
+ n.transform = Affine::translate(at);
+ f(&mut n);
+ doc.insert(n, parent, None)?;
+ Ok(id)
+}
+
+/// A soft shadow under stickies and stamps.
+fn soft_shadow() -> Effect {
+ Effect {
+ kind: EffectKind::DropShadow(Shadow { color: Color::new(0.0, 0.0, 0.0, 0.16), offset: (0.0, 2.0), radius: 6.0, ..Shadow::default() }),
+ visible: true,
+ }
+}
+
+/// A text layer filling its frame's width (the frame's auto layout places it).
+fn add_text(doc: &mut Document, parent: NodeId, text: &str, size: f64, color: Color, align: TextAlignH, width: f64) -> Result {
+ let first: String = text.lines().next().unwrap_or("").chars().take(64).collect();
+ let name = if first.trim().is_empty() { "Text" } else { first.as_str() };
+ let mut td = TextData {
+ characters: crate::cmd::props::normalize_line_endings(text),
+ auto_resize: TextAutoResize::Height,
+ align_h: align,
+ ..TextData::default()
+ };
+ td.style.font_size = size;
+ let id = add(doc, parent, NodeKind::Text(td), name, (0.0, 0.0), (width.max(1.0), size * 1.4), |n| {
+ n.fills = vec![Paint::solid(color)];
+ n.child_layout.sizing_h = Sizing::Fill;
+ })?;
+ if let Some(n) = doc.node(id)
+ && let Some((w, h)) = figcraft_text::auto_size(n)
+ && let Some(n) = doc.node_mut(id)
+ {
+ (n.width, n.height) = (w, h);
+ }
+ 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,
+ }
+}
+
+/// 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)> {
+ let id = add(doc, parent, NodeKind::Frame, "Sticky", at, (STICKY, STICKY), |n| {
+ n.fills = vec![Paint::solid(color)];
+ n.corners.radii = [2.0; 4];
+ n.effects = vec![soft_shadow()];
+ n.clip = false;
+ n.layout = Some(AutoLayout {
+ mode: LayoutMode::Vertical,
+ gap: 8.0,
+ padding: [STICKY_PAD; 4],
+ main_align: MainAlign::SpaceBetween,
+ ..AutoLayout::default()
+ });
+ n.child_layout.sizing_v = Sizing::Hug;
+ n.child_layout.min_h = Some(STICKY);
+ 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)?;
+ 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) {
+ n.name = "Author".into();
+ }
+ }
+ Ok((id, note))
+}
+
+fn sticky_cmd(s: &mut Session, p: &Value) -> Result {
+ let cmd = "board.sticky";
+ require(s, cmd)?;
+ let color = color_param(cmd, p)?.unwrap_or(s.tool.board.sticky);
+ let author = match get(p, "author") {
+ Some(Value::String(a)) => a.trim().chars().filter(|c| !c.is_control()).take(64).collect(),
+ Some(Value::Bool(false)) => String::new(),
+ _ => author(s),
+ };
+ let parent = parent_of(cmd, s, p)?;
+ let text = string(p, "text").unwrap_or_default();
+ let at = (num_or(p, "x", 0.0), num_or(p, "y", 0.0));
+ let (id, note) = make_sticky(s.doc_mut()?, parent, at, &text, color, &author)?;
+ s.set_selection(vec![id]);
+ Ok(json!({"id": id, "text": note}))
+}
+
+/// The first text layer inside board object `id` (its note or label).
+pub fn text_of(doc: &Document, id: NodeId) -> Option {
+ let n = doc.node(id)?;
+ n.board.as_ref().filter(|b| b.has_text())?;
+ n.children.iter().copied().find(|c| doc.node(*c).is_some_and(|k| matches!(k.kind, NodeKind::Text(_))))
+}
+
+/// The board object whose text `text` is, if any.
+pub fn owner_of_text(doc: &Document, text: NodeId) -> Option {
+ let p = doc.node(text)?.parent?;
+ (text_of(doc, p) == Some(text)).then_some(p)
+}
+
+/// Start typing in board object `id`'s text (all of it selected). False when it has none.
+pub fn edit_text(s: &mut Session, id: NodeId) -> Result {
+ let Some(t) = s.doc().ok().and_then(|d| text_of(d, id)) else { return Ok(false) };
+ textedit::begin(s, t, None, false)?;
+ textedit::key(s, "SelectAll", false, false, false)?;
+ Ok(true)
+}
+
+fn next_sticky(s: &mut Session, p: &Value) -> Result {
+ let cmd = "board.nextSticky";
+ 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 sticky first".into()))?;
+ let n = doc.get(from)?;
+ if !matches!(n.board, Some(BoardItem::Sticky { .. })) {
+ return Err(bad(cmd, "that isn't a sticky"));
+ }
+ let color = n.fills.iter().find_map(Paint::solid_color).unwrap_or(s.tool.board.sticky);
+ let parent = n.parent.ok_or_else(|| bad(cmd, "that sticky has no parent"))?;
+ let at = n.transform.translation();
+ let (dx, dy) = match string(p, "side").as_deref().unwrap_or("right") {
+ "right" => (n.width + STICKY_GAP, 0.0),
+ "left" => (-(STICKY + STICKY_GAP), 0.0),
+ "below" => (0.0, n.height + STICKY_GAP),
+ "above" => (0.0, -(STICKY + STICKY_GAP)),
+ other => return Err(bad(cmd, format!("`side` is right, below, left or above, not `{other}`"))),
+ };
+ let author = author(s);
+ if editing.is_some() {
+ textedit::end(s)?;
+ }
+ let (id, note) = make_sticky(s.doc_mut()?, parent, (at.x + dx, at.y + dy), "", color, &author)?;
+ s.set_selection(vec![id]);
+ if boolean(p, "edit") == Some(true) {
+ // Typing goes on in the new sticky once this step is recorded.
+ s.request_ui("board.editText", json!({"id": id}));
+ }
+ Ok(json!({"id": id, "text": note}))
+}
+
+/// A shape with text's layers: the frame, its outline and its text.
+fn make_shape(
+ doc: &mut Document,
+ parent: NodeId,
+ at: (f64, f64),
+ size: (f64, f64),
+ shape: BoardShape,
+ text: &str,
+ color: Color,
+) -> Result<(NodeId, NodeId)> {
+ let (w, h) = size;
+ let id = add(doc, parent, NodeKind::Frame, shape.label(), at, size, |n| {
+ n.fills.clear();
+ n.clip = false;
+ n.layout = Some(AutoLayout {
+ mode: LayoutMode::Vertical,
+ padding: shape_padding(shape, w, h),
+ main_align: MainAlign::Center,
+ cross_align: CrossAlign::Center,
+ ..AutoLayout::default()
+ });
+ n.board = Some(BoardItem::Shape { shape });
+ })?;
+ add(doc, id, NodeKind::Vector { network: VectorNetwork::from_path(&shape.path(w, h)) }, "Outline", (0.0, 0.0), size, |n| {
+ n.fills = vec![Paint::solid(color)];
+ n.strokes = vec![Paint::solid(line_shade(color))];
+ n.stroke.weight = 1.5;
+ n.stroke.align = StrokeAlign::Inside;
+ n.child_layout.absolute = true;
+ n.constraints = Constraints { horizontal: HConstraint::Scale, vertical: VConstraint::Scale };
+ })?;
+ let [_, r, _, l] = shape_padding(shape, w, h);
+ let label = add_text(doc, id, text, 16.0, INK, TextAlignH::Center, (w - l - r).max(1.0))?;
+ Ok((id, label))
+}
+
+fn shape_padding(shape: BoardShape, w: f64, h: f64) -> [f64; 4] {
+ let [t, r, b, l] = shape.text_insets();
+ [t * h, r * w, b * h, l * w]
+}
+
+fn shape_cmd(s: &mut Session, p: &Value) -> Result {
+ let cmd = "board.shape";
+ require(s, cmd)?;
+ let shape = match string(p, "shape") {
+ Some(v) => shape_of(cmd, &v)?,
+ None => s.tool.board.shape,
+ };
+ let size = |k| {
+ num(p, k)
+ .map_or(Ok(SHAPE), |v| if (1.0..=100_000.0).contains(&v) { Ok(v) } else { Err(bad(cmd, format!("`{k}` is a size from 1 to 100000"))) })
+ };
+ let (w, h) = (size("width")?, size("height")?);
+ let color = color_param(cmd, p)?.unwrap_or(s.tool.board.sticky);
+ let parent = parent_of(cmd, s, p)?;
+ let text = string(p, "text").unwrap_or_default();
+ let at = (num_or(p, "x", 0.0), num_or(p, "y", 0.0));
+ let (id, label) = make_shape(s.doc_mut()?, parent, at, (w, h), shape, &text, color)?;
+ s.set_selection(vec![id]);
+ Ok(json!({"id": id, "text": label}))
+}
+
+fn stamp_cmd(s: &mut Session, p: &Value) -> Result {
+ let cmd = "board.stamp";
+ require(s, cmd)?;
+ let stamp = match string(p, "stamp") {
+ Some(v) => stamp_of(cmd, &v)?,
+ None => s.tool.board.stamp,
+ };
+ let (x, y) = (req_num(cmd, p, "x")?, req_num(cmd, p, "y")?);
+ let author = author(s);
+ let page = s.page()?;
+ let half = STAMP_SIZE / 2.0;
+ let doc = s.doc_mut()?;
+ let id = add(doc, page, NodeKind::Frame, stamp.label(), (x - half, y - half), (STAMP_SIZE, STAMP_SIZE), |n| {
+ n.fills = vec![Paint::solid(stamp.color())];
+ n.corners.radii = [half; 4];
+ n.effects = vec![soft_shadow()];
+ n.clip = false;
+ n.board = Some(BoardItem::Stamp { stamp, author });
+ })?;
+ for part in stamp.mark() {
+ let path = figcraft_geom::BezPath::from_svg(part.d).map_err(|e| EngineError::Other(format!("stamp mark: {e}")))?;
+ add(doc, id, NodeKind::Vector { network: VectorNetwork::from_path(&path) }, "Mark", (0.0, 0.0), (STAMP_SIZE, STAMP_SIZE), |n| {
+ if part.filled {
+ n.fills = vec![Paint::solid(Color::WHITE)];
+ } else {
+ n.fills.clear();
+ n.strokes = vec![Paint::solid(Color::WHITE)];
+ n.stroke.weight = 3.0;
+ (n.stroke.cap_start, n.stroke.cap_end) = (StrokeCap::Round, StrokeCap::Round);
+ n.stroke.join = StrokeJoin::Round;
+ n.stroke.align = StrokeAlign::Center;
+ }
+ })?;
+ }
+ s.set_selection(vec![id]);
+ Ok(json!({"id": id}))
+}
+
+fn ink_cmd(s: &mut Session, p: &Value) -> Result {
+ let cmd = "board.ink";
+ require(s, cmd)?;
+ let high = boolean(p, "highlighter").unwrap_or(false);
+ let color = color_param(cmd, p)?.unwrap_or(if high { s.tool.board.highlighter } else { s.tool.board.marker });
+ let (weight, opacity) = if high { HIGHLIGHTER } else { MARKER };
+ if get(p, "path").is_none() && get(p, "points").is_none() {
+ return Err(bad(cmd, "`path` or `points` is required"));
+ }
+ let page = s.page()?;
+ let select = boolean(p, "select").unwrap_or(true);
+ let mut q = json!({"type": "vector", "parent": page, "closed": false, "select": select, "name": if high { "Highlight" } else { "Ink" }, "props": {
+ "fills": [], "strokes": [color.to_css_hex()], "strokeWeight": weight, "strokeCap": "round", "strokeJoin": "round", "strokeAlign": "center",
+ }});
+ for k in ["path", "points"] {
+ if let (Some(v), Some(o)) = (get(p, k), q.as_object_mut()) {
+ o.insert(k.into(), v.clone());
+ }
+ }
+ let made = crate::cmd::create::create(s, &q)?;
+ let id = made.get("id").and_then(id_of).ok_or_else(|| EngineError::Other("no stroke made".into()))?;
+ let n = s.doc_mut()?.get_mut(id)?;
+ n.opacity = opacity;
+ if high {
+ n.blend = BlendMode::Multiply;
+ }
+ n.board = Some(BoardItem::Ink);
+ Ok(json!({"id": id}))
+}
+
+/// One connector end from the params: a layer on this page, or a point.
+fn end_param(cmd: &str, s: &Session, p: &Value, key: &str, side_key: &str) -> Result {
+ let side = match string(p, side_key) {
+ Some(v) => Side::from_id(&v).ok_or_else(|| bad(cmd, format!("`{side_key}` is auto, top, right, bottom or left")))?,
+ None => Side::Auto,
+ };
+ match get(p, key) {
+ Some(Value::Object(o)) if o.contains_key("x") => {
+ let (x, y) = (num(&Value::Object(o.clone()), "x"), num(&Value::Object(o.clone()), "y"));
+ match (x, y) {
+ (Some(x), Some(y)) if x.is_finite() && y.is_finite() => Ok(End::Point { x, y }),
+ _ => Err(bad(cmd, format!("`{key}` needs finite x and y"))),
+ }
+ }
+ Some(v) => {
+ let node = id_of(v).ok_or_else(|| bad(cmd, format!("`{key}` is a layer id or {{x, y}}")))?;
+ let doc = s.doc()?;
+ let n = doc.get(node)?;
+ if n.is_page() || doc.page_of(node) != Some(s.page()?) {
+ return Err(bad(cmd, format!("`{key}` must be a layer on this page")));
+ }
+ if matches!(n.board, Some(BoardItem::Connector(_))) {
+ return Err(bad(cmd, format!("`{key}` can't be another connector")));
+ }
+ Ok(End::Node { node, side })
+ }
+ None => Err(bad(cmd, format!("`{key}` is required"))),
+ }
+}
+
+fn connector_cmd(s: &mut Session, p: &Value) -> Result {
+ let cmd = "board.connector";
+ require(s, cmd)?;
+ let from = end_param(cmd, s, p, "from", "fromSide")?;
+ let to = end_param(cmd, s, p, "to", "toSide")?;
+ if from.node().is_some() && from.node() == to.node() {
+ return Err(bad(cmd, "connect two different layers"));
+ }
+ let routing = match string(p, "style") {
+ Some(v) => routing_of(cmd, &v)?,
+ None => s.tool.board.routing,
+ };
+ let start = cap_of(cmd, p, "startCap")?.unwrap_or(StrokeCap::None);
+ let end = cap_of(cmd, p, "endCap")?.unwrap_or(StrokeCap::TriangleArrow);
+ let c = Connector { from, to, routing };
+ let page = s.page()?;
+ let doc = s.doc_mut()?;
+ let pts = route(doc, &c).ok_or_else(|| bad(cmd, "the ends can't be placed"))?;
+ if pts.windows(2).all(|w| w.first() == w.get(1)) {
+ return Err(bad(cmd, "the ends are in the same place"));
+ }
+ let id = add(doc, page, NodeKind::Vector { network: VectorNetwork::default() }, "Connector", (0.0, 0.0), (0.0, 0.0), |n| {
+ n.fills.clear();
+ n.strokes = vec![Paint::solid(LINE)];
+ n.stroke.weight = LINE_WEIGHT;
+ n.stroke.join = StrokeJoin::Round;
+ n.stroke.cap_start = start;
+ n.stroke.cap_end = end;
+ n.board = Some(BoardItem::Connector(c));
+ })?;
+ place_route(doc, id, &pts);
+ 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)?);
+ }
+ s.set_selection(vec![id]);
+ Ok(out)
+}
+
+/// The label of connector `id`, if it has one.
+pub fn label_of(doc: &Document, id: NodeId) -> Option {
+ let parent = doc.node(id)?.parent?;
+ doc.node(parent)?.children.iter().copied().find(|c| doc.node(*c).is_some_and(|n| n.board == Some(BoardItem::Label { connector: id })))
+}
+
+/// Give connector `id` the label `text` (empty removes it); the label's id.
+fn set_label(doc: &mut Document, id: NodeId, text: &str) -> Result> {
+ let existing = label_of(doc, id);
+ if text.trim().is_empty() {
+ if let Some(l) = existing {
+ doc.remove(l)?;
+ }
+ return Ok(None);
+ }
+ if let Some(l) = existing {
+ if let Some(t) = text_of(doc, l)
+ && let Some(NodeKind::Text(td)) = doc.node_mut(t).map(|n| &mut n.kind)
+ {
+ let len = td.char_count();
+ td.replace_range(0, len, text);
+ }
+ return Ok(Some(l));
+ }
+ let parent = doc.node(id).and_then(|n| n.parent).ok_or(DocError::NoNode(id))?;
+ let l = add(doc, parent, NodeKind::Frame, "Label", (0.0, 0.0), (40.0, 24.0), |n| {
+ n.fills = vec![Paint::solid(Color::WHITE)];
+ n.corners.radii = [4.0; 4];
+ n.clip = false;
+ n.layout = Some(AutoLayout { padding: [3.0, 6.0, 3.0, 6.0], ..AutoLayout::default() });
+ n.child_layout.sizing_h = Sizing::Hug;
+ n.child_layout.sizing_v = Sizing::Hug;
+ n.board = Some(BoardItem::Label { connector: id });
+ })?;
+ let t = add_text(doc, l, text, 12.0, INK, TextAlignH::Center, 40.0)?;
+ if let Some(n) = doc.node_mut(t)
+ && let NodeKind::Text(td) = &mut n.kind
+ {
+ // The label hugs its text: one line per paragraph.
+ td.auto_resize = TextAutoResize::WidthAndHeight;
+ n.child_layout.sizing_h = Sizing::Hug;
+ }
+ Ok(Some(l))
+}
+
+fn label_cmd(s: &mut Session, p: &Value) -> Result {
+ let cmd = "board.label";
+ require(s, cmd)?;
+ let id = req_targets(cmd, s, p)?.first().copied().ok_or_else(|| bad(cmd, "select a connector"))?;
+ let doc = s.doc()?;
+ let id = match doc.node(id).and_then(|n| n.board.clone()) {
+ Some(BoardItem::Connector(_)) => id,
+ Some(BoardItem::Label { connector }) => connector,
+ _ => return Err(bad(cmd, "that isn't a connector")),
+ };
+ let text = req_string(cmd, p, "text")?;
+ let label = set_label(s.doc_mut()?, id, &text)?;
+ Ok(json!({"id": id, "label": label}))
+}
+
+/// The board objects among `ids`, each with its item (a label counts as its connector's text).
+fn items(doc: &Document, ids: &[NodeId]) -> Vec<(NodeId, BoardItem)> {
+ ids.iter().filter_map(|i| doc.node(*i).and_then(|n| n.board.clone()).map(|b| (*i, b))).collect()
+}
+
+fn set_color(s: &mut Session, p: &Value) -> Result {
+ let cmd = "board.setColor";
+ require(s, cmd)?;
+ let ids = req_targets(cmd, s, p)?;
+ let color = color_param(cmd, p)?.ok_or_else(|| bad(cmd, "`color` is required"))?;
+ let doc = s.doc_mut()?;
+ let mut changed = Vec::new();
+ for (id, item) in items(doc, &ids) {
+ match item {
+ BoardItem::Sticky { .. } => doc.get_mut(id)?.fills = vec![Paint::solid(color)],
+ BoardItem::Shape { .. } => {
+ let Some(outline) = doc.get(id)?.children.first().copied() else { continue };
+ let n = doc.get_mut(outline)?;
+ n.fills = vec![Paint::solid(color)];
+ 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 { .. } => continue,
+ }
+ changed.push(id);
+ }
+ if changed.is_empty() {
+ return Err(bad(cmd, "select stickies, shapes, connectors or ink"));
+ }
+ Ok(json!({"ids": changed}))
+}
+
+/// What `board.setStyle` changes (each `None` leaves it).
+struct Restyle {
+ shape: Option,
+ routing: Option,
+ size: Option,
+ start: Option,
+ end: Option,
+}
+
+impl Restyle {
+ fn of(cmd: &str, p: &Value) -> Result {
+ let size = num(p, "fontSize")
+ .map(|v| if v.is_finite() && (1.0..=1000.0).contains(&v) { Ok(v) } else { Err(bad(cmd, "`fontSize` is from 1 to 1000")) })
+ .transpose()?;
+ Ok(Restyle {
+ shape: string(p, "shape").map(|v| shape_of(cmd, &v)).transpose()?,
+ routing: string(p, "style").map(|v| routing_of(cmd, &v)).transpose()?,
+ size,
+ start: cap_of(cmd, p, "startCap")?,
+ end: cap_of(cmd, p, "endCap")?,
+ })
+ }
+
+ /// Restyle board object `id` (`item`); whether anything about it changed.
+ fn apply(&self, doc: &mut Document, id: NodeId, item: BoardItem) -> Result {
+ let changed = match item {
+ BoardItem::Shape { shape } => match self.shape.filter(|n| *n != shape) {
+ Some(new) => {
+ reshape(doc, id, new)?;
+ true
+ }
+ None => false,
+ },
+ BoardItem::Connector(c) => self.restyle_connector(doc, id, c)?,
+ _ => false,
+ };
+ // 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),
+ _ => false,
+ };
+ Ok(changed || sized)
+ }
+
+ fn restyle_connector(&self, doc: &mut Document, id: NodeId, mut c: Connector) -> Result {
+ let n = doc.get_mut(id)?;
+ if let Some(r) = self.routing {
+ c.routing = r;
+ n.board = Some(BoardItem::Connector(c));
+ }
+ if let Some(cap) = self.start {
+ n.stroke.cap_start = cap;
+ }
+ if let Some(cap) = self.end {
+ n.stroke.cap_end = cap;
+ }
+ Ok(self.routing.is_some() || self.start.is_some() || self.end.is_some())
+ }
+}
+
+/// Shape with text `id` takes outline `new` (its text room too).
+fn reshape(doc: &mut Document, id: NodeId, new: BoardShape) -> Result<()> {
+ let n = doc.get_mut(id)?;
+ n.board = Some(BoardItem::Shape { shape: new });
+ n.name = new.label().into();
+ let (w, h) = (n.width, n.height);
+ if let Some(l) = n.layout.as_mut() {
+ l.padding = shape_padding(new, w, h);
+ }
+ if let Some(o) = doc.get(id)?.children.first().copied()
+ && let Some(on) = doc.node_mut(o)
+ {
+ on.kind = NodeKind::Vector { network: VectorNetwork::from_path(&new.path(w, h)) };
+ (on.width, on.height, on.transform) = (w, h, Affine::IDENTITY);
+ }
+ Ok(())
+}
+
+/// Board object `id`'s text at `size`; whether it has text.
+fn resize_text(doc: &mut Document, id: NodeId, size: f64) -> bool {
+ let Some(t) = text_of(doc, id) else { return false };
+ if let Some(NodeKind::Text(td)) = doc.node_mut(t).map(|n| &mut n.kind) {
+ set_font_size(td, size);
+ return true;
+ }
+ false
+}
+
+fn set_style(s: &mut Session, p: &Value) -> Result {
+ let cmd = "board.setStyle";
+ require(s, cmd)?;
+ let ids = req_targets(cmd, s, p)?;
+ let restyle = Restyle::of(cmd, p)?;
+ let doc = s.doc_mut()?;
+ let mut changed = Vec::new();
+ for (id, item) in items(doc, &ids) {
+ if restyle.apply(doc, id, item)? {
+ changed.push(id);
+ }
+ }
+ if changed.is_empty() {
+ return Err(bad(cmd, "nothing selected takes these (shapes with text, connectors, labels)"));
+ }
+ Ok(json!({"ids": changed}))
+}
+
+fn set_font_size(td: &mut TextData, size: f64) {
+ td.style.font_size = size;
+ for r in &mut td.runs {
+ r.style.font_size = size;
+ }
+}
+
+/// Each layer of `sources` (copied one by one, in order, as `copies`) and its copy: the whole
+/// subtrees pair up when they have the same shape (an instance made of a main component may not;
+/// then only the roots do).
+pub(crate) fn copy_map(doc: &Document, sources: &[NodeId], copies: &[NodeId]) -> BTreeMap {
+ let mut map = BTreeMap::new();
+ for (s, c) in sources.iter().zip(copies) {
+ let (a, b) = (doc.subtree(*s), doc.subtree(*c));
+ if a.len() == b.len() {
+ map.extend(a.into_iter().zip(b));
+ } else {
+ map.insert(*s, *c);
+ }
+ }
+ map
+}
+
+/// The connectors and labels among copied layers, as `(copy, the original's board item)`, from the
+/// originals in `doc` (`map`: original → copy).
+pub(crate) fn copied_items(doc: &Document, map: &BTreeMap) -> Vec<(NodeId, BoardItem)> {
+ map.iter().filter_map(|(o, c)| doc.node(*o).and_then(|n| n.board.clone()).map(|b| (*c, b))).collect()
+}
+
+/// After a copy (`map`: each copied original → its copy; `originals`: the copies' items as the
+/// originals had them), copied connectors join the copies of what they joined and labels follow
+/// the copies of their connectors. From another file (`foreign`), what wasn't copied isn't here: a
+/// connector's end there stays where it is drawn, as a point, and a label without its connector
+/// goes.
+pub(crate) fn rejoin(doc: &mut Document, originals: &[(NodeId, BoardItem)], map: &BTreeMap, foreign: bool) {
+ for (copy, item) in originals {
+ let mut item = item.clone();
+ let copied = |n: NodeId| map.contains_key(&n);
+ match &mut item {
+ BoardItem::Connector(c) if foreign => {
+ let ends = ends_now(doc, *copy);
+ for (end, at) in [(&mut c.from, ends.map(|e| e.0)), (&mut c.to, ends.map(|e| e.1))] {
+ if let (End::Node { node, .. }, Some(p)) = (*end, at)
+ && !copied(node)
+ {
+ *end = End::Point { x: p.x, y: p.y };
+ }
+ }
+ }
+ BoardItem::Label { connector } if foreign && !copied(*connector) => {
+ let _ = doc.remove(*copy);
+ continue;
+ }
+ BoardItem::Connector(_) | BoardItem::Label { .. } => {}
+ _ => continue,
+ }
+ item.remap(map);
+ if let Some(n) = doc.node_mut(*copy) {
+ n.board = Some(item);
+ }
+ }
+}
+
+// ---------------------------------------------------------------------------------------------
+// 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.
+pub(crate) fn settle_text(doc: &mut Document, before: &Document, touched: &BTreeSet) {
+ 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))
+ {
+ let pad = shape_padding(shape, n.width, n.height);
+ if n.layout.as_ref().is_some_and(|l| l.padding != pad)
+ && let Some(l) = doc.node_mut(id).and_then(|k| k.layout.as_mut())
+ {
+ l.padding = pad;
+ }
+ }
+ }
+}
+
+/// After layout: connectors run between their ends again (an end whose layer is gone stays where
+/// it was), one moved on its own takes its free ends along, and labels sit at their middles. Only
+/// the connectors and labels an edit can have moved are looked at: touched themselves, or with a
+/// touched (or gone) end, connector or layer around them.
+pub(crate) fn settle_routes(doc: &mut Document, before: &Document, touched: &BTreeSet) {
+ if !is_board(doc) || touched.is_empty() {
+ return;
+ }
+ let hit = |doc: &Document, id: NodeId| touched.contains(&id) || doc.ancestors(id).iter().any(|a| touched.contains(a));
+ let (mut connectors, mut labels) = (Vec::new(), Vec::new());
+ for n in doc.nodes() {
+ match &n.board {
+ Some(BoardItem::Connector(c)) => {
+ let ends = [c.from.node(), c.to.node()].into_iter().flatten();
+ if hit(doc, n.id) || ends.into_iter().any(|e| !doc.contains(e) || hit(doc, e)) {
+ connectors.push((n.id, *c));
+ }
+ }
+ Some(BoardItem::Label { connector }) => labels.push((n.id, *connector)),
+ _ => {}
+ }
+ }
+ let rerouted: BTreeSet = connectors.iter().map(|(id, _)| *id).collect();
+ for (id, mut c) in connectors {
+ let changed = detach_gone_ends(doc, id, &mut c) | carry_free_ends(doc, before, touched, id, &mut c);
+ if changed && let Some(n) = doc.node_mut(id) {
+ n.board = Some(BoardItem::Connector(c));
+ }
+ if let Some(pts) = route(doc, &c) {
+ place_route(doc, id, &pts);
+ }
+ }
+ for (label, connector) in labels {
+ if rerouted.contains(&connector) || touched.contains(&connector) || hit(doc, label) {
+ place_label(doc, label, connector);
+ }
+ }
+}
+
+/// The ends of connector `id` (as `c`) whose layer is gone or on another page stay where they are
+/// drawn, as points. Whether any did.
+fn detach_gone_ends(doc: &Document, id: NodeId, c: &mut Connector) -> bool {
+ let (page, ends) = (doc.page_of(id), ends_now(doc, id));
+ let mut detached = false;
+ for (end, at) in [(&mut c.from, ends.map(|e| e.0)), (&mut c.to, ends.map(|e| e.1))] {
+ if let (End::Node { node, .. }, Some(p)) = (*end, at)
+ && (!doc.contains(node) || doc.page_of(node) != page)
+ {
+ *end = End::Point { x: p.x, y: p.y };
+ detached = true;
+ }
+ }
+ detached
+}
+
+/// Connector `id` (as `c`) moved by itself (a drag, a nudge: its place changed but not what it
+/// joins): its free ends move with it. Whether they did.
+fn carry_free_ends(doc: &Document, before: &Document, touched: &BTreeSet, id: NodeId, c: &mut Connector) -> bool {
+ let (Some(b), Some(n)) = (before.node(id), doc.node(id)) else { return false };
+ if !touched.contains(&id) || b.transform == n.transform || b.board != n.board {
+ return false;
+ }
+ let Some(expected) = route(doc, c).and_then(|pts| figcraft_geom::points_bounds(pts.iter().copied())).map(|b| b.origin()) else { return false };
+ let d = (doc.world_transform(id) * Point::ZERO) - expected;
+ if d.hypot() <= 1e-9 {
+ return false;
+ }
+ let mut moved = false;
+ for end in [&mut c.from, &mut c.to] {
+ if let End::Point { x, y } = end {
+ (*x, *y) = (*x + d.x, *y + d.y);
+ moved = true;
+ }
+ }
+ moved
+}
+
+/// Label `label` at the middle of connector `connector`; gone with it when it is gone.
+fn place_label(doc: &mut Document, label: NodeId, connector: NodeId) {
+ let Some(mid) = doc.node(connector).and_then(|_| route_mid(doc, connector)) else {
+ let _ = doc.remove(label);
+ return;
+ };
+ let Some(n) = doc.node(label) else { return };
+ let pw = n.parent.map_or(Affine::IDENTITY, |p| doc.world_transform(p));
+ let local = pw.inverse() * mid;
+ let t = Affine::translate((local.x - n.width / 2.0, local.y - n.height / 2.0));
+ if n.transform != t
+ && let Some(n) = doc.node_mut(label)
+ {
+ n.transform = t;
+ }
+}
+
+/// Connector `id`'s first and last points on the page as it is drawn now.
+fn ends_now(doc: &Document, id: NodeId) -> Option<(Point, Point)> {
+ let NodeKind::Vector { network } = &doc.node(id)?.kind else { return None };
+ let w = doc.world_transform(id);
+ Some((w * network.vertices.first()?.point(), w * network.vertices.last()?.point()))
+}
+
+/// The middle of connector `id`'s route by length, on the page.
+fn route_mid(doc: &Document, id: NodeId) -> Option {
+ let NodeKind::Vector { network } = &doc.node(id)?.kind else { return None };
+ let w = doc.world_transform(id);
+ let pts: Vec = network.vertices.iter().map(|v| w * v.point()).collect();
+ let total: f64 = pts.windows(2).map(|s| (s[1] - s[0]).hypot()).sum();
+ let mut left = total / 2.0;
+ for s in pts.windows(2) {
+ let (a, b) = (s[0], s[1]);
+ let l = (b - a).hypot();
+ if l >= left && l > 0.0 {
+ return Some(a.lerp(b, left / l));
+ }
+ left -= l;
+ }
+ pts.first().copied()
+}
+
+/// Write the route `pts` (page points) into connector `id`: its box, place and path. Untouched
+/// when it already runs there, so a connector that didn't move isn't an edit.
+fn place_route(doc: &mut Document, id: NodeId, pts: &[Point]) {
+ let Some(n) = doc.node(id) else { return };
+ let pw = n.parent.map_or(Affine::IDENTITY, |p| doc.world_transform(p));
+ let inv = pw.inverse();
+ let local: Vec = pts.iter().map(|p| inv * *p).collect();
+ let Some(b) = figcraft_geom::points_bounds(local.iter().copied()) else { return };
+ if !(b.x0.is_finite() && b.y0.is_finite() && b.x1.is_finite() && b.y1.is_finite()) {
+ return;
+ }
+ let rel: Vec = local.iter().map(|p| Point::new(p.x - b.x0, p.y - b.y0)).collect();
+ let network = VectorNetwork::from_points(&rel, false);
+ let t = Affine::translate((b.x0, b.y0));
+ let same =
+ n.transform == t && n.width == b.width() && n.height == b.height() && matches!(&n.kind, NodeKind::Vector { network: old } if *old == network);
+ if same {
+ return;
+ }
+ if let Some(n) = doc.node_mut(id) {
+ n.kind = NodeKind::Vector { network };
+ n.transform = t;
+ (n.width, n.height) = (b.width(), b.height());
+ }
+}
+
+/// The page points connector `c` runs through: from the middle of the side of each attached layer
+/// facing the other end (or the side it names), straight or in right angles.
+pub fn route(doc: &Document, c: &Connector) -> Option> {
+ let bounds = |e: &End| e.node().and_then(|n| doc.world_bounds(n));
+ let centre = |e: &End, b: Option| match e {
+ End::Point { x, y } => Some(Point::new(*x, *y)),
+ End::Node { .. } => b.map(|b| b.center()),
+ };
+ let (fb, tb) = (bounds(&c.from), bounds(&c.to));
+ let (fc, tc) = (centre(&c.from, fb)?, centre(&c.to, tb)?);
+ let (p0, h0) = attach(&c.from, fb, tc)?;
+ let (p1, h1) = attach(&c.to, tb, fc)?;
+ let mut pts = match c.routing {
+ Routing::Straight => vec![p0, p1],
+ Routing::Elbow => elbow(p0, h0, p1, h1),
+ };
+ pts.dedup();
+ // A turn that doesn't turn (the ends in line) is no point of the route.
+ let in_line = |i: usize, b: &Point| match (i.checked_sub(1).and_then(|j| pts.get(j)), pts.get(i + 1)) {
+ (Some(a), Some(c)) => (a.x == b.x && b.x == c.x) || (a.y == b.y && b.y == c.y),
+ _ => false,
+ };
+ let pts: Vec = pts.iter().enumerate().filter(|(i, b)| !in_line(*i, b)).map(|(_, b)| *b).collect();
+ pts.iter().all(|p| p.x.is_finite() && p.y.is_finite()).then_some(pts)
+}
+
+/// Where end `e` attaches (its point, or the middle of its layer's side facing `other`) and
+/// whether that side faces sideways (`None`: a free point).
+fn attach(e: &End, b: Option, other: Point) -> Option<(Point, Option)> {
+ match e {
+ End::Point { x, y } => Some((Point::new(*x, *y), None)),
+ End::Node { side, .. } => {
+ let b = b?;
+ let side = match side {
+ Side::Auto => {
+ let d = other - b.center();
+ // Compare against the box's proportions: a wide box takes the sides more.
+ if d.x.abs() * b.height().max(1e-9) >= d.y.abs() * b.width().max(1e-9) {
+ if d.x >= 0.0 { Side::Right } else { Side::Left }
+ } else if d.y >= 0.0 {
+ Side::Bottom
+ } else {
+ Side::Top
+ }
+ }
+ s => *s,
+ };
+ Some((side.point(b), Some(side.horizontal())))
+ }
+ }
+}
+
+/// A right-angled route from `p0` to `p1`, leaving and arriving along the sides' normals
+/// (`h`: sideways; a free end follows the other).
+fn elbow(p0: Point, h0: Option, p1: Point, h1: Option) -> Vec {
+ let h0 = h0.or(h1).unwrap_or((p1.x - p0.x).abs() >= (p1.y - p0.y).abs());
+ let h1 = h1.unwrap_or(h0);
+ match (h0, h1) {
+ (true, true) => {
+ let mx = (p0.x + p1.x) / 2.0;
+ vec![p0, Point::new(mx, p0.y), Point::new(mx, p1.y), p1]
+ }
+ (false, false) => {
+ let my = (p0.y + p1.y) / 2.0;
+ vec![p0, Point::new(p0.x, my), Point::new(p1.x, my), p1]
+ }
+ (true, false) => vec![p0, Point::new(p1.x, p0.y), p1],
+ (false, true) => vec![p0, Point::new(p0.x, p1.y), p1],
+ }
+}
+
+// ---------------------------------------------------------------------------------------------
+// The board tools.
+
+impl Session {
+ /// A press with a board tool: place a sticky, shape or stamp, start a connector or a stroke,
+ /// or start erasing.
+ pub(crate) fn board_down(&mut self, ev: &PointerEvent) -> Result<()> {
+ // A board tool kept while a design file came to the front: back to Move for this press.
+ if !is_board(self.doc()?) {
+ self.tool.tool = ToolId::Move;
+ return self.pointer(ev);
+ }
+ // A sticky still being typed in ends first, so the next object is an undo step of its own.
+ if self.ds()?.text_edit.is_some() {
+ crate::textedit::end(self)?;
+ }
+ match self.tool.tool {
+ ToolId::Sticky => {
+ let half = STICKY / 2.0;
+ let r = self.execute("board.sticky", &json!({"x": ev.x - half, "y": ev.y - half}))?;
+ self.board_placed();
+ if let Some(id) = r.get("id").and_then(id_of) {
+ edit_text(self, id)?;
+ }
+ Ok(())
+ }
+ ToolId::BoardShape => {
+ let half = SHAPE / 2.0;
+ self.execute("board.shape", &json!({"x": ev.x - half, "y": ev.y - half}))?;
+ self.board_placed();
+ Ok(())
+ }
+ ToolId::Stamp => {
+ // Stamps go on one after another: the tool stays.
+ self.execute("board.stamp", &json!({"x": ev.x, "y": ev.y}))?;
+ Ok(())
+ }
+ ToolId::Marker | ToolId::Highlighter => {
+ self.tool.gesture = Gesture::Pencil { points: vec![ev.p()], pressure: vec![ev.pressure] };
+ Ok(())
+ }
+ ToolId::Connector => {
+ let from = self.end_at(ev);
+ self.tool.gesture = Gesture::Connect { from, start: ev.p() };
+ Ok(())
+ }
+ ToolId::Eraser => {
+ self.begin_interaction("Erase")?;
+ self.tool.gesture = Gesture::Erase { gone: Vec::new() };
+ self.erase_at(ev)
+ }
+ _ => Ok(()),
+ }
+ }
+
+ /// After placing an object: back to the Move tool unless tools stay on.
+ fn board_placed(&mut self) {
+ if !self.prefs.keep_tool {
+ self.set_tool(ToolId::Move);
+ }
+ }
+
+ /// What a connector end at the pointer attaches to: the object there, or the point.
+ fn end_at(&self, ev: &PointerEvent) -> End {
+ let hit = (|| {
+ let doc = self.doc().ok()?;
+ let leaf = self.hit(doc, self.page().ok()?, ev.p(), 2.0 / ev.zoom.max(1e-6))?;
+ let t = figcraft_doc::geometry::select_target(doc, leaf, &[], false);
+ let n = doc.node(t)?;
+ (!matches!(n.board, Some(BoardItem::Connector(_)) | Some(BoardItem::Label { .. }) | Some(BoardItem::Ink))).then_some(t)
+ })();
+ match hit {
+ Some(node) => End::Node { node, side: Side::Auto },
+ None => End::Point { x: ev.x, y: ev.y },
+ }
+ }
+
+ pub(crate) fn connect_drag(&mut self, ev: &PointerEvent, from: End, start: Point) {
+ let a = match from {
+ End::Point { x, y } => Point::new(x, y),
+ End::Node { .. } => start,
+ };
+ self.tool.overlay.rubber = Some([a.x, a.y, ev.x, ev.y]);
+ self.tool.overlay.drop_target = from.node();
+ self.tool.gesture = Gesture::Connect { from, start };
+ if let Ok(ds) = self.ds_mut() {
+ ds.revision += 1;
+ }
+ }
+
+ pub(crate) fn connect_up(&mut self, ev: &PointerEvent, from: End, start: Point) -> Result<()> {
+ self.tool.overlay.rubber = None;
+ self.tool.overlay.drop_target = None;
+ // A click, not a drag: nothing to join.
+ if (ev.p() - start).hypot() * ev.zoom.max(1e-6) < 4.0 {
+ return Ok(());
+ }
+ let to = self.end_at(ev);
+ if to.node().is_some() && to.node() == from.node() {
+ return Ok(());
+ }
+ let json_end = |e: End| match e {
+ End::Node { node, .. } => json!(node),
+ End::Point { x, y } => json!({"x": x, "y": y}),
+ };
+ let style = self.tool.board.routing.id();
+ self.execute("board.connector", &json!({"from": json_end(from), "to": json_end(to), "style": style}))?;
+ self.board_placed();
+ Ok(())
+ }
+
+ /// The eraser at the pointer: the marker and highlighter strokes it touches go (until the
+ /// gesture ends, which is one undo step).
+ pub(crate) fn erase_at(&mut self, ev: &PointerEvent) -> Result<()> {
+ let Gesture::Erase { mut gone } = std::mem::take(&mut self.tool.gesture) else { return Ok(()) };
+ let tol = ERASER_PX / ev.zoom.max(1e-6);
+ self.tool.overlay.brush = Some([ev.x, ev.y, tol]);
+ let (doc, page) = (self.doc()?.clone(), self.page()?);
+ if let Some(hit) =
+ doc.hit_test(page, ev.p(), tol, None).filter(|h| doc.node(*h).is_some_and(|n| n.board == Some(BoardItem::Ink)) && !gone.contains(h))
+ {
+ gone.push(hit);
+ let ids = gone.clone();
+ self.preview(|d, sel| {
+ for i in &ids {
+ let _ = d.remove(*i);
+ }
+ sel.retain(|s| !ids.contains(s));
+ Ok(())
+ })?;
+ }
+ self.tool.gesture = Gesture::Erase { gone };
+ if let Ok(ds) = self.ds_mut() {
+ ds.revision += 1;
+ }
+ Ok(())
+ }
+
+ pub(crate) fn erase_up(&mut self) -> Result<()> {
+ self.tool.overlay.brush = None;
+ self.commit_interaction()
+ }
+
+ /// A finished marker or highlighter stroke (page points).
+ pub(crate) fn ink_finish(&mut self, path: &str) -> Result<()> {
+ let high = self.tool.tool == ToolId::Highlighter;
+ self.execute("board.ink", &json!({"path": path, "highlighter": high, "select": false}))?;
+ // Strokes come one after another: the selection stays as it was.
+ Ok(())
+ }
+}
+
+impl Session {
+ /// A double-click with the Move tool on a board object: type in its text (a connector gets a
+ /// label to type in). True when it was one.
+ pub(crate) fn board_double_click(&mut self, doc: &Document, leaf: NodeId, sel: &[NodeId]) -> Result {
+ let whole = figcraft_doc::geometry::select_target(doc, leaf, sel, false);
+ let editing = self.ds()?.text_edit.as_ref().is_some_and(|te| owner_of_text(doc, te.id) == Some(whole));
+ let Some(item) = doc.node(whole).and_then(|n| n.board.clone()).filter(|_| !editing) else { return Ok(false) };
+ self.tool.gesture = Gesture::None;
+ self.cancel_interaction()?;
+ match item {
+ BoardItem::Connector(_) => {
+ let label = match label_of(doc, whole) {
+ Some(l) => l,
+ None => {
+ let r = self.execute("board.label", &json!({"id": whole, "text": "Label"}))?;
+ r.get("label").and_then(id_of).ok_or_else(|| EngineError::Other("no label made".into()))?
+ }
+ };
+ edit_text(self, label)
+ }
+ b if b.has_text() => edit_text(self, whole),
+ _ => Ok(false),
+ }
+ }
+}
diff --git a/crates/engine/src/board_tests.rs b/crates/engine/src/board_tests.rs
new file mode 100644
index 00000000..5b8cbbf9
--- /dev/null
+++ b/crates/engine/src/board_tests.rs
@@ -0,0 +1,363 @@
+//! Boards: the file kind, sticky notes, shapes with text, connectors that follow what they join
+//! (locally, through undo and in live sessions), stamps, ink and the eraser, and refusals.
+
+use figcraft_doc::{
+ BOARD_PAGE, BoardItem, BoardShape, Connector, End, FileKind, Node, NodeId, NodeKind, Routing, Side, Stamp, StrokeCap, board_color,
+};
+use figcraft_geom::Point;
+use serde_json::{Value, json};
+
+use crate::board::{route, sticky_font_size};
+use crate::collab_live_tests::Room;
+use crate::tools::{PointerEvent, PointerKind, ToolId};
+use crate::{EngineError, Session};
+
+pub(crate) fn board() -> Session {
+ let mut s = Session::new();
+ s.execute("file.newBoard", &json!({"name": "Ideas"})).unwrap();
+ s
+}
+
+pub(crate) fn id(v: &Value, key: &str) -> NodeId {
+ v[key].as_u64().map(NodeId).unwrap_or_else(|| panic!("no {key} in {v}"))
+}
+
+pub(crate) fn node(s: &Session, id: NodeId) -> Node {
+ s.doc().unwrap().node(id).unwrap().clone()
+}
+
+pub(crate) fn connector(s: &Session, id: NodeId) -> Connector {
+ match node(s, id).board {
+ Some(BoardItem::Connector(c)) => c,
+ other => panic!("not a connector: {other:?}"),
+ }
+}
+
+/// Connector `id`'s points on the page.
+pub(crate) fn drawn(s: &Session, id: NodeId) -> Vec {
+ let doc = s.doc().unwrap();
+ let NodeKind::Vector { network } = &doc.node(id).unwrap().kind else { panic!("not a vector") };
+ let w = doc.world_transform(id);
+ network.vertices.iter().map(|v| w * v.point()).collect()
+}
+
+pub(crate) fn near(a: Point, b: Point) -> bool {
+ (a - b).hypot() < 1e-6
+}
+
+#[test]
+fn a_board_is_a_kind_of_file_that_saves_and_reopens() {
+ let s = board();
+ let doc = s.doc().unwrap();
+ assert_eq!(doc.kind, FileKind::Board);
+ assert!(matches!(doc.node(doc.pages[0]).unwrap().kind, NodeKind::Page { background, .. } if background == BOARD_PAGE));
+ let (back, _) = figcraft_format::from_json(&figcraft_format::to_json(doc).unwrap().to_string()).unwrap();
+ assert_eq!(back.kind, FileKind::Board);
+ // Files from before boards (no kind) are design files, and design files don't write one.
+ let mut d = Session::new();
+ d.execute("file.new", &json!({})).unwrap();
+ let json = figcraft_format::to_json(d.doc().unwrap()).unwrap();
+ assert!(json.get("kind").is_none());
+ assert_eq!(figcraft_format::from_json(&json.to_string()).unwrap().0.kind, FileKind::Design);
+ assert_eq!(crate::inspect::document(&s, 0, false)["kind"], "board", "inspect shows the kind");
+}
+
+#[test]
+fn board_commands_refuse_on_design_files_and_prototyping_refuses_on_boards() {
+ let mut d = Session::new();
+ d.execute("file.new", &json!({})).unwrap();
+ for (cmd, p) in [("board.sticky", json!({"x": 0, "y": 0})), ("tool.sticky", json!({})), ("tool.set", json!({"tool": "marker"}))] {
+ assert!(matches!(d.execute(cmd, &p), Err(EngineError::Disabled(..))), "{cmd} on a design file");
+ }
+ let mut s = board();
+ for cmd in ["view.devMode", "view.prototype", "proto.present", "proto.flow.add", "dev.focus"] {
+ let e = s.execute(cmd, &json!({})).unwrap_err();
+ assert!(e.to_string().contains("boards have no prototypes"), "{cmd}: {e}");
+ }
+}
+
+#[test]
+fn a_sticky_is_a_square_frame_whose_note_shrinks_as_it_grows() {
+ 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();
+ let (st, note) = (id(&r, "id"), id(&r, "text"));
+ let n = node(&s, st);
+ assert!(n.is_board_atom() && matches!(&n.board, Some(BoardItem::Sticky { author }) if author == "Ada"));
+ assert_eq!((n.width, n.height), (200.0, 200.0));
+ 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);
+ // 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.
+ 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!(node(&s, st).width == 200.0 && node(&s, st).height >= 200.0);
+ // Undo puts the short note and its size back.
+ s.execute("edit.undo", &json!({})).unwrap();
+ assert_eq!(node(&s, note).kind.text().unwrap().style.font_size, 24.0);
+}
+
+#[test]
+fn next_sticky_goes_beside_in_the_same_colour_and_emptied_notes_stay() {
+ let mut s = board();
+ let a = id(&s.execute("board.sticky", &json!({"x": 0, "y": 0, "color": "pink"})).unwrap(), "id");
+ let r = s.execute("board.nextSticky", &json!({})).unwrap();
+ let b = id(&r, "id");
+ let (na, nb) = (node(&s, a), node(&s, b));
+ assert_eq!(nb.transform.translation().x, na.width + 24.0);
+ assert_eq!(nb.fills, na.fills);
+ assert_eq!(s.selection(), vec![b]);
+ // Typing in it and emptying it again keeps its note; ending selects the sticky.
+ let note = id(&r, "text");
+ crate::board::edit_text(&mut s, b).unwrap();
+ crate::textedit::insert(&mut s, "x").unwrap();
+ crate::textedit::key(&mut s, "Backspace", false, false, false).unwrap();
+ crate::textedit::end(&mut s).unwrap();
+ assert!(s.doc().unwrap().contains(note));
+ assert_eq!(s.selection(), vec![b]);
+}
+
+#[test]
+fn shapes_carry_text_and_change_outline() {
+ let mut s = board();
+ let r = s.execute("board.shape", &json!({"shape": "diamond", "x": 0, "y": 0, "text": "Decide", "color": "green"})).unwrap();
+ let sh = id(&r, "id");
+ let n = node(&s, sh);
+ assert_eq!(n.board, Some(BoardItem::Shape { shape: BoardShape::Diamond }));
+ assert_eq!(n.children.len(), 2);
+ assert!(matches!(node(&s, n.children[0]).kind, NodeKind::Vector { .. }));
+ s.execute("board.setStyle", &json!({"ids": [sh], "shape": "speechBubble", "fontSize": 24})).unwrap();
+ assert_eq!(node(&s, sh).board, Some(BoardItem::Shape { shape: BoardShape::SpeechBubble }));
+ assert_eq!(node(&s, id(&r, "text")).kind.text().unwrap().style.font_size, 24.0);
+ s.execute("board.setColor", &json!({"ids": [sh], "color": "#FF0000"})).unwrap();
+ assert_eq!(node(&s, n.children[0]).fills[0].solid_color().map(|c| c.to_hex()), Some("FF0000".into()));
+ assert!(s.execute("board.shape", &json!({"shape": "blob", "x": 0, "y": 0})).is_err());
+}
+
+#[test]
+fn connectors_follow_what_they_join_and_undo_with_it() {
+ let mut s = board();
+ let a = id(&s.execute("board.sticky", &json!({"x": 0, "y": 0})).unwrap(), "id");
+ let b = id(&s.execute("board.sticky", &json!({"x": 400, "y": 0})).unwrap(), "id");
+ let c = id(&s.execute("board.connector", &json!({"from": a, "to": b, "style": "straight", "label": "then"})).unwrap(), "id");
+ let pts = drawn(&s, c);
+ assert!(near(pts[0], Point::new(200.0, 100.0)) && near(pts[1], Point::new(400.0, 100.0)), "{pts:?}");
+ assert_eq!(node(&s, c).stroke.cap_end, StrokeCap::TriangleArrow);
+ // Its label sits at the middle.
+ let label = crate::board::label_of(s.doc().unwrap(), c).unwrap();
+ let lb = s.doc().unwrap().world_bounds(label).unwrap();
+ assert!(near(lb.center(), Point::new(300.0, 100.0)), "{lb:?}");
+ // Move one end: the connector re-routes (elbow now, out of the facing sides).
+ s.execute("board.setStyle", &json!({"ids": [c], "style": "elbow"})).unwrap();
+ s.execute("transform.move", &json!({"ids": [b], "dx": 0, "dy": 300})).unwrap();
+ let pts = drawn(&s, c);
+ assert!(near(pts[0], Point::new(200.0, 100.0)) && near(*pts.last().unwrap(), Point::new(400.0, 400.0)), "{pts:?}");
+ assert!(pts.windows(2).all(|w| w[0].x == w[1].x || w[0].y == w[1].y), "right angles: {pts:?}");
+ // Undo takes the move back and the route with it.
+ s.execute("edit.undo", &json!({})).unwrap();
+ assert!(near(*drawn(&s, c).last().unwrap(), Point::new(400.0, 100.0)));
+ // A deleted end stays where it was, as a point.
+ s.execute("edit.delete", &json!({"ids": [b]})).unwrap();
+ assert!(matches!(connector(&s, c).to, End::Point { .. }));
+ assert!(near(*drawn(&s, c).last().unwrap(), Point::new(400.0, 100.0)));
+ // A connector moved on its own takes its free end along; the attached one stays.
+ s.execute("transform.move", &json!({"ids": [c], "dx": 0, "dy": 50})).unwrap();
+ assert!(matches!(connector(&s, c).to, End::Point { x, y } if x == 400.0 && y == 150.0), "{:?}", connector(&s, c));
+ assert!(near(drawn(&s, c)[0], Point::new(200.0, 100.0)));
+ // Deleting the connector takes its label.
+ s.execute("edit.delete", &json!({"ids": [c]})).unwrap();
+ assert!(!s.doc().unwrap().contains(label));
+ assert!(s.execute("board.connector", &json!({"from": a, "to": a})).is_err());
+}
+
+#[test]
+fn routes_are_the_same_for_the_same_document() {
+ let mut s = board();
+ let a = id(&s.execute("board.shape", &json!({"x": 0, "y": 0})).unwrap(), "id");
+ let c = Connector { from: End::Node { node: a, side: Side::Bottom }, to: End::Point { x: 300.0, y: 500.0 }, routing: Routing::Elbow };
+ let doc = s.doc().unwrap();
+ let r = route(doc, &c).unwrap();
+ assert_eq!(r, route(&doc.clone(), &c).unwrap());
+ // Down out of the bottom, across halfway, down into the point.
+ assert_eq!(r, vec![Point::new(80.0, 160.0), Point::new(80.0, 330.0), Point::new(300.0, 330.0), Point::new(300.0, 500.0)]);
+}
+
+#[test]
+fn stamps_and_ink_and_the_eraser() {
+ let mut s = board();
+ s.prefs.user_name = "Grace".into();
+ let st = id(&s.execute("board.stamp", &json!({"x": 100, "y": 100, "stamp": "heart"})).unwrap(), "id");
+ let n = node(&s, st);
+ assert_eq!(n.board, Some(BoardItem::Stamp { stamp: Stamp::Heart, author: "Grace".into() }));
+ assert_eq!(s.doc().unwrap().world_bounds(st).unwrap().center(), Point::new(100.0, 100.0));
+ assert!(!n.children.is_empty());
+ // Marker and highlighter strokes through the tools; the eraser takes what it touches.
+ let draw = |s: &mut Session, tool: &str, y: f64| {
+ s.execute("tool.set", &json!({"tool": tool})).unwrap();
+ for (k, x) in [(PointerKind::Down, 0.0), (PointerKind::Move, 50.0), (PointerKind::Move, 100.0), (PointerKind::Up, 150.0)] {
+ s.pointer(&PointerEvent::at(k, x, y, 1.0)).unwrap();
+ }
+ };
+ draw(&mut s, "marker", 300.0);
+ draw(&mut s, "highlighter", 400.0);
+ let inks: Vec = s.doc().unwrap().nodes().filter(|n| n.board == Some(BoardItem::Ink)).cloned().collect();
+ assert_eq!(inks.len(), 2);
+ assert!(inks.iter().any(|n| n.opacity < 1.0 && n.stroke.weight > 10.0), "a highlighter stroke");
+ let undo = s.undo_depth().0;
+ s.execute("tool.eraser", &json!({})).unwrap();
+ for (k, x) in [(PointerKind::Down, 20.0), (PointerKind::Move, 60.0), (PointerKind::Up, 80.0)] {
+ s.pointer(&PointerEvent::at(k, x, 300.0, 1.0)).unwrap();
+ }
+ assert_eq!(s.doc().unwrap().nodes().filter(|n| n.board == Some(BoardItem::Ink)).count(), 1, "the marker stroke is gone");
+ assert_eq!(s.undo_depth().0, undo + 1, "one step");
+ assert_eq!(s.tool.tool, ToolId::Eraser);
+}
+
+#[test]
+fn the_sticky_and_connector_tools() {
+ let mut s = board();
+ s.execute("tool.sticky", &json!({"color": "orange"})).unwrap();
+ s.pointer(&PointerEvent::at(PointerKind::Down, 100.0, 100.0, 1.0)).unwrap();
+ s.pointer(&PointerEvent::at(PointerKind::Up, 100.0, 100.0, 1.0)).unwrap();
+ let te = s.ds().unwrap().text_edit.clone().expect("typing in the new sticky");
+ let a = crate::board::owner_of_text(s.doc().unwrap(), te.id).unwrap();
+ assert_eq!(node(&s, a).fills[0].solid_color(), board_color("orange"));
+ crate::textedit::insert(&mut s, "First").unwrap();
+ crate::textedit::end(&mut s).unwrap();
+ let b = id(&s.execute("board.sticky", &json!({"x": 500, "y": 0})).unwrap(), "id");
+ s.execute("tool.connector", &json!({})).unwrap();
+ s.pointer(&PointerEvent::at(PointerKind::Down, 100.0, 100.0, 1.0)).unwrap();
+ s.pointer(&PointerEvent::at(PointerKind::Move, 300.0, 100.0, 1.0)).unwrap();
+ s.pointer(&PointerEvent::at(PointerKind::Up, 600.0, 100.0, 1.0)).unwrap();
+ let c = s.doc().unwrap().nodes().find(|n| matches!(n.board, Some(BoardItem::Connector(_)))).map(|n| n.id).unwrap();
+ let k = connector(&s, c);
+ assert_eq!((k.from.node(), k.to.node()), (Some(a), Some(b)));
+}
+
+#[test]
+fn boards_sync_in_live_sessions() {
+ let mut s = board();
+ let a = id(&s.execute("board.sticky", &json!({"x": 0, "y": 0, "text": "A"})).unwrap(), "id");
+ let mut room = Room::new(s.doc().unwrap().clone(), 2, 7);
+ assert_eq!(room.s(1).doc().unwrap().kind, FileKind::Board, "joiners get a board");
+ let b = id(&room.s(1).execute("board.sticky", &json!({"x": 400, "y": 0, "text": "B"})).unwrap(), "id");
+ room.settle();
+ let c = id(&room.s(0).execute("board.connector", &json!({"from": a, "to": b})).unwrap(), "id");
+ room.s(1).execute("board.stamp", &json!({"x": 50, "y": 50, "stamp": "star"})).unwrap();
+ room.settle();
+ room.check();
+ // Person 1 moves the sticky person 0 connected: both see the connector follow it.
+ room.s(1).execute("transform.move", &json!({"ids": [b], "dx": 0, "dy": 250})).unwrap();
+ room.s(0).execute("board.setColor", &json!({"ids": [a], "color": "violet"})).unwrap();
+ room.settle();
+ room.check();
+ let doc = room.server.document();
+ let NodeKind::Vector { network } = &doc.node(c).unwrap().kind else { panic!("not a vector") };
+ let end = doc.world_transform(c) * network.vertices.last().unwrap().point();
+ assert_eq!(end, Point::new(400.0, 350.0), "to the moved sticky's facing side");
+ assert_eq!(doc.node(a).unwrap().fills[0].solid_color(), board_color("violet"));
+}
+
+#[test]
+fn board_commands_survive_junk() {
+ let junk = [
+ json!({}),
+ json!(null),
+ json!([1]),
+ json!({"x": "NaN", "y": 1e308, "text": 5, "color": [1], "author": {"x": 1}, "parent": "p"}),
+ json!({"x": -1e308, "y": 0, "color": "neon", "shape": 7, "width": -5, "height": 1e308, "stamp": "skull"}),
+ json!({"from": {"x": "a"}, "to": 99_999, "fromSide": "inside", "style": 3, "startCap": "spike", "endCap": 7, "label": [1]}),
+ json!({"from": {"x": 1e308, "y": -1e308}, "to": {"x": 0, "y": 0}, "style": "elbow", "label": "\u{0}"}),
+ json!({"ids": ["x", -1, 99_999], "color": "#GGG", "fontSize": -1, "side": "up", "edit": "yes"}),
+ json!({"id": 2, "text": "", "path": "M0 0 L", "points": [[1]], "highlighter": "yes"}),
+ json!({"path": "M0 0 L 1e308 1e308", "points": [[0, 0], [1e308, 1]]}),
+ ];
+ let ids: Vec<&str> = crate::cmd::all_commands()
+ .iter()
+ .map(|c| c.id)
+ .filter(|i| {
+ i.starts_with("board.")
+ || ["tool.sticky", "tool.shape", "tool.connector", "tool.marker", "tool.highlighter", "tool.eraser", "tool.stamp", "file.newBoard"]
+ .contains(i)
+ })
+ .collect();
+ assert!(ids.len() >= 17, "{ids:?}");
+ for cmd in ids {
+ for j in &junk {
+ let mut s = board();
+ let a = s.execute("board.sticky", &json!({"x": 0, "y": 0})).unwrap()["id"].clone();
+ let b = s.execute("board.shape", &json!({"x": 300, "y": 0})).unwrap()["id"].clone();
+ let _ = s.execute("board.connector", &json!({"from": a, "to": b, "label": "x"}));
+ if let Err(EngineError::Internal { cmd, msg }) = s.execute(cmd, j) {
+ panic!("{cmd} panicked on {j}: {msg}");
+ }
+ }
+ }
+ // Every other command on a board with objects on it.
+ for spec in crate::cmd::all_commands() {
+ if spec.id.starts_with("file.") && spec.id != "file.newBoard" || spec.id == "text.rescanFonts" || spec.id == "image.place" {
+ continue;
+ }
+ for j in &junk[..3] {
+ let mut s = board();
+ let a = s.execute("board.sticky", &json!({"x": 0, "y": 0})).unwrap()["id"].clone();
+ let b = s.execute("board.stamp", &json!({"x": 300, "y": 0})).unwrap()["id"].clone();
+ let _ = s.execute("board.connector", &json!({"from": a, "to": b}));
+ if let Err(EngineError::Internal { cmd, msg }) = s.execute(spec.id, j) {
+ panic!("{cmd} panicked on {j}: {msg}");
+ }
+ }
+ }
+}
+
+#[test]
+fn a_press_on_a_stickys_background_picks_and_drags_it() {
+ let mut s = board();
+ let a = id(&s.execute("board.sticky", &json!({"x": 0, "y": 0, "text": "Hi"})).unwrap(), "id");
+ let b = id(&s.execute("board.sticky", &json!({"x": 400, "y": 0})).unwrap(), "id");
+ let c = id(&s.execute("board.connector", &json!({"from": a, "to": b})).unwrap(), "id");
+ s.execute("select.none", &json!({})).unwrap();
+ // Below the note, on the sticky's own fill (a top-level frame's background is the canvas).
+ s.pointer(&PointerEvent::at(PointerKind::Down, 100.0, 150.0, 1.0)).unwrap();
+ s.pointer(&PointerEvent::at(PointerKind::Move, 100.0, 250.0, 1.0)).unwrap();
+ s.pointer(&PointerEvent::at(PointerKind::Move, 100.0, 450.0, 1.0)).unwrap();
+ s.pointer(&PointerEvent::at(PointerKind::Up, 100.0, 450.0, 1.0)).unwrap();
+ assert_eq!(s.selection(), vec![a]);
+ assert_eq!(node(&s, a).transform.translation().y, 300.0);
+ assert!(near(drawn(&s, c)[0], Point::new(200.0, 400.0)), "the connector followed the drag: {:?}", drawn(&s, c));
+}
+
+#[test]
+fn a_copy_of_joined_objects_joins_the_copies() {
+ let mut s = board();
+ let a = id(&s.execute("board.sticky", &json!({"x": 0, "y": 0})).unwrap(), "id");
+ let b = id(&s.execute("board.sticky", &json!({"x": 400, "y": 0})).unwrap(), "id");
+ let c = id(&s.execute("board.connector", &json!({"from": a, "to": b, "label": "x"})).unwrap(), "id");
+ let label = crate::board::label_of(s.doc().unwrap(), c).unwrap();
+ s.execute("edit.duplicate", &json!({"ids": [a, b, c, label]})).unwrap();
+ let copies = s.selection();
+ assert_eq!(copies.len(), 4, "{copies:?}");
+ let k = copies.iter().find_map(|i| match node(&s, *i).board {
+ Some(BoardItem::Connector(k)) => Some(k),
+ _ => None,
+ });
+ let k = k.unwrap();
+ assert!(copies.contains(&k.from.node().unwrap()) && copies.contains(&k.to.node().unwrap()), "{k:?} {copies:?}");
+ // Copy and paste too.
+ s.execute("select.set", &json!({"ids": [a, b, c]})).unwrap();
+ s.execute("edit.copy", &json!({})).unwrap();
+ s.execute("edit.paste", &json!({})).unwrap();
+ let pasted = s.selection();
+ let k = pasted.iter().find_map(|i| match node(&s, *i).board {
+ Some(BoardItem::Connector(k)) => Some(k),
+ _ => None,
+ });
+ let k = k.unwrap();
+ assert!(pasted.contains(&k.from.node().unwrap()) && pasted.contains(&k.to.node().unwrap()), "{k:?} {pasted:?}");
+}
diff --git a/crates/engine/src/board_tools_tests.rs b/crates/engine/src/board_tools_tests.rs
new file mode 100644
index 00000000..4109adda
--- /dev/null
+++ b/crates/engine/src/board_tools_tests.rs
@@ -0,0 +1,277 @@
+//! Boards, continued: copies and pastes (within a file and from another), routes with named sides
+//! and free points, connectors inside moving sections, styles and labels with their refusals, and
+//! the shape, stamp, highlighter and connector tools with double-clicks.
+
+use figcraft_doc::{BoardItem, BoardShape, End, NodeId, Side, Stamp, StrokeCap, board_color};
+use figcraft_geom::Point;
+use serde_json::json;
+
+use crate::Session;
+use crate::board::route;
+use crate::board_tests::{board, connector, drawn, id, near, node};
+use crate::tools::{PointerEvent, PointerKind, ToolId};
+
+/// The connector among `ids`, if any.
+fn connector_in(s: &Session, ids: &[NodeId]) -> Option {
+ let doc = s.doc().ok()?;
+ ids.iter().find_map(|i| match &doc.node(*i)?.board {
+ Some(BoardItem::Connector(k)) => Some(*k),
+ _ => None,
+ })
+}
+
+#[test]
+fn pasting_into_another_board_detaches_what_was_left_behind() {
+ let mut s = board();
+ let a = id(&s.execute("board.sticky", &json!({"x": 0, "y": 0})).unwrap(), "id");
+ let b = id(&s.execute("board.sticky", &json!({"x": 400, "y": 0})).unwrap(), "id");
+ let r = s.execute("board.connector", &json!({"from": a, "to": b, "style": "straight", "label": "x"})).unwrap();
+ let (c, label) = (id(&r, "id"), id(&r, "label"));
+ let first = s.active;
+ // A second board whose own ids are the same small numbers as the first's.
+ let second = s.execute("file.newBoard", &json!({})).unwrap()["index"].clone();
+ for x in [0, 300, 600, 900] {
+ s.execute("board.sticky", &json!({"x": x, "y": 500})).unwrap();
+ }
+ let others: Vec = s.doc().unwrap().nodes().map(|n| n.id).collect();
+ s.execute("doc.switch", &json!({"index": first})).unwrap();
+ s.execute("select.set", &json!({"ids": [a, c, label]})).unwrap();
+ s.execute("edit.copy", &json!({})).unwrap();
+ s.execute("doc.switch", &json!({"index": second})).unwrap();
+ s.execute("edit.paste", &json!({})).unwrap();
+ let doc = s.doc().unwrap();
+ let pasted = doc.nodes().find(|n| matches!(n.board, Some(BoardItem::Connector(_))) && !others.contains(&n.id)).unwrap().clone();
+ let k = connector(&s, pasted.id);
+ let from = k.from.node().unwrap();
+ assert!(!others.contains(&from) && matches!(doc.node(from).unwrap().board, Some(BoardItem::Sticky { .. })), "joins the pasted sticky");
+ let to = drawn(&s, pasted.id).last().copied().unwrap();
+ assert!(matches!(k.to, End::Point { x, y } if near(Point::new(x, y), to)), "the end left behind stays where it is drawn: {k:?}");
+ let pasted_label = crate::board::label_of(doc, pasted.id).expect("the label came with its connector");
+ assert!(!others.contains(&pasted_label));
+ // A label copied without its connector doesn't come.
+ s.execute("doc.switch", &json!({"index": first})).unwrap();
+ s.execute("select.set", &json!({"ids": [label]})).unwrap();
+ s.execute("edit.copy", &json!({})).unwrap();
+ s.execute("doc.switch", &json!({"index": second})).unwrap();
+ let labels = |s: &Session| s.doc().unwrap().nodes().filter(|n| matches!(n.board, Some(BoardItem::Label { .. }))).count();
+ let before = labels(&s);
+ s.execute("edit.paste", &json!({})).unwrap();
+ assert_eq!(labels(&s), before);
+ // Within its own file, a connector pasted alone stays joined to the same layers.
+ s.execute("doc.switch", &json!({"index": first})).unwrap();
+ s.execute("select.set", &json!({"ids": [c]})).unwrap();
+ s.execute("edit.copy", &json!({})).unwrap();
+ s.execute("edit.paste", &json!({})).unwrap();
+ let k = connector_in(&s, &s.selection()).unwrap();
+ assert_eq!((k.from.node(), k.to.node()), (Some(a), Some(b)));
+}
+
+#[test]
+fn duplicating_and_alt_dragging_keep_connections_inside_copied_sections() {
+ let mut s = board();
+ let sec = id(&s.execute("node.create", &json!({"type": "section", "x": -50, "y": -50, "width": 400, "height": 400})).unwrap(), "id");
+ let a = id(&s.execute("board.sticky", &json!({"x": 50, "y": 50, "parent": sec})).unwrap(), "id");
+ let b = id(&s.execute("board.sticky", &json!({"x": 600, "y": 0})).unwrap(), "id");
+ let c = id(&s.execute("board.connector", &json!({"from": a, "to": b})).unwrap(), "id");
+ s.execute("edit.duplicate", &json!({"ids": [sec, c]})).unwrap();
+ let copies = s.selection();
+ let from = connector_in(&s, &copies).unwrap().from.node().unwrap();
+ let doc = s.doc().unwrap();
+ assert!(from != a && copies.iter().any(|r| doc.is_ancestor(*r, from)), "the copy joins the sticky inside the copied section");
+ // Alt-drag copies the same way.
+ s.execute("select.set", &json!({"ids": [b, c]})).unwrap();
+ let press = |k, x| PointerEvent { alt: true, ..PointerEvent::at(k, x, 100.0, 1.0) };
+ for (k, x) in [(PointerKind::Down, 700.0), (PointerKind::Move, 760.0), (PointerKind::Move, 800.0), (PointerKind::Up, 800.0)] {
+ s.pointer(&press(k, x)).unwrap();
+ }
+ let copies = s.selection();
+ assert_eq!(copies.len(), 2);
+ let k = connector_in(&s, &copies).unwrap();
+ assert!(copies.contains(&k.to.node().unwrap()), "{k:?}");
+}
+
+#[test]
+fn routes_take_named_sides_and_free_points() {
+ let mut s = board();
+ 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 }).unwrap();
+ let side = |n, side| End::Node { node: n, side };
+ let p = |x, y| End::Point { x, y };
+ let pt = Point::new;
+ // Side to side: out, across halfway, in.
+ assert_eq!(elbow(side(a, Side::Right), side(b, Side::Left)), vec![pt(100.0, 50.0), pt(200.0, 50.0), pt(200.0, 350.0), pt(300.0, 350.0)]);
+ // A side and a top or bottom: one turn.
+ assert_eq!(elbow(side(a, Side::Right), side(b, Side::Top)), vec![pt(100.0, 50.0), pt(350.0, 50.0), pt(350.0, 300.0)]);
+ assert_eq!(elbow(side(a, Side::Bottom), side(b, Side::Left)), vec![pt(50.0, 100.0), pt(50.0, 350.0), pt(300.0, 350.0)]);
+ // Two free points: the longer way first; in a line, no turns.
+ 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 });
+ assert_eq!(straight.unwrap(), vec![pt(50.0, 100.0), pt(50.0, 500.0)]);
+ assert_eq!(Side::from_id("TOP"), Some(Side::Top));
+ assert_eq!(Side::from_id("inside"), None);
+ // The same place twice is refused, as are a side that doesn't exist and a point without numbers.
+ assert!(s.execute("board.connector", &json!({"from": {"x": 5, "y": 5}, "to": {"x": 5, "y": 5}})).is_err());
+ assert!(s.execute("board.connector", &json!({"from": a, "to": b, "fromSide": "inside"})).is_err());
+ assert!(s.execute("board.connector", &json!({"from": a, "to": {"x": "a"}})).is_err());
+ assert!(s.execute("board.connector", &json!({"from": a})).is_err());
+}
+
+#[test]
+fn a_connector_follows_a_layer_whose_section_moves_and_ignores_unrelated_edits() {
+ let mut s = board();
+ let sec = id(&s.execute("node.create", &json!({"type": "section", "x": 0, "y": 0, "width": 300, "height": 300})).unwrap(), "id");
+ let a = id(&s.execute("board.sticky", &json!({"x": 50, "y": 50, "parent": sec})).unwrap(), "id");
+ let b = id(&s.execute("board.stamp", &json!({"x": 800, "y": 150})).unwrap(), "id");
+ let c = id(&s.execute("board.connector", &json!({"from": a, "to": b, "style": "straight"})).unwrap(), "id");
+ assert!(near(drawn(&s, c)[0], Point::new(250.0, 150.0)));
+ // Only the section is edited; the sticky inside it moves with it, and so does the connector.
+ s.execute("transform.move", &json!({"ids": [sec], "dx": 0, "dy": 100})).unwrap();
+ assert!(near(drawn(&s, c)[0], Point::new(250.0, 250.0)), "{:?}", drawn(&s, c));
+ // An edit that touches neither end leaves the connector as it was.
+ let before = s.doc().unwrap().node_arc(c).cloned().unwrap();
+ s.execute("board.sticky", &json!({"x": 0, "y": 900})).unwrap();
+ assert!(std::sync::Arc::ptr_eq(&before, s.doc().unwrap().node_arc(c).unwrap()));
+}
+
+#[test]
+fn styles_labels_and_their_refusals() {
+ let mut s = board();
+ let a = id(&s.execute("board.sticky", &json!({"x": 0, "y": 0, "author": false})).unwrap(), "id");
+ assert_eq!(node(&s, a).children.len(), 1, "no author line");
+ let b = id(&s.execute("board.sticky", &json!({"x": 400, "y": 0, "author": " Lin "})).unwrap(), "id");
+ assert!(matches!(node(&s, b).board, Some(BoardItem::Sticky { ref author }) if author == "Lin"));
+ let c = id(&s.execute("board.connector", &json!({"from": a, "to": b, "startCap": "circleFilled", "endCap": "none"})).unwrap(), "id");
+ assert_eq!((node(&s, c).stroke.cap_start, node(&s, c).stroke.cap_end), (StrokeCap::CircleFilled, StrokeCap::None));
+ // Labels: set, change, size, remove; named by the label itself too.
+ let l = id(&s.execute("board.label", &json!({"id": c, "text": "first"})).unwrap(), "label");
+ assert_eq!(id(&s.execute("board.label", &json!({"id": l, "text": "second"})).unwrap(), "label"), l, "the same label, new text");
+ let text = crate::board::text_of(s.doc().unwrap(), l).unwrap();
+ assert_eq!(node(&s, text).kind.text().unwrap().characters, "second");
+ s.execute("board.setStyle", &json!({"ids": [l], "fontSize": 36})).unwrap();
+ assert_eq!(node(&s, text).kind.text().unwrap().style.font_size, 36.0);
+ assert!(s.execute("board.label", &json!({"id": c, "text": ""})).unwrap()["label"].is_null());
+ assert!(!s.doc().unwrap().contains(l));
+ // What doesn't take a style or colour says so.
+ assert!(s.execute("board.setStyle", &json!({"ids": [a], "fontSize": 30})).is_err(), "stickies size their own text");
+ assert!(s.execute("board.setStyle", &json!({"ids": [c], "fontSize": 0})).is_err());
+ let st = id(&s.execute("board.stamp", &json!({"x": 0, "y": 0, "stamp": "check"})).unwrap(), "id");
+ assert!(s.execute("board.setColor", &json!({"ids": [st], "color": "blue"})).is_err());
+ assert!(s.execute("board.setColor", &json!({"ids": [a]})).is_err());
+ assert!(s.execute("board.label", &json!({"id": a, "text": "x"})).is_err());
+ // A palette colour on a line draws in its deeper shade; a hex colour as given.
+ s.execute("board.setColor", &json!({"ids": [c], "color": "blue"})).unwrap();
+ assert!(node(&s, c).strokes[0].solid_color().is_some() && node(&s, c).strokes[0].solid_color() != board_color("blue"));
+ s.execute("board.setColor", &json!({"ids": [c], "color": "#123456"})).unwrap();
+ assert_eq!(node(&s, c).strokes[0].solid_color().map(|c| c.to_hex()), Some("123456".into()));
+ // Next stickies on each side, and refusals.
+ for (side, dx, dy) in [("below", 0.0, 224.0), ("left", -224.0, 0.0), ("above", 0.0, -224.0)] {
+ let n = id(&s.execute("board.nextSticky", &json!({"id": a, "side": side})).unwrap(), "id");
+ let t = node(&s, n).transform.translation();
+ assert_eq!((t.x, t.y), (dx, dy), "{side}");
+ }
+ assert!(s.execute("board.nextSticky", &json!({"id": a, "side": "diagonal"})).is_err());
+ assert!(s.execute("board.nextSticky", &json!({"id": c})).is_err());
+ assert!(s.execute("board.ink", &json!({})).is_err());
+ assert!(s.execute("board.sticky", &json!({"x": 0, "y": 0, "parent": c})).is_err(), "a connector holds no layers");
+}
+
+#[test]
+fn the_shape_stamp_highlighter_and_connector_tools_and_double_clicks() {
+ let mut s = board();
+ let click = |s: &mut Session, x, y| {
+ s.pointer(&PointerEvent::at(PointerKind::Down, x, y, 1.0)).unwrap();
+ s.pointer(&PointerEvent::at(PointerKind::Up, x, y, 1.0)).unwrap();
+ };
+ s.execute("tool.shape", &json!({"shape": "roundedRectangle"})).unwrap();
+ click(&mut s, 100.0, 100.0);
+ let sh = s.selection()[0];
+ assert_eq!(node(&s, sh).board, Some(BoardItem::Shape { shape: BoardShape::RoundedRectangle }));
+ assert_eq!(s.tool.tool, ToolId::Move, "back to Move after placing");
+ s.execute("tool.stamp", &json!({"stamp": "question"})).unwrap();
+ click(&mut s, 400.0, 100.0);
+ click(&mut s, 450.0, 100.0);
+ let stamps = s.doc().unwrap().nodes().filter(|n| matches!(n.board, Some(BoardItem::Stamp { stamp: Stamp::Question, .. }))).count();
+ assert_eq!(stamps, 2);
+ assert_eq!(s.tool.tool, ToolId::Stamp, "stamps go on one after another");
+ assert!(s.execute("tool.stamp", &json!({"stamp": "skull"})).is_err());
+ s.execute("tool.highlighter", &json!({"color": "pink"})).unwrap();
+ assert_eq!(Some(s.tool.board.highlighter), board_color("pink"));
+ s.execute("tool.marker", &json!({"color": "#336699"})).unwrap();
+ assert_eq!(s.tool.board.marker.to_hex(), "336699");
+ // A connector drag that is only a click, or from an object to itself, makes nothing.
+ s.execute("tool.connector", &json!({"style": "straight"})).unwrap();
+ click(&mut s, 100.0, 100.0);
+ s.pointer(&PointerEvent::at(PointerKind::Down, 60.0, 120.0, 1.0)).unwrap();
+ s.pointer(&PointerEvent::at(PointerKind::Move, 100.0, 140.0, 1.0)).unwrap();
+ assert!(s.tool.overlay.rubber.is_some(), "the rubber band shows while dragging");
+ s.pointer(&PointerEvent::at(PointerKind::Up, 100.0, 140.0, 1.0)).unwrap();
+ assert!(!s.doc().unwrap().nodes().any(|n| matches!(n.board, Some(BoardItem::Connector(_)))));
+ // From the shape out to empty canvas: a connector to a free point.
+ s.pointer(&PointerEvent::at(PointerKind::Down, 80.0, 140.0, 1.0)).unwrap();
+ s.pointer(&PointerEvent::at(PointerKind::Up, 80.0, 600.0, 1.0)).unwrap();
+ let c = s.doc().unwrap().nodes().find(|n| matches!(n.board, Some(BoardItem::Connector(_)))).map(|n| n.id).unwrap();
+ assert!(matches!(connector(&s, c).to, End::Point { .. }));
+ // Double-clicks: on the shape its text, on the connector a new label, both typed into.
+ s.execute("tool.move", &json!({})).unwrap();
+ s.execute("select.none", &json!({})).unwrap();
+ s.pointer(&PointerEvent::at(PointerKind::DoubleClick, 80.0, 140.0, 1.0)).unwrap();
+ let te = s.ds().unwrap().text_edit.clone().expect("typing in the shape");
+ assert_eq!(crate::board::owner_of_text(s.doc().unwrap(), te.id), Some(sh));
+ crate::textedit::end(&mut s).unwrap();
+ let line = drawn(&s, c);
+ let m = line[0].midpoint(line[1]);
+ s.pointer(&PointerEvent::at(PointerKind::DoubleClick, m.x, m.y, 1.0)).unwrap();
+ let label = crate::board::label_of(s.doc().unwrap(), c).expect("a label was added");
+ let te = s.ds().unwrap().text_edit.clone().expect("typing in the label");
+ assert_eq!(crate::board::owner_of_text(s.doc().unwrap(), te.id), Some(label));
+}
+
+#[test]
+fn an_ink_stroke_ends_where_the_button_comes_up() {
+ let mut s = board();
+ s.execute("tool.marker", &json!({})).unwrap();
+ // Down and up with no move between: the stroke still runs from the press to the release.
+ s.pointer(&PointerEvent::at(PointerKind::Down, 0.0, 0.0, 1.0)).unwrap();
+ s.pointer(&PointerEvent::at(PointerKind::Up, 150.0, 0.0, 1.0)).unwrap();
+ let doc = s.doc().unwrap();
+ let ink = doc.nodes().find(|n| matches!(n.board, Some(BoardItem::Ink))).map(|n| n.id).expect("a stroke");
+ let b = doc.world_bounds(ink).unwrap();
+ assert!(b.x0.abs() < 6.0 && (b.x1 - 150.0).abs() < 6.0, "from 0 to 150 (stroke width aside): {b:?}");
+}
+
+#[test]
+fn a_second_sticky_ends_the_first_ones_typing_and_undoes_alone() {
+ let mut s = board();
+ s.execute("tool.sticky", &json!({})).unwrap();
+ s.prefs.keep_tool = true;
+ s.pointer(&PointerEvent::at(PointerKind::Down, 100.0, 100.0, 1.0)).unwrap();
+ s.pointer(&PointerEvent::at(PointerKind::Up, 100.0, 100.0, 1.0)).unwrap();
+ let text = s.ds().unwrap().text_edit.as_ref().expect("typing in the new sticky").id;
+ crate::textedit::insert(&mut s, "first note").unwrap();
+ s.pointer(&PointerEvent::at(PointerKind::Down, 500.0, 100.0, 1.0)).unwrap();
+ s.pointer(&PointerEvent::at(PointerKind::Up, 500.0, 100.0, 1.0)).unwrap();
+ let stickies = |s: &Session| s.doc().unwrap().nodes().filter(|n| matches!(n.board, Some(BoardItem::Sticky { .. }))).count();
+ let typed = |s: &Session| s.doc().unwrap().node(text).unwrap().kind.text().unwrap().characters.clone();
+ assert_eq!(stickies(&s), 2);
+ crate::textedit::end(&mut s).unwrap();
+ s.undo().unwrap();
+ assert_eq!(stickies(&s), 1, "the second sticky is its own undo step");
+ assert_eq!(typed(&s), "first note", "the first sticky keeps what was typed in it");
+}
+
+#[test]
+fn a_board_tool_left_on_presses_as_move_in_a_design_file() {
+ let mut s = board();
+ s.execute("tool.sticky", &json!({})).unwrap();
+ s.execute("file.new", &json!({})).unwrap();
+ let r = id(&s.execute("shape.rectangle", &json!({"x": 0, "y": 0, "width": 100, "height": 100})).unwrap(), "id");
+ s.execute("select.none", &json!({})).unwrap();
+ s.pointer(&PointerEvent::at(PointerKind::Down, 50.0, 50.0, 1.0)).unwrap();
+ s.pointer(&PointerEvent::at(PointerKind::Up, 50.0, 50.0, 1.0)).unwrap();
+ assert_eq!(s.tool.tool, ToolId::Move);
+ assert_eq!(s.selection(), vec![r], "the press selected as Move does");
+}
diff --git a/crates/engine/src/booleans.rs b/crates/engine/src/booleans.rs
index 87d90153..c3de51cb 100644
--- a/crates/engine/src/booleans.rs
+++ b/crates/engine/src/booleans.rs
@@ -124,7 +124,7 @@ pub(crate) fn apply(s: &mut Session, cmd: &str, p: &Value, op: BoolOp) -> Result
}
return Ok(json!({"ids": ids, "operation": op}));
}
- let out = crate::cmd::structure::wrap_boolean(s, p, op)?;
+ let out = crate::cmd::structure::wrap_boolean(s, p, cmd, op)?;
// Operands of a new group follow its operation.
if let Some(g) = crate::params::id_of(&out["id"]) {
let doc = s.doc_mut()?;
diff --git a/crates/engine/src/bound_alpha_tests.rs b/crates/engine/src/bound_alpha_tests.rs
new file mode 100644
index 00000000..c54f0fb7
--- /dev/null
+++ b/crates/engine/src/bound_alpha_tests.rs
@@ -0,0 +1,153 @@
+//! A colour variable's alpha applies once to the paint it is bound to (#802): a `#RRGGBBAA` fill keeps
+//! its alpha in the paint opacity, and binding a variable with alpha hands the variable the whole
+//! colour, so the two alphas don't multiply (canvas, SVG, `.fig` round trips, mode switches).
+
+use figcraft_doc::NodeId;
+use serde_json::json;
+
+use crate::Session;
+
+/// 0x80 / 255 and 0x40 / 255.
+const HALF: f32 = 128.0 / 255.0;
+const QUARTER: f32 = 64.0 / 255.0;
+
+fn ex(s: &mut Session, cmd: &str, p: serde_json::Value) {
+ s.execute(cmd, &p).unwrap_or_else(|e| panic!("{cmd}: {e}"));
+}
+
+/// A rectangle filled `#0D6EFD80` and a colour variable `tint` (Light `light`, Dark `dark`).
+fn setup(light: &str, dark: &str) -> (Session, NodeId) {
+ let mut s = Session::new();
+ let r = s.execute("shape.rectangle", &json!({"x": 0, "y": 0, "width": 10, "height": 10, "props": {"fill": "#0D6EFD80"}})).unwrap();
+ let r = NodeId(r["id"].as_u64().unwrap());
+ ex(&mut s, "variable.createCollection", json!({"name": "Tokens", "modes": ["Light", "Dark"]}));
+ ex(&mut s, "variable.create", json!({"collection": "Tokens", "name": "tint", "type": "color", "value": light}));
+ ex(&mut s, "variable.set", json!({"variable": "tint", "mode": "Dark", "value": dark}));
+ (s, r)
+}
+
+/// The fill's effective alpha (colour alpha times paint opacity).
+fn alpha(s: &Session, r: NodeId) -> f32 {
+ s.doc().unwrap().node(r).unwrap().fills[0].solid_color().unwrap().a
+}
+
+/// The alpha byte of the rectangle rendered on its own (transparent backdrop).
+fn pixel_alpha(s: &Session, r: NodeId) -> u8 {
+ let pix = figcraft_render::render_node(s.doc().unwrap(), r, 1.0).unwrap();
+ let i = ((5 * pix.width() + 5) * 4 + 3) as usize;
+ pix.data()[i]
+}
+
+fn near(a: f32, b: f32) -> bool {
+ (a - b).abs() < 2e-3
+}
+
+#[test]
+fn a_hex_with_alpha_keeps_its_alpha_in_the_opacity() {
+ let (s, r) = setup("#0D6EFD80", "#0D6EFD40");
+ let p = &s.doc().unwrap().node(r).unwrap().fills[0];
+ assert_eq!(p.kind, figcraft_color::PaintKind::Solid { color: figcraft_color::Color::from_rgb8_const(0x0D, 0x6E, 0xFD) });
+ assert!(near(p.opacity, HALF));
+ assert_eq!(pixel_alpha(&s, r), 128);
+}
+
+#[test]
+fn a_bound_variable_alpha_applies_once() {
+ // The fill and the variable are both #0D6EFD80: the result is 50%, not 25%.
+ let (mut s, r) = setup("#0D6EFD80", "#0D6EFD40");
+ ex(&mut s, "variable.bind", json!({"ids": [r.0], "field": "fill", "variable": "tint"}));
+ assert!(near(alpha(&s, r), HALF), "{}", alpha(&s, r));
+ assert_eq!(pixel_alpha(&s, r), 128);
+ let svg = figcraft_svg::export_svg(s.doc().unwrap(), &[r], &figcraft_svg::SvgOptions::default()).unwrap();
+ assert!(svg.contains("fill=\"#0D6EFD\" fill-opacity=\"0.502\""), "{svg}");
+ // Binding the same variable again changes nothing.
+ ex(&mut s, "variable.bind", json!({"ids": [r.0], "field": "fill", "variable": "tint"}));
+ assert!(near(alpha(&s, r), HALF));
+}
+
+#[test]
+fn unbinding_keeps_the_colour_with_its_alpha_in_the_opacity() {
+ let (mut s, r) = setup("#0D6EFD40", "#0D6EFD");
+ ex(&mut s, "variable.bind", json!({"ids": [r.0], "field": "fill", "variable": "tint"}));
+ assert_eq!(pixel_alpha(&s, r), 64);
+ ex(&mut s, "variable.bind", json!({"ids": [r.0], "field": "fill", "variable": null}));
+ let p = &s.doc().unwrap().node(r).unwrap().fills[0];
+ assert_eq!(p.kind, figcraft_color::PaintKind::Solid { color: figcraft_color::Color::from_rgb8_const(0x0D, 0x6E, 0xFD) });
+ assert!(near(p.opacity, QUARTER), "{}", p.opacity);
+ assert_eq!(pixel_alpha(&s, r), 64);
+ // Undo restores the binding and its paint.
+ ex(&mut s, "edit.undo", json!({}));
+ assert!(!s.doc().unwrap().node(r).unwrap().bound.is_empty());
+ assert_eq!(pixel_alpha(&s, r), 64);
+}
+
+#[test]
+fn modes_switch_the_alpha_without_accumulating() {
+ let (mut s, r) = setup("#0D6EFD40", "#0D6EFD80");
+ ex(&mut s, "variable.bind", json!({"ids": [r.0], "field": "fill", "variable": "tint"}));
+ for (mode, want) in [("Dark", HALF), ("Light", QUARTER), ("Dark", HALF), ("Light", QUARTER)] {
+ ex(&mut s, "variable.setMode", json!({"collection": "Tokens", "mode": mode}));
+ assert!(near(alpha(&s, r), want), "{mode}: {}", alpha(&s, r));
+ }
+ // An opacity set while bound multiplies on top and survives mode switches.
+ ex(&mut s, "fill.set", json!({"ids": [r.0], "index": 0, "opacity": 0.5}));
+ ex(&mut s, "variable.setMode", json!({"collection": "Tokens", "mode": "Dark"}));
+ assert!(near(alpha(&s, r), HALF * 0.5));
+}
+
+#[test]
+fn node_set_and_style_bindings_apply_the_alpha_once() {
+ let (mut s, r) = setup("#0D6EFD80", "#0D6EFD40");
+ let var = s.doc().unwrap().variables.get("tint").unwrap().id.clone();
+ ex(&mut s, "node.set", json!({"id": r.0, "props": {"boundVariables": {"fill": var}}}));
+ assert!(near(alpha(&s, r), HALF));
+ ex(&mut s, "node.set", json!({"id": r.0, "props": {"boundVariables": {"fill": null}}}));
+ assert!(near(s.doc().unwrap().node(r).unwrap().fills[0].opacity, HALF));
+ // A paint style made from a `#RRGGBBAA` colour, bound to the variable.
+ let st = s.execute("style.create", &json!({"type": "paint", "name": "Tint", "value": "#0D6EFD80"})).unwrap()["id"].clone();
+ ex(&mut s, "style.bind", json!({"style": st, "field": "fills/0/color", "variable": "tint"}));
+ ex(&mut s, "style.apply", json!({"ids": [r.0], "style": st}));
+ assert!(near(alpha(&s, r), HALF), "{}", alpha(&s, r));
+}
+
+#[test]
+fn a_fig_round_trip_keeps_the_alpha_once() {
+ let (mut s, r) = setup("#0D6EFD80", "#0D6EFD40");
+ ex(&mut s, "variable.bind", json!({"ids": [r.0], "field": "fill", "variable": "tint"}));
+ ex(&mut s, "fill.set", json!({"ids": [r.0], "index": 0, "opacity": 0.5}));
+ let (bytes, _) = figcraft_format::fig::export(s.doc().unwrap(), None).unwrap();
+ let back = crate::cmd::file::load_fig(&bytes, "x").unwrap().unwrap().doc;
+ let n = back.nodes().find(|n| !n.bound.is_empty()).unwrap();
+ let a = n.fills[0].solid_color().unwrap().a;
+ assert!(near(a, HALF * 0.5), "{a}");
+}
+
+#[test]
+fn code_gives_a_translucent_stroke_its_alpha_once() {
+ let (mut s, r) = setup("#0D6EFD80", "#0D6EFD40");
+ ex(&mut s, "stroke.add", json!({"ids": [r.0], "color": "#FF000080"}));
+ let code = s.execute("inspect.code", &json!({"id": r.0})).unwrap()["code"].as_str().unwrap_or_default().to_string();
+ assert!(code.contains("solid rgba(255, 0, 0, 0.50)"), "{code}");
+}
+
+#[test]
+fn binding_keeps_an_opacity_set_on_the_paint() {
+ // A 15% tint whose colour comes from a variable (#923): the bind replaces the colour only.
+ let mut s = Session::new();
+ ex(&mut s, "variable.createCollection", json!({"name": "Tokens", "modes": ["Light"]}));
+ ex(&mut s, "variable.create", json!({"collection": "Tokens", "name": "red", "type": "color", "value": "#FF0000"}));
+ let props = json!({"fills": [{"type": "solid", "color": "#000000", "opacity": 0.15}]});
+ let r = s.execute("node.create", &json!({"type": "rectangle", "x": 0, "y": 0, "width": 10, "height": 10, "props": props})).unwrap();
+ let r = NodeId(r["id"].as_u64().unwrap());
+ ex(&mut s, "variable.bind", json!({"ids": [r.0], "field": "fill", "variable": "red"}));
+ let p = s.doc().unwrap().node(r).unwrap().fills[0].clone();
+ assert_eq!(p.kind, figcraft_color::PaintKind::Solid { color: figcraft_color::Color::from_rgb8_const(0xFF, 0, 0) });
+ assert!(near(p.opacity, 0.15), "{}", p.opacity);
+ ex(&mut s, "variable.bind", json!({"ids": [r.0], "field": "fill", "variable": null}));
+ assert!(near(s.doc().unwrap().node(r).unwrap().fills[0].opacity, 0.15));
+ // An opacity set on a `#RRGGBBAA` fill is the user's too, and stays.
+ let (mut s, r) = setup("#FF0000", "#FF0000");
+ ex(&mut s, "fill.set", json!({"ids": [r.0], "index": 0, "opacity": 0.25}));
+ ex(&mut s, "variable.bind", json!({"ids": [r.0], "field": "fill", "variable": "tint"}));
+ assert!(near(alpha(&s, r), 0.25), "{}", alpha(&s, r));
+}
diff --git a/crates/engine/src/catalog.rs b/crates/engine/src/catalog.rs
index 4b6cd3fc..5180b340 100644
--- a/crates/engine/src/catalog.rs
+++ b/crates/engine/src/catalog.rs
@@ -21,8 +21,9 @@ pub const SEP: &str = "-";
pub static MENU: &[MenuItem] = &[
// File
m!("File", "New design file", "file.new"),
- // FigCraft's own: starter templates (not counted by `parity`, like the other items of its own
- // listed in `OWN`).
+ m!("File", "New board", "file.newBoard"),
+ // FigCraft's own: boards and starter templates (not counted by `parity`, like the other items
+ // of its own listed in `OWN`).
m!("File", "New from template…", "file.newFromTemplate"),
m!("File", "New window", "window.new"),
m!("File", "Open…", "file.open"),
@@ -289,7 +290,7 @@ pub fn items() -> impl Iterator- {
}
/// Items of FigCraft's own that the parity count leaves out (as it does the `collab.` ones).
-const OWN: [&str; 3] = ["file.newFromTemplate", "help.gettingStarted", "text.missingFonts"];
+const OWN: [&str; 4] = ["file.newFromTemplate", "file.newBoard", "help.gettingStarted", "text.missingFonts"];
/// Coverage: (implemented, total, missing ids). `extra` lists ids implemented by the UI layer.
pub fn parity(extra: &[&str]) -> (usize, usize, Vec<&'static str>) {
diff --git a/crates/engine/src/cmd/arrange.rs b/crates/engine/src/cmd/arrange.rs
index ad6c21d1..10ad13e5 100644
--- a/crates/engine/src/cmd/arrange.rs
+++ b/crates/engine/src/cmd/arrange.rs
@@ -27,6 +27,13 @@ pub fn specs() -> Vec
{
spacing
),
spec!("arrange.tidy", "Tidy up", "{ids?, spacing?}", true, tidy),
+ spec!(
+ "arrange.reorder",
+ "Reorder selection",
+ "{ids?, source, target, swap?, fromGesture?} (insert at target's visual slot; no hierarchy changes)",
+ true,
+ reorder
+ ),
spec!("arrange.packH", "Pack horizontal", "{ids?}", true, |s, p| pack(s, p, true)),
spec!("arrange.packV", "Pack vertical", "{ids?}", true, |s, p| pack(s, p, false)),
spec!("arrange.roundToPixels", "Round to pixels", "{ids?}", true, round_px),
@@ -528,6 +535,7 @@ pub(crate) fn resize_cmd(s: &mut Session, p: &Value) -> Result {
let (col, row) = string(p, "anchor").and_then(|a| crate::tools::anchor_of(&a)).unwrap_or((0, 0));
let (ax, ay) = (f64::from(col) / 2.0, f64::from(row) / 2.0);
let doc = s.doc_mut()?;
+ let before = super::styles::bound_before(doc, &ids);
for i in ids {
let n = doc.get(i)?;
let (ow, oh) = (n.width, n.height);
@@ -551,6 +559,49 @@ pub(crate) fn resize_cmd(s: &mut Session, p: &Value) -> Result {
}
super::props::restore_worlds(doc, &kept)?;
}
+ super::styles::detach_edited(doc, &before);
+ ok()
+}
+
+/// Reorder visual slots without rebuilding or reparenting layers.
+fn reorder(s: &mut Session, p: &Value) -> Result {
+ let cmd = "arrange.reorder";
+ let ids = req_targets(cmd, s, p)?;
+ let source = req_id(cmd, p, "source")?;
+ let target = req_id(cmd, p, "target")?;
+ let ds = s.ds()?;
+ let base = ds.interaction.as_ref().filter(|_| boolean(p, "fromGesture") == Some(true)).map(|i| i.doc.clone()).unwrap_or_else(|| ds.doc.clone());
+ let layout =
+ crate::selection_reorder::ReorderLayout::new(&base, &ids).ok_or_else(|| bad(cmd, "select a regular row, column or complete aligned grid"))?;
+ let positions = layout
+ .positions(source, target, boolean(p, "swap") == Some(true))
+ .ok_or_else(|| bad(cmd, "source and target must belong to the selection"))?;
+ // Validate every delta before editing; absolute targets always come from the gesture's
+ // snapshot so crossing several slots and returning to the start does not accumulate edits.
+ let doc = s.doc()?;
+ let mut moves = Vec::new();
+ for (id, at) in positions {
+ let now = doc.world_bounds(id).ok_or_else(|| bad(cmd, "layer is no longer available"))?;
+ let (dx, dy) = (at.x - now.x0, at.y - now.y0);
+ if !dx.is_finite() || !dy.is_finite() {
+ return Err(bad(cmd, "non-finite reorder result"));
+ }
+ if dx.abs() > 1e-9 || dy.abs() > 1e-9 {
+ let node = doc.get(id)?;
+ let parent = node.parent.map(|p| doc.world_transform(p)).unwrap_or(Affine::IDENTITY);
+ let transform = parent.inverse() * Affine::translate((dx, dy)) * parent * node.transform;
+ if !transform.as_coeffs().iter().all(|v| v.is_finite()) {
+ return Err(bad(cmd, "non-finite local transform"));
+ }
+ moves.push((id, dx, dy));
+ }
+ }
+ if !moves.is_empty() {
+ let doc = s.doc_mut()?;
+ for (id, dx, dy) in moves {
+ move_world(doc, id, dx, dy)?;
+ }
+ }
ok()
}
diff --git a/crates/engine/src/cmd/component.rs b/crates/engine/src/cmd/component.rs
index ff7a56df..01914640 100644
--- a/crates/engine/src/cmd/component.rs
+++ b/crates/engine/src/cmd/component.rs
@@ -56,11 +56,17 @@ pub fn specs() -> Vec {
s.set_selection(out.iter().filter_map(id_of).collect());
Ok(json!({"ids": out}))
}),
- spec!("component.combineVariants", "Combine as variants", "{ids? (components)}", true, combine),
+ spec!(
+ "component.combineVariants",
+ "Combine as variants",
+ "{ids? (main components; none already a variant, a library copy or inside an instance)} (wraps them in a new component set; names without `=` become \"Property 1=Default\", \"Property 1=VariantN\")",
+ true,
+ combine
+ ),
spec!(
"component.addVariant",
"Add variant",
- "{id? (component set or variant), property?, value?} (duplicates the variant; `property`=`value` names the new one)",
+ "{id? (component set, variant, or a main component not in a set yet: it becomes a set of itself and the new variant), property?, value?} (duplicates the variant; `property`=`value` names the new one)",
true,
add_variant
),
@@ -159,7 +165,7 @@ pub fn specs() -> Vec {
spec!(
"component.resetOverride",
"Reset override",
- "{id?, group? (fills|strokes|effects|opacity|visible|name|corners|characters|textStyle|padding|gap|alignment|grids|exports|interactions|size|position|component|props|slot; all when omitted)}",
+ "{id?, group? (fills|strokes|effects|opacity|visible|name|corners|characters|textStyle|padding|gap|alignment|grids|exports|interactions|size|position|modes|component|props|slot; all when omitted)}",
true,
reset_override
),
@@ -330,23 +336,25 @@ fn create(s: &mut Session, p: &Value) -> Result {
Ok(json!({"id": target}))
}
+/// The name a new component set takes from its first variant: the path before the last '/'
+/// ("Button/State=Hover" → "Button"), or a plain name as is ("Button"). A bare "prop=value" name
+/// ("State=Default, Size=Small") names no set.
+fn set_name_from(variant: &str) -> Option {
+ let base = variant.rsplit_once('/').map_or(variant, |(path, _)| path).trim();
+ (!base.is_empty() && !base.contains('=')).then(|| base.to_string())
+}
+
/// Wrap components in a new component set (named after the first) placed around them.
-fn wrap_in_set(doc: &mut Document, ids: &[NodeId]) -> Result {
- let cmd = "component.combineVariants";
+fn wrap_in_set(cmd: &str, doc: &mut Document, ids: &[NodeId]) -> Result {
let top = *ids.last().ok_or_else(|| bad(cmd, "nothing selected"))?;
let parent = doc.get(top)?.parent.ok_or_else(|| bad(cmd, "page"))?;
if inside_instance(doc, top) || owning_instance(doc, parent).is_some() {
- return Err(EngineError::Disabled(cmd.into(), "components inside an instance can't be combined".into()));
+ return Err(EngineError::Disabled(cmd.into(), INSIDE_INSTANCE.into()));
}
let bounds = doc.bounds_of(ids).unwrap_or_default();
let pw = doc.world_transform(parent);
let local = figcraft_geom::transform_rect_bbox(pw.inverse(), bounds.inflate(20.0, 20.0));
- let base = ids
- .first()
- .and_then(|i| doc.node(*i))
- .map(|n| n.name.split(['/', '=']).next().unwrap_or("Component").trim().to_string())
- .filter(|n| !n.is_empty() && !n.contains(','))
- .unwrap_or_else(|| "Component".into());
+ let base = ids.first().and_then(|i| doc.node(*i)).and_then(|n| set_name_from(&n.name)).unwrap_or_else(|| doc.next_name("Component"));
let set = doc.alloc_id();
let mut n = Node::new(set, NodeKind::ComponentSet { description: String::new() }, base, local.width(), local.height());
n.transform = figcraft_geom::Affine::translate((local.x0, local.y0));
@@ -358,22 +366,71 @@ fn wrap_in_set(doc: &mut Document, ids: &[NodeId]) -> Result {
Ok(set)
}
-fn combine(s: &mut Session, p: &Value) -> Result {
- let cmd = "component.combineVariants";
- let ids = req_targets(cmd, s, p)?;
- let doc = s.doc_mut()?;
+const INSIDE_INSTANCE: &str = "components inside an instance can't become variants";
+
+/// Why `ids` (distinct) can't become the variants of a new component set, or `None` when they
+/// can: anything but main components, components that are variants already (combining them would
+/// put a set in a set), library copies, components inside an instance, and a component inside
+/// another one of `ids`.
+fn combine_refusal(doc: &Document, ids: &[NodeId]) -> Option<&'static str> {
if !ids.iter().all(|i| doc.node(*i).is_some_and(|n| matches!(n.kind, NodeKind::Component { .. }))) {
- return Err(bad(cmd, "select components only"));
+ Some("select components only")
+ } else if ids.iter().any(|i| variant_set(doc, *i).is_some()) {
+ Some("components that are variants already can't be combined again")
+ } else if ids.iter().any(|i| doc.is_remote(*i)) {
+ Some(crate::library::READ_ONLY)
+ } else if ids.iter().any(|i| inside_instance(doc, *i)) {
+ Some(INSIDE_INSTANCE)
+ } else if roots(doc, ids).len() != ids.len() {
+ Some("a component can't be combined with one inside it")
+ } else {
+ None
}
- let ids = z_sorted(doc, &ids);
- let set = wrap_in_set(doc, &ids)?;
+}
+
+/// Whether "Combine as variants" is on offer for `ids` (menus and the Design panel): two or more
+/// main components that [`combine_refusal`] lets through.
+pub fn can_combine_variants(doc: &Document, ids: &[NodeId]) -> bool {
+ ids.len() >= 2 && combine_refusal(doc, ids).is_none() && ids.iter().collect::>().len() == ids.len()
+}
+
+/// Whether "Add variant" is on offer for `id`: a component set with variants, a variant, or a main
+/// component not in a set yet (it becomes one); never a library copy or inside an instance.
+pub fn can_add_variant(doc: &Document, id: NodeId) -> bool {
+ let Some(n) = doc.node(id) else { return false };
+ let local = !doc.is_remote(id) && !inside_instance(doc, id);
+ match n.kind {
+ NodeKind::ComponentSet { .. } => {
+ local && n.children.iter().any(|c| doc.node(*c).is_some_and(|c| matches!(c.kind, NodeKind::Component { .. })))
+ }
+ NodeKind::Component { .. } => local,
+ _ => false,
+ }
+}
+
+/// Wrap `ids` (z-sorted main components) in a new component set, naming them "Property 1=Default",
+/// "Property 1=VariantN" unless already in prop=value form. Returns the set.
+fn make_variant_set(cmd: &str, doc: &mut Document, ids: &[NodeId]) -> Result {
+ let set = wrap_in_set(cmd, doc, ids)?;
for (k, i) in ids.iter().enumerate() {
- // Name variants "Property 1=Variant N" unless already in prop=value form.
let node = doc.get_mut(*i)?;
if !node.name.contains('=') {
node.name = format!("Property 1={}", if k == 0 { "Default".to_string() } else { format!("Variant{}", k + 1) });
}
}
+ Ok(set)
+}
+
+fn combine(s: &mut Session, p: &Value) -> Result {
+ let cmd = "component.combineVariants";
+ let mut seen = BTreeSet::new();
+ let ids: Vec = req_targets(cmd, s, p)?.into_iter().filter(|i| seen.insert(*i)).collect();
+ let doc = s.doc_mut()?;
+ if let Some(why) = combine_refusal(doc, &ids) {
+ return Err(EngineError::Disabled(cmd.into(), why.into()));
+ }
+ let ids = z_sorted(doc, &ids);
+ let set = make_variant_set(cmd, doc, &ids)?;
s.set_selection(vec![set]);
Ok(json!({"id": set}))
}
@@ -397,15 +454,19 @@ fn fit_set(doc: &mut Document, set: NodeId) {
fn add_variant(s: &mut Session, p: &Value) -> Result {
let cmd = "component.addVariant";
- let t = targets(s, p).first().copied().ok_or_else(|| bad(cmd, "select a component set or variant"))?;
+ let t = targets(s, p).first().copied().ok_or_else(|| bad(cmd, "select a component set or component"))?;
let doc = s.doc_mut()?;
let (set, base) = match doc.get(t)?.kind {
NodeKind::ComponentSet { .. } => {
let last = doc.get(t)?.children.last().copied().ok_or_else(|| bad(cmd, "the component set is empty"))?;
(t, last)
}
- NodeKind::Component { .. } => (variant_set(doc, t).ok_or_else(|| bad(cmd, "the component isn't a variant (combine as variants first)"))?, t),
- _ => return Err(bad(cmd, "select a component set or variant")),
+ NodeKind::Component { .. } => match variant_set(doc, t) {
+ Some(set) => (set, t),
+ // A main component on its own becomes a set of itself, then gains the new variant.
+ None => (make_variant_set(cmd, doc, &[t])?, t),
+ },
+ _ => return Err(bad(cmd, "select a component set or component")),
};
let options = variant_options(doc, set);
let mut pairs = variant_props(&doc.get(base)?.name);
@@ -472,6 +533,7 @@ fn detach(s: &mut Session, p: &Value) -> Result {
// Own layers lose their link (slot content stays as it is); nested instances stay
// instances of their own mains.
let nested = unlink_layers(doc, i, Some(i));
+ keep_main_modes(doc, i)?;
let n = doc.get_mut(i)?;
n.kind = NodeKind::Frame;
n.source = None;
@@ -491,6 +553,19 @@ fn detach(s: &mut Session, p: &Value) -> Result {
Ok(json!({"ids": out}))
}
+/// Make the variable modes instance `i` takes from its main its own (it's being detached).
+fn keep_main_modes(doc: &mut Document, i: NodeId) -> Result<()> {
+ let modes = match doc.get(i)?.kind {
+ NodeKind::Instance { component, .. } => doc.node(component).map(|m| m.var_modes.clone()).unwrap_or_default(),
+ _ => return Ok(()),
+ };
+ let own = &mut doc.get_mut(i)?.var_modes;
+ for (c, m) in modes {
+ own.entry(c).or_insert(m);
+ }
+ Ok(())
+}
+
fn reset_instance(s: &mut Session, p: &Value) -> Result {
let cmd = "component.resetInstance";
let ids = req_targets(cmd, s, p)?;
@@ -608,7 +683,7 @@ fn make_slot(s: &mut Session, p: &Value) -> Result {
let owner = Owner::resolve(doc, id).ok_or_else(|| bad(cmd, "the frame isn't inside a component"))?;
let name = string(p, "name").unwrap_or_else(|| fresh_prop_name(doc, &owner, &n.name));
let preferred = get(p, "preferred").cloned().unwrap_or(Value::Null);
- add_prop(s, &json!({"id": id, "layer": id, "name": name, "type": "slot", "preferred": preferred}))
+ add_prop_for(cmd, s, &json!({"id": id, "layer": id, "name": name, "type": "slot", "preferred": preferred}))
}
fn remove_slot(s: &mut Session, p: &Value) -> Result {
@@ -1039,7 +1114,12 @@ fn valid_prop_name(cmd: &str, name: &str) -> Result {
}
fn add_prop(s: &mut Session, p: &Value) -> Result {
- let cmd = "component.addProperty";
+ add_prop_for("component.addProperty", s, p)
+}
+
+/// Add a component property for command `cmd`, which errors name (`component.makeSlot` adds its
+/// slot property here).
+fn add_prop_for(cmd: &str, s: &mut Session, p: &Value) -> Result {
let target = targets(s, p).first().copied().ok_or_else(|| bad(cmd, "select a component"))?;
let name = valid_prop_name(cmd, &req_string(cmd, p, "name")?)?;
let t = req_string(cmd, p, "type")?;
@@ -1084,7 +1164,7 @@ fn add_prop(s: &mut Session, p: &Value) -> Result
+
+ 
+ 
