b45255bb6fe2
props.rs
//! Property editing: `node.set` and the shorthand keys every surface uses.
use figcraft_color::{Color, Paint};
use figcraft_doc::{
AutoLayout, Brush, ChildLayout, DecorationStyle, DevStatus, Document, Effect, GridTrack, LayoutMode, LetterSpacing, LineHeight, ListStyle,
MAX_LIST_INDENT, MaskType, Node, NodeId, NodeKind, Sizing, StrokeCap, StrokeProps, TextAutoResize, TextCase, TextData, TextDecoration,
WidthPoint, WidthPreset, WidthProfile, style_weight, valid_axis_tag, valid_feature_tag,
};
use figcraft_geom::{Affine, Point};
use serde_json::{Map, Value, json};
use crate::params::{bool_of, color_of, f64_of, fraction_of, get, paints_of};
use crate::{Result, bad};
/// The per-side stroke weight keys, in `StrokeProps::sides` order (top, right, bottom, left).
pub const STROKE_SIDES: [&str; 4] = ["strokeTopWeight", "strokeRightWeight", "strokeBottomWeight", "strokeLeftWeight"];
/// Keys `node.set` understands (documented for agents).
pub const KEYS: &str = "name, visible, locked, opacity (0-1 or \"50%\"), blend, x, y (relative to the parent frame; groups don't count), width, height, rotation (degrees), absoluteRotation (degrees on the page: the layer's angle plus its parents', what the Design panel's field shows; one of the two per call), \
fills (paints or colours; gradients as {type: linearGradient|radialGradient|angularGradient|diamondGradient, stops: [\"#hex\", ...], from?, to?} too), fill (colour, {$var: variable id or name}, or \"none\"/null: no fill), strokes, stroke (colour, {$var: variable id or name}, or \"none\"/null: no stroke), strokeWeight, strokeAlign (inside|center|outside), strokeSides [t,r,b,l], strokeTopWeight / strokeRightWeight / strokeBottomWeight / strokeLeftWeight (one side; turns on individual strokes), \
strokeCap / startCap / endCap, strokeJoin, miterAngle (degrees: sharper joins bevel; or miterLimit as a ratio), dashes [..], dashCap (none|round|square; null: dashes take startCap and endCap), widthProfile (preset uniform|wedge|taper|eye|rounded|pinch, [[t, scale], ...] or null), brush (preset id, {preset, spacing, sizeJitter, rotationJitter, scatter, seed} or null), cornerRadius (n or [tl,tr,br,bl]), cornerSmoothing (0-1), effects, \
clip, isMask, layout (null|horizontal|vertical|grid|{...}), gap, crossGap, padding (n or [t,r,b,l]), paddingTop/Right/Bottom/Left, \
mainAlign (min|center|max, or the auto gaps spaceBetween|spaceAround|spaceEvenly), crossAlign (min|center|max|baseline: first text baselines, horizontal layouts), contentAlign (wrapped lines: auto = packed where crossAlign says | spaceBetween), wrap (rows of a horizontal layout, columns of a vertical one), strokesIncluded (the frame's inside stroke takes up space), reverseZ (canvas stacking: true = first on top), \
columnGap / rowGap (aliases of gap / crossGap), gridColumns, gridRows, columnTracks / rowTracks ([120 | \"1fr\" | \"auto\" | {sizing, value}]), \
gridColumn / gridRow (0-based cell anchor, null = auto), gridColumnSpan, gridRowSpan, gridAlignH / gridAlignV (a grid child's alignment in its cell: min|center|max, auto/null = the frame's), sizingH / sizingV (fixed|hug|fill), \
absolute (ignore auto layout; follows constraints), minWidth, maxWidth, minHeight, maxHeight (null removes), constraints {horizontal, vertical}, grids, exports, characters, fontFamily, fontStyle, \
fontSize, lineHeight (auto|px|\"150%\"), letterSpacing (px|\"2%\"), textAlign (left|center|right|justified), textAlignVertical, textAutoResize \
(widthAndHeight|height|none|truncate), textDecoration, textDecorationStyle (solid|dotted|wavy), textDecorationThickness / textDecorationOffset \
(auto|px|\"10%\" of the font size; the offset runs from the baseline down to an underline's top edge), textDecorationSkipInk (underlines break around descenders), \
textDecorationColor (colour, or auto/null: the text's), textCase (original|upper|lower|title|smallCaps), paragraphSpacing, paragraphIndent, \
listStyle (none|bulleted|numbered; with start/end: the paragraphs those chars touch), indentation (list nesting level 0-8, same range rule), \
listSpacing (px between list items, in place of paragraphSpacing), wrapStyle (auto|balance|pretty; with start/end: the paragraphs those chars touch), hangingPunctuation, hangingList (markers outside the box), leadingTrim (vertical trim: none|capHeight), maxLines, features ({tag: bool}, e.g. {\"liga\": false, \"tnum\": true}), \
fontVariations / variationSettings ({axis: number}, e.g. {\"wght\": 550, \"wdth\": 85}; null = none), \
path (a vector's SVG path data: replaces its geometry, keeping the layer, its paints, styles and bindings; width/height in the same call scale it as \
node.create does; its own box goes at the layer's x/y, or with x/y given, at x + its left edge and y + its top as node.create places it), pointCount, innerRadius, arcStart, arcSweep, \
arcInner, booleanOperation (a boolean group's operation, or an operand's own; null: the group's), operandOperation (a layer in a boolean \
group: how it combines with the operands below it; null: the group's), constrainProportions, description, interactions, overflow, pluginData {k: v}";
/// CRLF, bare CR, U+2028 and U+2029 become LF, the only line ending text layout understands (editor insertion does the same).
pub(crate) fn normalize_line_endings(s: &str) -> String {
s.replace("\r\n", "\n").replace(['\r', '\u{2028}', '\u{2029}'], "\n")
}
/// The name a text layer derives from its characters: the first line, at most 64 characters, or
/// None when that line is blank (a layer with no name of its own, which the Layers panel shows by
/// its kind).
///
/// A layer whose name is this derived name is one nobody has renamed, so the editor keeps its name
/// in step as the characters are typed ([`crate::textedit`]); any other name was chosen by the
/// author and is kept. Commands never rename, so a layer named for its role keeps that name as a
/// field key even when `characters` replace text that reads like it.
pub(crate) fn text_layer_name(characters: &str) -> Option<String> {
let first: String = characters.lines().next().unwrap_or("").chars().take(64).collect();
(!first.trim().is_empty()).then_some(first)
}
/// Whether `name` is one a text layer was given for its characters rather than by its author, so
/// the editor may keep it in step with them. Blank text leaves a layer named `""` when the Text
/// tool draws it and `Text` when `node.create` makes it, and both read as unnamed in the panel.
pub(crate) fn text_name_is_derived(name: &str, derived: Option<&String>) -> bool {
match derived {
Some(d) => name == d,
// `NodeKind::Text(_).label()`, which the panel falls back to for an unnamed layer.
None => name.is_empty() || name == "Text",
}
}
/// camelCase object keys โ snake_case (accept the inspect/camel forms for serde-backed values).
pub fn snake(v: &Value) -> Value {
match v {
Value::Object(m) => Value::Object(
m.iter()
.map(|(k, v)| {
let mut out = String::new();
for c in k.chars() {
if c.is_ascii_uppercase() {
out.push('_');
out.push(c.to_ascii_lowercase());
} else {
out.push(c);
}
}
// Paint/effect type tags stay as they are.
let key = if matches!(k.as_str(), "type" | "kind") { k.clone() } else { out };
(key, if matches!(k.as_str(), "type" | "kind") { v.clone() } else { snake(v) })
})
.collect(),
),
Value::Array(a) => Value::Array(a.iter().map(snake).collect()),
other => other.clone(),
}
}
/// `v` as an effect list, refusing keys an effect doesn't read: serde dropped them without a word,
/// so a shadow given `offsetY` kept the default offset.
pub fn effects_from(cmd: &str, v: &Value) -> Result<Vec<Effect>> {
let effects: Vec<Effect> = serde_json::from_value(snake(v)).map_err(|e| bad(cmd, format!("effects: {e}")))?;
for (i, given) in v.as_array().into_iter().flatten().enumerate() {
refuse_ignored_effect_keys(cmd, &format!("effects[{i}]"), given, |v| serde_json::from_value(snake(v)).ok())?;
}
Ok(effects)
}
/// `p[key]` as one effect, read as serde reads it (its aliases too), refusing keys it doesn't read.
pub fn effect_from(cmd: &str, p: &Value, key: &str) -> Result<Option<Effect>> {
let Some(v) = get(p, key) else { return Ok(None) };
let effect: Effect = serde_json::from_value(v.clone()).map_err(|e| bad(cmd, format!("`{key}`: {e}")))?;
refuse_ignored_effect_keys(cmd, &format!("`{key}`"), v, |v| serde_json::from_value(v.clone()).ok())?;
Ok(Some(effect))
}
/// Most keys an effect object may carry (the widest effect takes about a dozen).
const MAX_EFFECT_KEYS: usize = 32;
/// Refuse the keys of effect `given` that `parse` ignores, naming the keys the effect takes. Set to
/// null, a key it reads fails to parse or changes the effect; a key it ignores changes nothing.
fn refuse_ignored_effect_keys(cmd: &str, at: &str, given: &Value, parse: impl Fn(&Value) -> Option<Effect>) -> Result<()> {
let Some(fields) = given.as_object() else { return Ok(()) };
// Each key is probed by reparsing the whole object without it: bounded, or a long list of
// unknown keys costs its length squared before it is refused.
if fields.len() > MAX_EFFECT_KEYS {
return Err(bad(cmd, format!("{at}: more than {MAX_EFFECT_KEYS} properties")));
}
let parsed = parse(given);
let ignored: Vec<&str> = fields
.iter()
.filter(|(_, v)| !v.is_null())
.filter(|(k, _)| {
let mut probe = fields.clone();
probe.insert((*k).clone(), Value::Null);
parse(&Value::Object(probe)).is_some_and(|e| Some(e) == parsed)
})
.map(|(k, _)| k.as_str())
.collect();
if ignored.is_empty() {
return Ok(());
}
let takes = parsed.and_then(|e| serde_json::to_value(e).ok()).map(crate::inspect::camel).unwrap_or_default();
let kind = takes.get("type").and_then(Value::as_str).unwrap_or("effect").to_string();
let names: Vec<&str> = takes.as_object().into_iter().flatten().map(|(k, _)| k.as_str()).collect();
Err(bad(cmd, format!("{at}: unknown properties: {} (a {kind} takes {})", ignored.join(", "), names.join(", "))))
}
pub(crate) fn enum_of<T: serde::de::DeserializeOwned>(v: &Value) -> Option<T> {
let s = v.as_str()?;
// Accept camelCase, snake/upper-case and spaced variants.
let norm: String = {
let mut out = String::new();
let mut up = false;
// Once, not per character: a long value made this quadratic before it was refused.
let no_lowercase = s.chars().all(|c| !c.is_lowercase() || !c.is_alphabetic());
for (i, ch) in s.trim().chars().enumerate() {
if ch == '_' || ch == '-' || ch == ' ' {
up = true;
continue;
}
if i == 0 {
out.extend(ch.to_lowercase());
} else if up {
out.extend(ch.to_uppercase());
up = false;
} else if no_lowercase {
out.extend(ch.to_lowercase());
} else {
out.push(ch);
}
}
out
};
serde_json::from_value(Value::String(norm)).ok()
}
pub(crate) fn sizing(v: &Value) -> Option<Sizing> {
match v.as_str()?.to_ascii_lowercase().as_str() {
"fixed" => Some(Sizing::Fixed),
"hug" | "auto" | "hug contents" => Some(Sizing::Hug),
"fill" | "fill container" | "stretch" => Some(Sizing::Fill),
_ => None,
}
}
pub(crate) fn line_height(v: &Value) -> Option<LineHeight> {
match v {
Value::String(s) if s.eq_ignore_ascii_case("auto") => Some(LineHeight::Auto),
Value::String(s) if s.trim().ends_with('%') => {
s.trim().trim_end_matches('%').trim().parse().ok().filter(|f: &f64| f.is_finite()).map(LineHeight::Percent)
}
Value::Object(_) => serde_json::from_value(v.clone()).ok(),
other => f64_of(other).map(LineHeight::Pixels),
}
}
pub(crate) fn letter_spacing(v: &Value) -> Option<LetterSpacing> {
match v {
Value::String(s) if s.trim().ends_with('%') => {
s.trim().trim_end_matches('%').trim().parse().ok().filter(|f: &f64| f.is_finite()).map(LetterSpacing::Percent)
}
Value::Object(_) => serde_json::from_value(v.clone()).ok(),
other => f64_of(other).map(LetterSpacing::Pixels),
}
}
fn four(v: &Value) -> Option<[f64; 4]> {
match v {
Value::Array(a) => {
let f: Vec<f64> = a.iter().map(f64_of).collect::<Option<_>>()?;
match f.as_slice() {
[x] => Some([*x; 4]),
[a, b] => Some([*a, *b, *a, *b]),
[a, b, c, d] => Some([*a, *b, *c, *d]),
_ => None,
}
}
other => f64_of(other).map(|x| [x; 4]),
}
}
const BOOL_OP_HELP: &str = "booleanOperation / operandOperation: union|subtract|intersect|exclude (null: the group's, for operands)";
/// An operand's own boolean operation (`null`: its group's).
fn set_operand_op(doc: &mut Document, id: NodeId, v: &Value, cmd: &str) -> Result<()> {
if crate::booleans::group_of(doc, id).is_none() {
return Err(bad(cmd, "not a boolean group or a layer in one"));
}
doc.get_mut(id)?.bool_op = if v.is_null() { None } else { Some(enum_of(v).ok_or_else(|| bad(cmd, BOOL_OP_HELP))?) };
Ok(())
}
pub(crate) const WIDTH_PROFILE_HELP: &str = "widthProfile: a preset (uniform|wedge|taper|eye|rounded|pinch), points [[t (0-1 along the path), scale (ร stroke weight)] | [t, left, right] (one-sided: each side's scale, looking along the path), ...] or [{t, scale} | {t, left, right}], {preset} | {points}, or null (uniform)";
/// The stroke caps `strokeCap`, `startCap` and `endCap` take (every [`StrokeCap`]).
pub(crate) const STROKE_CAP_HELP: &str = "none|round|square|lineArrow|triangleArrow|reversedTriangle|circleFilled|diamondFilled";
pub(crate) const BRUSH_HELP: &str = "brush: a preset (taper|ink|ribbon|bristle: stretched; dots|stars|confetti|leaves: scattered), {preset, spacing? (ร weight), sizeJitter? (0-1), rotationJitter? (0-1), scatter? (0-4 ร weight), seed?}, or null (a plain stroke)";
/// A brush from a preset id, `{preset, spacing?, sizeJitter?, rotationJitter?, scatter?, seed?}`
/// or null. `Some(None)` = no brush; `None` = not a brush (or an unknown preset).
pub fn brush_of(v: &Value) -> Option<Option<Brush>> {
let b = match v {
Value::Null => return Some(None),
Value::String(id) => Brush::new(id.as_str()),
Value::Object(_) => serde_json::from_value::<Brush>(snake(v)).ok()?,
_ => return None,
};
figcraft_pathops::brush::preset(&b.preset).map(|_| Some(b.sanitized()))
}
/// A width profile from a preset name, points (`[[t, scale] | [t, left, right], ...]` or
/// `[{t, scale} | {t, left, right}]`), `{preset}` / `{points}`, or null. `Some(None)` = uniform;
/// `None` = not a profile.
pub fn width_profile_of(v: &Value) -> Option<Option<WidthProfile>> {
match v {
Value::Null => Some(None),
Value::String(s) => WidthPreset::from_id(s).map(WidthPreset::profile),
Value::Array(a) => {
let num = |x: Option<&Value>| x.and_then(f64_of);
let points = a
.iter()
.map(|p| match p {
Value::Array(xy) => match (num(xy.first()), num(xy.get(1)), num(xy.get(2))) {
(Some(t), Some(l), Some(r)) => Some(WidthPoint::from_sides(t, l, r)),
(Some(t), Some(s), None) => Some(WidthPoint::new(t, s)),
_ => None,
},
Value::Object(o) => {
let t = num(o.get("t"))?;
match (num(o.get("left")), num(o.get("right"))) {
(Some(l), Some(r)) => Some(WidthPoint::from_sides(t, l, r)),
_ => Some(WidthPoint::new(t, num(o.get("scale").or_else(|| o.get("width")))?)),
}
}
_ => None,
})
.collect::<Option<Vec<_>>>()?;
Some(Some(WidthProfile { points }.sanitized()).filter(|p| !p.points.is_empty()))
}
Value::Object(o) => o.get("points").or_else(|| o.get("preset")).and_then(width_profile_of),
_ => None,
}
}
/// A width point as [`width_profile_of`] reads it back: `[t, scale]`, or `[t, left, right]` when
/// its sides differ.
pub fn width_point_json(p: &WidthPoint) -> Value {
if p.symmetric() {
json!([p.t, p.scale])
} else {
let (l, r) = p.sides();
json!([p.t, l, r])
}
}
/// A profile's points as [`width_profile_of`] reads them back (`null` without points).
pub fn width_points_json(profile: Option<&WidthProfile>) -> Value {
match profile.filter(|p| !p.points.is_empty()) {
Some(p) => Value::Array(p.points.iter().map(width_point_json).collect()),
None => Value::Null,
}
}
const TRACK_HELP: &str = "tracks: [px | \"120px\" | \"1fr\" | \"auto\" (hug) | {sizing: fixed|hug|fill, value}]";
/// One grid track from `120` / `"120px"` (fixed), `"2fr"` / `"fill"` (fill), `"auto"` / `"hug"`,
/// or `{sizing, value}`.
pub fn track_of(v: &Value) -> Option<GridTrack> {
match v {
Value::Number(_) => f64_of(v).map(|px| GridTrack::fixed(px.clamp(0.0, 1e6))),
Value::String(s) => {
let s = s.trim().to_ascii_lowercase();
match s.as_str() {
"auto" | "hug" => Some(GridTrack::hug()),
"fill" => Some(GridTrack::fill(1.0)),
_ => match s.strip_suffix("fr") {
Some(fr) => fr.trim().parse::<f64>().ok().filter(|f| f.is_finite()).map(|f| GridTrack::fill(f.clamp(0.0, 1e4))),
None => f64_of(&Value::String(s)).map(|px| GridTrack::fixed(px.clamp(0.0, 1e6))),
},
}
}
Value::Object(o) => {
let s = o.get("sizing").or_else(|| o.get("type")).and_then(sizing)?;
let val = o.get("value").or_else(|| o.get("size")).and_then(f64_of);
Some(match s {
Sizing::Fixed => GridTrack::fixed(val?.clamp(0.0, 1e6)),
Sizing::Hug => GridTrack::hug(),
Sizing::Fill => GridTrack::fill(val.unwrap_or(1.0).clamp(0.0, 1e4)),
})
}
_ => None,
}
}
/// Set one min/max limit (`None` removes it), keeping min โค max by moving the other limit.
pub fn set_limit(cl: &mut ChildLayout, key: &str, val: Option<f64>) {
let (target, other, is_min) = match key {
"minWidth" => (&mut cl.min_w, &mut cl.max_w, true),
"maxWidth" => (&mut cl.max_w, &mut cl.min_w, false),
"minHeight" => (&mut cl.min_h, &mut cl.max_h, true),
_ => (&mut cl.max_h, &mut cl.min_h, false),
};
*target = val;
if let (Some(v), Some(o)) = (val, *other)
&& (is_min && o < v || !is_min && o > v)
{
*other = Some(v);
}
}
fn text_mut<'a>(cmd: &str, n: &'a mut Node) -> Result<&'a mut TextData> {
let id = n.id;
n.kind.text_mut().ok_or_else(|| bad(cmd, format!("node {id} is not text")))
}
fn ensure_layout(n: &mut Node) -> &mut AutoLayout {
n.layout.get_or_insert_with(|| AutoLayout { padding: [0.0; 4], gap: 0.0, ..Default::default() })
}
/// The keys that set a frame's auto layout (through [`layout_mut`]).
pub const LAYOUT_KEYS: &[&str] = &[
"gap",
"itemSpacing",
"columnGap",
"crossGap",
"counterAxisSpacing",
"rowGap",
"padding",
"paddingTop",
"paddingRight",
"paddingBottom",
"paddingLeft",
"paddingHorizontal",
"paddingVertical",
"mainAlign",
"primaryAxisAlignItems",
"crossAlign",
"counterAxisAlignItems",
"contentAlign",
"counterAxisAlignContent",
"wrap",
"gridColumns",
"gridRows",
"strokesIncluded",
"reverseZ",
"columnTracks",
"gridColumnTracks",
"rowTracks",
"gridRowTracks",
];
/// Drop the bindings of auto layout fields (gap, paddingโฆ): they go with the auto layout, or
/// re-applying them would bring it back.
pub fn drop_layout_bindings(n: &mut Node) {
n.bound.retain(|k, _| !LAYOUT_KEYS.contains(&k.as_str()));
}
/// The auto layout of a frame-like node, created when it has none yet. Other nodes can't hold an
/// auto layout: an auto layout key on them is refused, not stored where nothing reads it
/// (`node.set` on several layers skips them instead, see `edit::set`).
fn layout_mut<'a>(cmd: &str, k: &str, n: &'a mut Node) -> Result<&'a mut AutoLayout> {
if !n.kind.is_frame_like() {
return Err(bad(
cmd,
format!(
"`{k}` is an auto layout property, and layer {} โ{}โ is a {} (only frames, components and instances have auto layout)",
n.id,
n.name,
n.kind.type_name()
),
));
}
Ok(ensure_layout(n))
}
/// Replace a node's fills (or strokes). Bindings on the paints whose bound values the new list
/// changed let go, as an explicit edit does (see `lists::rebind_edited_paint`).
fn set_paints(n: &mut Node, fills: bool, paints: Vec<Paint>) {
if fills {
super::lists::take_character_fills(n);
}
let old = std::mem::replace(if fills { &mut n.fills } else { &mut n.strokes }, paints);
for (i, p) in old.iter().enumerate() {
super::lists::rebind_edited_paint(n, fills, i, p);
}
}
/// `"none"` (either case) and null ask for no paint, as an empty `fills`/`strokes` list does.
fn paint_none(v: &Value) -> bool {
v.is_null() || v.as_str().is_some_and(|s| s.eq_ignore_ascii_case("none"))
}
/// A top-level variable wrapper. Validate before `node.set` skips type-specific properties too,
/// so an unsupported wrapper is always an error, even on a mixed selection.
pub(crate) fn variable_prop<'a>(cmd: &str, key: &str, value: &'a Value) -> Result<Option<&'a str>> {
let Some(o) = value.as_object().filter(|o| o.contains_key("$var")) else { return Ok(None) };
if !matches!(key, "fill" | "stroke") {
return Err(bad(cmd, format!("`{key}`: only `fill` and `stroke` take variables in props; use `variable.bind` for other fields")));
}
if o.len() != 1 {
return Err(bad(cmd, format!("`{key}`: a `$var` wrapper takes only `$var`, with no extra keys")));
}
let name = o
.get("$var")
.and_then(Value::as_str)
.filter(|s| !s.is_empty())
.ok_or_else(|| bad(cmd, format!("`{key}`: `$var` must be a variable id or name (a non-empty string)")))?;
Ok(Some(name))
}
/// The order [`apply`] takes keys in: geometry first so rotation applies to the final size, the
/// auto layout mode before the keys that tune it (an object `layout` replaces the whole auto
/// layout), style links after the values so a link wins over values its style sets, variable
/// bindings last so paints set in the same call don't detach them. `$var` wrappers also win over style links.
fn apply_order(k: &str, v: &Value) -> u8 {
if v.get("$var").is_some() {
return 7;
}
match k {
"path" | "width" | "height" | "w" | "h" => 0,
"layout" | "layoutMode" => 1,
"rotation" | "absoluteRotation" => 3,
"x" | "y" => 4,
"fillStyle" | "strokeStyle" | "effectStyle" | "textStyle" | "gridStyle" => 5,
"boundVariables" => 6,
_ => 2,
}
}
/// Auto layout keys given beside a `layout` (or `layoutMode`) that turns auto layout off: they
/// would turn it back on (`layout_mut`), so the call is refused rather than one of them losing.
fn layout_keys_beside_none(cmd: &str, props: &Map<String, Value>) -> Result<()> {
let off = ["layout", "layoutMode"]
.into_iter()
.find(|k| props.get(*k).is_some_and(|v| v.is_null() || v.as_str().is_some_and(|s| s.eq_ignore_ascii_case("none"))));
let tuning: Vec<String> = props.keys().filter(|k| LAYOUT_KEYS.contains(&k.as_str())).map(|k| format!("`{k}`")).collect();
let Some(off) = off.filter(|_| !tuning.is_empty()) else { return Ok(()) };
let (what, are) = if tuning.len() == 1 { ("an auto layout property", "is") } else { ("auto layout properties", "are") };
Err(bad(cmd, format!("{} {are} {what}, and `{off}` in the same call turns auto layout off", tuning.join(", "))))
}
/// An explicit width (`is_w`) or height makes hugging or filling on that axis fixed, like typing
/// into W or H; sized to the full space its auto layout parent has for it on that axis, the layer
/// fills instead: "Child objects of an auto layout frame will also be set to Fill container if
/// they are manually resized to the full available space of the parent frame" (Guide to auto
/// layout).
pub(crate) fn fix_axis(doc: &mut Document, id: NodeId, is_w: bool) -> Result<()> {
let sizing = if fills_available_space(doc, id, is_w) { Sizing::Fill } else { Sizing::Fixed };
let n = doc.get_mut(id)?;
if is_w {
n.child_layout.sizing_h = sizing;
} else {
n.child_layout.sizing_v = sizing;
}
Ok(())
}
/// Whether `id`'s width (`is_w`) or height is the full space its auto layout parent has for it on
/// that axis: the frame's size less its padding and an inside stroke included in the layout (the
/// insets layout itself takes). Across the flow that is every child's room;
/// along the flow only a lone child has it (beside siblings what is left depends on the gaps, the
/// alignment and overflow, so a size that happens to match it is not "the full available
/// space"). Never in a hugging or wrapping frame or a grid, or for a layer that ignores the layout.
fn fills_available_space(doc: &Document, id: NodeId, is_w: bool) -> bool {
let Some(n) = doc.node(id) else { return false };
let Some(parent) = n.parent.and_then(|p| doc.node(p)) else { return false };
let Some(l) = &parent.layout else { return false };
if n.child_layout.absolute || l.wrap || l.mode == LayoutMode::Grid {
return false;
}
// A rotated layer's local size isn't the size layout gives it room for (its rotated bounds
// are): it stays Fixed rather than have Fill squash its geometry.
let [_, b, c, ..] = n.transform.as_coeffs();
if b.abs() > 1e-9 || c.abs() > 1e-9 {
return false;
}
let hugs = if is_w { parent.child_layout.sizing_h } else { parent.child_layout.sizing_v } == Sizing::Hug;
if hugs {
return false;
}
if (l.mode == LayoutMode::Horizontal) == is_w
&& parent.children.iter().filter(|c| **c != id).filter_map(|c| doc.node(*c)).any(|c| c.visible && !c.child_layout.absolute)
{
return false;
}
let (pt, pr, pb, pl) = figcraft_layout::insets(parent, l);
let available = if is_w { parent.width - pl - pr } else { parent.height - pt - pb };
let size = if is_w { n.width } else { n.height };
available > 0.0 && (size - available).abs() < 0.01
}
/// The `geometry` properties of `apply`; `false` when `k` is not one of them.
fn apply_geometry(
cmd: &str,
doc: &mut Document,
id: NodeId,
props: &Map<String, Value>,
k: &str,
v: &Value,
path_offset: &mut (f64, f64),
) -> Result<bool> {
match k {
"path" => {
*path_offset = set_path(cmd, doc, id, v, props)?;
// A size given beside the path is its scale (`set_path`), and still fixes or fills
// its auto layout axis, judged once the path has given the layer that size.
for (long, short, is_w) in [("width", "w", true), ("height", "h", false)] {
if props.contains_key(long) || props.contains_key(short) {
fix_axis(doc, id, is_w)?;
}
}
}
"width" | "height" | "w" | "h" if props.contains_key("path") => {}
"x" | "y" => {
let val = f64_of(v).ok_or_else(|| bad(cmd, format!("`{k}` must be a number")))?;
let val = val + if k == "x" { path_offset.0 } else { path_offset.1 };
// X/Y are the node's own origin (its rotated top-left for rotated nodes), in the
// frame it is in (groups have no space of their own).
let n = doc.get(id)?;
let group = n.parent.filter(|p| doc.node(*p).is_some_and(|pn| pn.kind.bounds_follow_children()));
let space = group.map_or(Affine::IDENTITY, |g| doc.frame_relative(g));
let c = (space * n.transform).as_coeffs();
let (mut tx, mut ty) = (c[4], c[5]);
if k == "x" {
tx = val;
} else {
ty = val;
}
doc.get_mut(id)?.transform = space.inverse() * Affine::new([c[0], c[1], c[2], c[3], tx, ty]);
}
"width" | "height" | "w" | "h" => {
let val = f64_of(v).ok_or_else(|| bad(cmd, format!("`{k}` must be a number")))?.max(0.0);
let is_w = k.starts_with('w');
// With the proportions locked (the Layout panel's link) and only one side set, the
// other side follows the node's ratio; both sides in one `node.set` stay as typed.
let (nw, nh) = {
let n = doc.get(id)?;
let (ow, oh) = (n.width, n.height);
let (other, other_short) = if is_w { ("height", "h") } else { ("width", "w") };
let linked = n.constrain_proportions && !props.contains_key(other) && !props.contains_key(other_short) && ow > 1e-9 && oh > 1e-9;
let derived = if is_w { oh * val / ow } else { ow * val / oh };
match (is_w, linked && derived.is_finite()) {
(true, true) => (val, derived),
(false, true) => (derived, val),
(true, false) => (val, oh),
(false, false) => (ow, val),
}
};
resize_node(doc, id, nw, nh)?;
// Explicit size makes text fixed in that dimension.
if let Some(t) = doc.get_mut(id)?.kind.text_mut() {
t.fix_size(is_w, !is_w);
}
fix_axis(doc, id, is_w)?;
}
"rotation" => {
let deg = f64_of(v).ok_or_else(|| bad(cmd, "`rotation` must be degrees"))?;
let n = doc.get_mut(id)?;
n.transform = figcraft_geom::set_rotation_about_center(n.transform, n.width, n.height, deg);
}
"absoluteRotation" => {
let deg = f64_of(v).ok_or_else(|| bad(cmd, "`absoluteRotation` must be degrees"))?;
if props.contains_key("rotation") {
return Err(bad(cmd, "give one of `rotation` and `absoluteRotation`"));
}
let (w, h) = {
let n = doc.get(id)?;
(n.width, n.height)
};
let world = figcraft_geom::set_rotation_about_center(doc.world_transform(id), w, h, deg);
let parent = doc.get(id)?.parent;
let pw = parent.map(|p| doc.world_transform(p)).unwrap_or(figcraft_geom::Affine::IDENTITY);
let local = pw.inverse() * world;
if local.as_coeffs().iter().all(|c| c.is_finite()) {
doc.get_mut(id)?.transform = local;
} else {
// A degenerate parent can't be inverted: turn the local angle instead.
let n = doc.get_mut(id)?;
n.transform = figcraft_geom::set_rotation_about_center(n.transform, n.width, n.height, deg);
}
}
_ => return Ok(false),
}
Ok(true)
}
/// The `look` properties of `apply`; `false` when `k` is not one of them.
fn apply_look(cmd: &str, doc: &mut Document, id: NodeId, k: &str, v: &Value) -> Result<bool> {
match k {
"name" => doc.get_mut(id)?.name = string_val(v).ok_or_else(|| bad(cmd, "`name` must be a string"))?,
"visible" => doc.get_mut(id)?.visible = v.as_bool().ok_or_else(|| bad(cmd, "`visible` must be a boolean"))?,
"locked" => doc.get_mut(id)?.locked = v.as_bool().ok_or_else(|| bad(cmd, "`locked` must be a boolean"))?,
"opacity" => {
let o = fraction_of(v).ok_or_else(|| bad(cmd, "`opacity` must be a number"))?;
doc.get_mut(id)?.opacity = o.clamp(0.0, 1.0) as f32;
}
"blend" | "blendMode" => {
let b = v.as_str().and_then(figcraft_color::BlendMode::from_name).ok_or_else(|| bad(cmd, "unknown blend mode"))?;
doc.get_mut(id)?.blend = b;
}
"fills" => set_paints(doc.get_mut(id)?, true, paints_of(v).ok_or_else(|| bad(cmd, "`fills` must be paints or colours"))?),
"fill" => {
if paint_none(v) {
set_paints(doc.get_mut(id)?, true, vec![]);
} else {
let c = color_of(v).ok_or_else(|| bad(cmd, "`fill` must be a colour, \"none\" or null"))?;
set_paints(doc.get_mut(id)?, true, vec![Paint::solid(c)]);
}
}
"strokes" => set_paints(doc.get_mut(id)?, false, paints_of(v).ok_or_else(|| bad(cmd, "`strokes` must be paints or colours"))?),
"stroke" => {
if paint_none(v) {
set_paints(doc.get_mut(id)?, false, vec![]);
} else {
let c = color_of(v).ok_or_else(|| bad(cmd, "`stroke` must be a colour, \"none\" or null"))?;
set_paints(doc.get_mut(id)?, false, vec![Paint::solid(c)]);
}
}
"strokeWeight" => doc.get_mut(id)?.stroke.weight = f64_of(v).ok_or_else(|| bad(cmd, "`strokeWeight` must be a number"))?.max(0.0),
"strokeAlign" => doc.get_mut(id)?.stroke.align = enum_of(v).ok_or_else(|| bad(cmd, "strokeAlign: inside|center|outside"))?,
"strokeSides" => {
doc.get_mut(id)?.stroke.sides = if v.is_null() { None } else { Some(four(v).ok_or_else(|| bad(cmd, "strokeSides: [t,r,b,l]"))?) }
}
"strokeTopWeight" | "strokeRightWeight" | "strokeBottomWeight" | "strokeLeftWeight" => {
let i = STROKE_SIDES.iter().position(|x| *x == k).unwrap_or(0);
let w = f64_of(v).ok_or_else(|| bad(cmd, format!("`{k}` must be a number")))?.max(0.0);
let st = &mut doc.get_mut(id)?.stroke;
// One side set on its own turns on individual strokes, the others at the weight.
let mut sides = st.sides.unwrap_or([st.weight; 4]);
if let Some(slot) = sides.get_mut(i) {
*slot = w;
}
st.sides = Some(sides);
}
"strokeCap" => {
let c: StrokeCap = enum_of(v).ok_or_else(|| bad(cmd, format!("strokeCap: {STROKE_CAP_HELP}")))?;
let n = doc.get_mut(id)?;
n.stroke.cap_start = c;
n.stroke.cap_end = c;
}
"startCap" => doc.get_mut(id)?.stroke.cap_start = enum_of(v).ok_or_else(|| bad(cmd, format!("startCap: {STROKE_CAP_HELP}")))?,
"endCap" => doc.get_mut(id)?.stroke.cap_end = enum_of(v).ok_or_else(|| bad(cmd, format!("endCap: {STROKE_CAP_HELP}")))?,
"strokeJoin" => doc.get_mut(id)?.stroke.join = enum_of(v).ok_or_else(|| bad(cmd, "strokeJoin: miter|bevel|round"))?,
"miterLimit" => doc.get_mut(id)?.stroke.miter_limit = f64_of(v).ok_or_else(|| bad(cmd, "`miterLimit` must be a number"))?.clamp(1.0, 100.0),
"miterAngle" => {
let deg = f64_of(v).ok_or_else(|| bad(cmd, "`miterAngle` must be degrees"))?;
doc.get_mut(id)?.stroke.miter_limit = StrokeProps::miter_limit_for(deg);
}
"dashes" => {
let d: Vec<f64> = if v.is_null() {
Vec::new()
} else {
let a = v.as_array().ok_or_else(|| bad(cmd, "`dashes` must be an array of numbers"))?;
a.iter()
.map(|x| if x.is_boolean() { None } else { f64_of(x).map(|n| n.max(0.0)) })
.collect::<Option<_>>()
.ok_or_else(|| bad(cmd, "`dashes` must be an array of numbers"))?
};
doc.get_mut(id)?.stroke.dashes = d;
}
"dashCap" => {
let cap = (!v.is_null())
.then(|| enum_of(v).filter(|c| StrokeCap::DASH.contains(c)).ok_or_else(|| bad(cmd, "dashCap: none|round|square, or null")))
.transpose()?;
doc.get_mut(id)?.stroke.dash_cap = cap;
}
"widthProfile" => doc.get_mut(id)?.stroke.width_profile = width_profile_of(v).ok_or_else(|| bad(cmd, WIDTH_PROFILE_HELP))?,
"brush" | "strokeBrush" => doc.get_mut(id)?.stroke.brush = brush_of(v).ok_or_else(|| bad(cmd, BRUSH_HELP))?,
_ => return Ok(false),
}
Ok(true)
}
/// The `corners` properties of `apply`; `false` when `k` is not one of them.
fn apply_corners(cmd: &str, doc: &mut Document, id: NodeId, k: &str, v: &Value) -> Result<bool> {
match k {
"cornerRadius" => {
let r = four(v).ok_or_else(|| bad(cmd, "cornerRadius: n or [tl,tr,br,bl]"))?.map(|x| x.max(0.0));
let n = doc.get_mut(id)?;
n.corners.radii = r;
// A vector's corner radius rounds every point (edit mode then sets them one by one).
if let NodeKind::Vector { network } = &mut n.kind {
network.vertices.iter_mut().for_each(|p| p.radius = r[0]);
crate::vectoredit::refit(doc, id)?;
}
}
"topLeftRadius" | "topRightRadius" | "bottomRightRadius" | "bottomLeftRadius" => {
let i = ["topLeftRadius", "topRightRadius", "bottomRightRadius", "bottomLeftRadius"].iter().position(|x| *x == k).unwrap_or(0);
let r = f64_of(v).ok_or_else(|| bad(cmd, format!("`{k}` must be a number")))?.max(0.0);
if let Some(slot) = doc.get_mut(id)?.corners.radii.get_mut(i) {
*slot = r;
}
}
"cornerSmoothing" => {
doc.get_mut(id)?.corners.smoothing = f64_of(v).ok_or_else(|| bad(cmd, "`cornerSmoothing` must be a number"))?.clamp(0.0, 1.0)
}
"effects" => doc.get_mut(id)?.effects = effects_from(cmd, v)?,
"clip" | "clipsContent" => doc.get_mut(id)?.clip = v.as_bool().ok_or_else(|| bad(cmd, "`clip` must be a boolean"))?,
"isMask" => doc.get_mut(id)?.is_mask = v.as_bool().ok_or_else(|| bad(cmd, format!("`{k}` must be a boolean")))?,
"devStatus" => {
let st = if v.is_null() {
Some(DevStatus::None)
} else {
v.as_str().and_then(|s| DevStatus::ALL.into_iter().find(|d| d.id().eq_ignore_ascii_case(s)))
};
let st = st.ok_or_else(|| bad(cmd, "devStatus: none|readyForDev|completed"))?;
if !st.is_none() && !crate::devinspect::has_status(doc, id) {
return Err(bad(cmd, "devStatus: only sections and frames at the top of a page or section take one"));
}
let n = doc.get_mut(id)?;
n.dev_status = st;
// Marking a layer (again) starts from its current contents.
n.dev_changed = false;
}
"maskType" => {
let t = v.as_str().and_then(|s| MaskType::ALL.into_iter().find(|m| m.id().eq_ignore_ascii_case(s)));
doc.get_mut(id)?.mask_type = t.ok_or_else(|| bad(cmd, "maskType: alpha|vector|luminance"))?;
}
_ => return Ok(false),
}
Ok(true)
}
/// The `layout` properties of `apply`; `false` when `k` is not one of them.
fn apply_layout(cmd: &str, doc: &mut Document, id: NodeId, k: &str, v: &Value) -> Result<bool> {
match k {
"layout" | "layoutMode" => {
let n = doc.get_mut(id)?;
if !n.kind.is_frame_like() {
return Err(bad(cmd, "auto layout needs a frame"));
}
match v {
Value::Null => {
n.layout = None;
drop_layout_bindings(n);
}
Value::String(s) if s.eq_ignore_ascii_case("none") => {
n.layout = None;
drop_layout_bindings(n);
}
Value::String(s) => {
let mode = match s.to_ascii_lowercase().as_str() {
"horizontal" | "row" => LayoutMode::Horizontal,
"vertical" | "column" => LayoutMode::Vertical,
"grid" => LayoutMode::Grid,
_ => return Err(bad(cmd, "layout: none|horizontal|vertical|grid")),
};
ensure_layout(n).mode = mode;
}
Value::Object(_) => n.layout = Some(serde_json::from_value(snake(v)).map_err(|e| bad(cmd, format!("layout: {e}")))?),
_ => return Err(bad(cmd, "layout: none|horizontal|vertical|grid|{...}")),
}
}
"gap" | "itemSpacing" | "columnGap" => {
layout_mut(cmd, k, doc.get_mut(id)?)?.gap = f64_of(v).ok_or_else(|| bad(cmd, format!("`{k}` must be a number")))?
}
"crossGap" | "counterAxisSpacing" | "rowGap" => {
layout_mut(cmd, k, doc.get_mut(id)?)?.cross_gap = f64_of(v).ok_or_else(|| bad(cmd, format!("`{k}` must be a number")))?
}
"padding" => {
let p = four(v).ok_or_else(|| bad(cmd, "padding: n or [t,r,b,l]"))?;
layout_mut(cmd, k, doc.get_mut(id)?)?.padding = p.map(|x| x.max(0.0));
}
"paddingTop" | "paddingRight" | "paddingBottom" | "paddingLeft" => {
let i = ["paddingTop", "paddingRight", "paddingBottom", "paddingLeft"].iter().position(|x| *x == k).unwrap_or(0);
let val = f64_of(v).ok_or_else(|| bad(cmd, format!("`{k}` must be a number")))?.max(0.0);
if let Some(slot) = layout_mut(cmd, k, doc.get_mut(id)?)?.padding.get_mut(i) {
*slot = val;
}
}
"paddingHorizontal" => {
let val = f64_of(v).ok_or_else(|| bad(cmd, format!("`{k}` must be a number")))?.max(0.0);
let l = layout_mut(cmd, k, doc.get_mut(id)?)?;
l.padding[1] = val;
l.padding[3] = val;
}
"paddingVertical" => {
let val = f64_of(v).ok_or_else(|| bad(cmd, format!("`{k}` must be a number")))?.max(0.0);
let l = layout_mut(cmd, k, doc.get_mut(id)?)?;
l.padding[0] = val;
l.padding[2] = val;
}
"mainAlign" | "primaryAxisAlignItems" => {
layout_mut(cmd, k, doc.get_mut(id)?)?.main_align =
enum_of(v).ok_or_else(|| bad(cmd, "mainAlign: min|center|max|spaceBetween|spaceAround|spaceEvenly"))?
}
"crossAlign" | "counterAxisAlignItems" => {
layout_mut(cmd, k, doc.get_mut(id)?)?.cross_align = enum_of(v).ok_or_else(|| bad(cmd, "crossAlign: min|center|max|baseline"))?
}
"contentAlign" | "counterAxisAlignContent" => {
layout_mut(cmd, k, doc.get_mut(id)?)?.content_align = enum_of(v).ok_or_else(|| bad(cmd, "contentAlign: auto|spaceBetween"))?
}
"wrap" => layout_mut(cmd, k, doc.get_mut(id)?)?.wrap = v.as_bool().ok_or_else(|| bad(cmd, format!("`{k}` must be a boolean")))?,
"gridColumns" | "gridRows" => {
let count = f64_of(v).ok_or_else(|| bad(cmd, format!("`{k}` must be a number")))?.clamp(1.0, 1000.0) as u32;
let l = layout_mut(cmd, k, doc.get_mut(id)?)?;
// Tracks past the new count go away (new tracks are 1fr).
let (n, tracks) = if k == "gridColumns" { (&mut l.grid_columns, &mut l.column_tracks) } else { (&mut l.grid_rows, &mut l.row_tracks) };
*n = count;
tracks.truncate(count as usize);
}
"strokesIncluded" => {
layout_mut(cmd, k, doc.get_mut(id)?)?.strokes_included = v.as_bool().ok_or_else(|| bad(cmd, format!("`{k}` must be a boolean")))?
}
"reverseZ" => layout_mut(cmd, k, doc.get_mut(id)?)?.reverse_z = v.as_bool().ok_or_else(|| bad(cmd, format!("`{k}` must be a boolean")))?,
_ => return Ok(false),
}
Ok(true)
}
/// The `sizing` properties of `apply`; `false` when `k` is not one of them.
fn apply_sizing(cmd: &str, doc: &mut Document, id: NodeId, k: &str, v: &Value) -> Result<bool> {
match k {
"sizingH" | "layoutSizingHorizontal" => {
let s = sizing(v).ok_or_else(|| bad(cmd, "sizing: fixed|hug|fill"))?;
set_sizing(cmd, doc, id, s, true)?;
}
"sizingV" | "layoutSizingVertical" => {
let s = sizing(v).ok_or_else(|| bad(cmd, "sizing: fixed|hug|fill"))?;
set_sizing(cmd, doc, id, s, false)?;
}
"absolute" | "ignoreAutoLayout" => {
let on = bool_of(v).ok_or_else(|| bad(cmd, "`absolute` must be a boolean"))?;
let cl = &mut doc.get_mut(id)?.child_layout;
cl.absolute = on;
// An absolute child can't fill: it keeps its current size.
if on {
for s in [&mut cl.sizing_h, &mut cl.sizing_v] {
if *s == Sizing::Fill {
*s = Sizing::Fixed;
}
}
}
}
"minWidth" | "maxWidth" | "minHeight" | "maxHeight" => {
let val = match v {
Value::Null => None,
other => Some(f64_of(other).ok_or_else(|| bad(cmd, format!("`{k}` must be a number or null")))?.clamp(0.0, 1e7)),
};
set_limit(&mut doc.get_mut(id)?.child_layout, k, val);
// A text has a max height or a number of max lines, not both: a max height sets the
// lines back to Auto (Guide to auto layout).
if k == "maxHeight"
&& val.is_some()
&& let Some(t) = doc.get_mut(id)?.kind.text_mut()
{
t.max_lines = 0;
}
}
"columnTracks" | "gridColumnTracks" | "rowTracks" | "gridRowTracks" => {
let a = v.as_array().ok_or_else(|| bad(cmd, format!("`{k}` must be an array of tracks")))?;
let tracks = a.iter().map(track_of).collect::<Option<Vec<_>>>().ok_or_else(|| bad(cmd, TRACK_HELP))?;
let l = layout_mut(cmd, k, doc.get_mut(id)?)?;
if k.contains("olumn") {
l.grid_columns = (tracks.len() as u32).clamp(1, 1000);
l.column_tracks = tracks;
} else {
l.grid_rows = (tracks.len() as u32).clamp(1, 1000);
l.row_tracks = tracks;
}
}
"gridColumn" | "gridColumnAnchorIndex" | "gridRow" | "gridRowAnchorIndex" => {
let val = match v {
Value::Null => None,
Value::String(s) if s.eq_ignore_ascii_case("auto") => None,
other => {
Some(f64_of(other).ok_or_else(|| bad(cmd, format!("`{k}` must be a 0-based index, \"auto\" or null")))?.clamp(0.0, 999.0) as u32)
}
};
let cl = &mut doc.get_mut(id)?.child_layout;
if k.starts_with("gridColumn") {
cl.grid_column = val;
} else {
cl.grid_row = val;
}
}
"gridAlignH" | "gridChildHorizontalAlign" | "gridAlignV" | "gridChildVerticalAlign" => {
let val = match v {
Value::Null => None,
Value::String(s) if s.eq_ignore_ascii_case("auto") => None,
other => Some(enum_of(other).ok_or_else(|| bad(cmd, format!("`{k}`: min|center|max|auto")))?),
};
let cl = &mut doc.get_mut(id)?.child_layout;
if k.contains('H') {
cl.grid_align_h = val;
} else {
cl.grid_align_v = val;
}
}
"gridColumnSpan" | "gridRowSpan" => {
let span = f64_of(v).ok_or_else(|| bad(cmd, format!("`{k}` must be a number")))?.clamp(1.0, 1000.0) as u32;
let cl = &mut doc.get_mut(id)?.child_layout;
if k == "gridColumnSpan" {
cl.grid_column_span = span;
} else {
cl.grid_row_span = span;
}
}
"constraints" => {
let n = doc.get_mut(id)?;
if let Some(h) = v.get("horizontal") {
n.constraints.horizontal = enum_of(h).ok_or_else(|| bad(cmd, "horizontal: left|right|leftRight|center|scale"))?;
}
if let Some(vv) = v.get("vertical") {
n.constraints.vertical = enum_of(vv).ok_or_else(|| bad(cmd, "vertical: top|bottom|topBottom|center|scale"))?;
}
}
_ => return Ok(false),
}
Ok(true)
}
/// The `meta` properties of `apply`; `false` when `k` is not one of them.
fn apply_meta(cmd: &str, doc: &mut Document, id: NodeId, k: &str, v: &Value) -> Result<bool> {
match k {
"grids" | "layoutGrids" => doc.get_mut(id)?.grids = serde_json::from_value(snake(v)).map_err(|e| bad(cmd, format!("grids: {e}")))?,
"exports" | "exportSettings" => doc.get_mut(id)?.exports = serde_json::from_value(snake(v)).map_err(|e| bad(cmd, format!("exports: {e}")))?,
"interactions" => doc.get_mut(id)?.interactions = serde_json::from_value(v.clone()).map_err(|e| bad(cmd, format!("interactions: {e}")))?,
"overflow" => doc.get_mut(id)?.overflow = enum_of(v).ok_or_else(|| bad(cmd, "overflow: none|horizontal|vertical|both"))?,
"scrollPosition" => doc.get_mut(id)?.scroll_position = enum_of(v).ok_or_else(|| bad(cmd, "scrollPosition: scrolls|fixed|sticky"))?,
"constrainProportions" => doc.get_mut(id)?.constrain_proportions = v.as_bool().ok_or_else(|| bad(cmd, format!("`{k}` must be a boolean")))?,
_ => return Ok(false),
}
Ok(true)
}
/// The `text` properties of `apply`; `false` when `k` is not one of them.
fn apply_text(cmd: &str, doc: &mut Document, id: NodeId, props: &Map<String, Value>, k: &str, v: &Value) -> Result<bool> {
match k {
"characters" | "text" => {
let s = string_val(v).ok_or_else(|| bad(cmd, "`characters` must be a string"))?;
let n = doc.get_mut(id)?;
let t = text_mut(cmd, n)?;
let len = t.char_count();
t.replace_range(0, len, &normalize_line_endings(&s));
n.overrides.insert("characters".into());
}
"fontFamily"
| "fontStyle"
| "fontWeight"
| "fontSize"
| "lineHeight"
| "letterSpacing"
| "textDecoration"
| "textCase"
| "hyperlink"
| "textFills"
| "fontVariations"
| "variationSettings"
| "textDecorationStyle"
| "textDecorationThickness"
| "textDecorationOffset"
| "textDecorationSkipInk"
| "textDecorationColor" => {
let n = doc.get_mut(id)?;
let t = text_mut(cmd, n)?;
let (start, end) = range_of(props, t.char_count());
apply_text_style(cmd, t, start, end, k, v)?;
}
"textAlign" | "textAlignHorizontal" => {
text_mut(cmd, doc.get_mut(id)?)?.align_h = enum_of(v).ok_or_else(|| bad(cmd, "textAlign: left|center|right|justified"))?
}
"textAlignVertical" => {
text_mut(cmd, doc.get_mut(id)?)?.align_v = enum_of(v).ok_or_else(|| bad(cmd, "textAlignVertical: top|middle|bottom"))?
}
"textAutoResize" => {
text_mut(cmd, doc.get_mut(id)?)?.auto_resize =
enum_of(v).ok_or_else(|| bad(cmd, "textAutoResize: widthAndHeight|height|none|truncate"))?
}
"paragraphSpacing" => {
text_mut(cmd, doc.get_mut(id)?)?.paragraph_spacing = f64_of(v).ok_or_else(|| bad(cmd, "`paragraphSpacing` must be a number"))?.max(0.0)
}
"paragraphIndent" => {
text_mut(cmd, doc.get_mut(id)?)?.paragraph_indent = f64_of(v).ok_or_else(|| bad(cmd, "`paragraphIndent` must be a number"))?.max(0.0)
}
"listStyle" | "indentation" => {
let t = text_mut(cmd, doc.get_mut(id)?)?;
let (start, end) = range_of(props, t.char_count());
if k == "listStyle" {
let l: ListStyle = enum_of(v).ok_or_else(|| bad(cmd, "listStyle: none|bulleted|numbered"))?;
t.set_para_lists(start, end, |p| p.list = l);
} else {
let d = f64_of(v).filter(|d| d.is_finite()).ok_or_else(|| bad(cmd, "indentation: a list level 0-8"))?;
t.set_para_lists(start, end, |p| p.indent = d.clamp(0.0, f64::from(MAX_LIST_INDENT)) as u8);
}
}
"textDirection" | "direction" => {
let d: figcraft_doc::TextDirection = enum_of(v).ok_or_else(|| bad(cmd, "textDirection: auto|ltr|rtl"))?;
let t = text_mut(cmd, doc.get_mut(id)?)?;
let (start, end) = range_of(props, t.char_count());
t.set_para_lists(start, end, |p| p.direction = d);
}
"listSpacing" => text_mut(cmd, doc.get_mut(id)?)?.list_spacing = f64_of(v).filter(|s| s.is_finite()).unwrap_or(0.0).clamp(0.0, 10_000.0),
"hangingPunctuation" | "hangingList" => {
let on = v.as_bool().ok_or_else(|| bad(cmd, format!("`{k}` must be true or false")))?;
let t = text_mut(cmd, doc.get_mut(id)?)?;
*if k == "hangingList" { &mut t.hanging_list } else { &mut t.hanging_punctuation } = on;
}
"leadingTrim" => text_mut(cmd, doc.get_mut(id)?)?.leading_trim = enum_of(v).ok_or_else(|| bad(cmd, "leadingTrim: none|capHeight"))?,
"wrapStyle" | "textWrap" => {
let w: figcraft_doc::WrapStyle = enum_of(v).ok_or_else(|| bad(cmd, "wrapStyle: auto|balance|pretty"))?;
let t = text_mut(cmd, doc.get_mut(id)?)?;
if props.contains_key("start") || props.contains_key("end") {
let (start, end) = range_of(props, t.char_count());
t.set_para_wrap_styles(start, end, w);
} else {
t.set_wrap_style(w);
}
}
"maxLines" => {
let lines = f64_of(v).unwrap_or(0.0).clamp(0.0, 10_000.0) as u32;
let n = doc.get_mut(id)?;
text_mut(cmd, n)?.max_lines = lines;
// A text has a max height or a number of max lines, not both: a number of lines takes
// the max height away (Guide to auto layout).
if lines > 0 {
n.child_layout.max_h = None;
}
}
"features" | "textFeatures" | "fontFeatures" | "openTypeFeatures" => {
let f = features_of(cmd, v)?;
let t = text_mut(cmd, doc.get_mut(id)?)?;
t.features.clear();
for (k, on) in f {
if let Some(on) = on {
t.features.insert(k, on);
}
}
}
"start" | "end" => {}
_ => return Ok(false),
}
Ok(true)
}
/// The `shape` properties of `apply`; `false` when `k` is not one of them.
fn apply_shape(cmd: &str, doc: &mut Document, id: NodeId, k: &str, v: &Value) -> Result<bool> {
match k {
"pointCount" => {
let c = f64_of(v).ok_or_else(|| bad(cmd, "`pointCount` must be a number"))?.round();
match &mut doc.get_mut(id)?.kind {
// Stars have 3 to 60 points; polygons keep the geometry's 120 (silent).
NodeKind::Star { count, .. } => *count = c.clamp(3.0, 60.0) as u32,
NodeKind::Polygon { count } => *count = c.clamp(3.0, 120.0) as u32,
_ => return Err(bad(cmd, "pointCount applies to polygons and stars")),
}
}
"innerRadius" | "ratio" => {
let r = fraction_of(v).unwrap_or(0.38);
match &mut doc.get_mut(id)?.kind {
NodeKind::Star { inner_ratio, .. } => *inner_ratio = r.clamp(0.0, 1.0),
_ => return Err(bad(cmd, "innerRadius applies to stars")),
}
}
"arcStart" | "arcSweep" | "arcInner" => {
let val = if k == "arcInner" { fraction_of(v) } else { f64_of(v) };
let val = val.ok_or_else(|| bad(cmd, format!("`{k}` must be a number")))?;
match &mut doc.get_mut(id)?.kind {
NodeKind::Ellipse { start, sweep, inner } => match k {
"arcStart" => *start = val.to_radians(),
"arcSweep" => *sweep = val.clamp(-360.0, 360.0).to_radians(),
_ => *inner = val.clamp(0.0, 0.99),
},
_ => return Err(bad(cmd, "arc applies to ellipses")),
}
}
"description" => match &mut doc.get_mut(id)?.kind {
NodeKind::Component { description, .. } | NodeKind::ComponentSet { description } => *description = string_val(v).unwrap_or_default(),
_ => return Err(bad(cmd, "description applies to components")),
},
"pluginData" => {
let n = doc.get_mut(id)?;
if let Some(o) = v.as_object() {
for (pk, pv) in o {
if pv.is_null() {
n.plugin_data.remove(pk);
} else {
n.plugin_data.insert(pk.clone(), string_val(pv).unwrap_or_else(|| pv.to_string()));
}
}
}
}
"fillStyle" | "strokeStyle" | "effectStyle" | "textStyle" | "gridStyle" => {
let sid = string_val(v);
crate::cmd::styles::apply_style_ref(doc, id, k, sid.as_deref())?;
}
"boundVariables" => {
let n = doc.get_mut(id)?;
if let Some(o) = v.as_object() {
for (field, var) in o {
match var.as_str() {
Some(vid) => {
if n.bound.get(field).map(String::as_str) != Some(vid) {
crate::cmd::styles::rebind_paint_alpha(&mut n.fills, &mut n.strokes, field, true);
}
n.bound.insert(field.clone(), vid.to_string());
}
None => {
if n.bound.remove(field).is_some() {
crate::cmd::styles::rebind_paint_alpha(&mut n.fills, &mut n.strokes, field, false);
}
}
}
}
}
}
"variableModes" => {
let n = doc.get_mut(id)?;
if let Some(o) = v.as_object() {
for (coll, mode) in o {
match mode.as_str() {
Some(m) => {
n.var_modes.insert(coll.clone(), m.to_string());
}
None => {
n.var_modes.remove(coll);
}
}
}
}
}
"booleanOperation" if !matches!(doc.get(id)?.kind, NodeKind::BooleanOp { .. }) => set_operand_op(doc, id, v, cmd)?,
"booleanOperation" => {
if let NodeKind::BooleanOp { op } = &mut doc.get_mut(id)?.kind {
*op = enum_of(v).ok_or_else(|| bad(cmd, BOOL_OP_HELP))?;
}
}
"operandOperation" => set_operand_op(doc, id, v, cmd)?,
"sectionContentsHidden" => {
if let NodeKind::Section { contents_hidden } = &mut doc.get_mut(id)?.kind {
*contents_hidden = v.as_bool().ok_or_else(|| bad(cmd, "`sectionContentsHidden` must be a boolean"))?;
}
}
"background" => {
let c = color_of(v).ok_or_else(|| bad(cmd, "`background` must be a colour"))?;
match &mut doc.get_mut(id)?.kind {
NodeKind::Page { background, .. } => *background = c,
_ => return Err(bad(cmd, "background applies to pages")),
}
}
"componentProperties" => {
if let NodeKind::Instance { props: p, .. } = &mut doc.get_mut(id)?.kind
&& let Some(o) = v.as_object()
{
for (pk, pv) in o {
p.insert(pk.clone(), pv.clone());
}
}
}
_ => return Ok(false),
}
Ok(true)
}
/// A `{$var}` wrapper on `fill` or `stroke`: the first paint binds to that variable.
fn apply_variable(cmd: &str, doc: &mut Document, id: NodeId, k: &str, v: &Value) -> Result<bool> {
let Some(name) = variable_prop(cmd, k, v)? else { return Ok(false) };
let vid = super::variables::resolve_strict(cmd, doc, name)?;
// All aliases of the first paint name one slot; other paint slots stay bound.
super::styles::unbind_slot(doc.get_mut(id)?, k == "fill", 0);
super::styles::bind_variable(cmd, doc, &[id], k, Some(&vid))?;
// A paint bound through props follows the variable, not its former style. Keep this
// local to `$var`, including when the style and variable happen to give the same colour.
let n = doc.get_mut(id)?;
if k == "fill" {
n.styles.fill = None;
} else {
n.styles.stroke = None;
}
Ok(true)
}
/// Apply a property map to one node. `x`/`y` are relative to the parent.
pub fn apply(cmd: &str, doc: &mut Document, id: NodeId, props: &Map<String, Value>) -> Result<()> {
layout_keys_beside_none(cmd, props)?;
let mut unknown = Vec::new();
let mut keys: Vec<(&String, &Value)> = props.iter().collect();
keys.sort_by_key(|(k, v)| apply_order(k, v));
// Where a new `path` had its own box, for `x`/`y` in the same call (as `node.create` places it).
let mut path_offset = (0.0, 0.0);
for (k, v) in keys {
let k = k.as_str();
if apply_variable(cmd, doc, id, k, v)?
|| apply_geometry(cmd, doc, id, props, k, v, &mut path_offset)?
|| apply_look(cmd, doc, id, k, v)?
|| apply_corners(cmd, doc, id, k, v)?
|| apply_layout(cmd, doc, id, k, v)?
|| apply_sizing(cmd, doc, id, k, v)?
|| apply_meta(cmd, doc, id, k, v)?
|| apply_text(cmd, doc, id, props, k, v)?
|| apply_shape(cmd, doc, id, k, v)?
{
continue;
}
unknown.push(k.to_string());
}
if !unknown.is_empty() {
return Err(bad(cmd, format!("unknown properties: {} (known: {KEYS})", unknown.join(", "))));
}
// Inside an instance, record which property groups were overridden (an instance's own export
// settings and interactions are its own, not overrides). Its resizing is recorded like any
// layer's: the sync takes the main's Hug / Fixed unless it is overridden, and Reset instance
// clears it. Inferred: Figma was measured only with a typed width (kept); a resizing chosen
// from the dropdown is taken as an override the same way, as every property set on an
// instance in Figma is one.
let own_root = matches!(doc.get(id)?.kind, NodeKind::Instance { .. }) && !crate::components::inside_instance(doc, id);
let n = doc.get_mut(id)?;
if n.source.is_some() {
for g in props.keys().map(|k| override_group(k)).filter(|g| *g != "other" && !(own_root && matches!(*g, "exports" | "interactions"))) {
n.overrides.insert(g.to_string());
}
}
Ok(())
}
/// Replace vector `id`'s geometry with SVG path data `v`, as `node.create` reads it: `width`/`height`
/// in the same call scale it, and the path's own box goes at the layer's origin, which keeps its
/// place, rotation and everything else. Returns where the path's own box was, which `x`/`y` in the
/// same call add (so `{path, x: 0, y: 0}` places it as `node.create` does). Layers inside an
/// instance are refused: their geometry comes from the main component, and a sync would undo it.
fn set_path(cmd: &str, doc: &mut Document, id: NodeId, v: &Value, props: &Map<String, Value>) -> Result<(f64, f64)> {
let d = v.as_str().ok_or_else(|| bad(cmd, "`path` must be SVG path data (a string)"))?;
let n = doc.get(id)?;
if !matches!(n.kind, NodeKind::Vector { .. }) {
return Err(bad(cmd, format!("`path` applies to vector layers, and layer {} โ{}โ is a {}", n.id, n.name, n.kind.type_name())));
}
if crate::components::inside_instance(doc, id) {
return Err(bad(cmd, format!("`path`: layer {} โ{}โ is inside an instance: edit its main component, or detach the instance", n.id, n.name)));
}
let size = |long: &str, short: &str| -> Result<Option<f64>> {
props.get(long).or_else(|| props.get(short)).map(|v| f64_of(v).ok_or_else(|| bad(cmd, format!("`{long}` must be a number")))).transpose()
};
let shape = super::create::path_network(cmd, d, size("width", "w")?, size("height", "h")?)?;
let n = doc.get_mut(id)?;
if let NodeKind::Vector { network } = &mut n.kind {
*network = shape.network;
}
n.width = shape.width;
n.height = shape.height;
Ok(shape.offset)
}
/// The override group a property key belongs to.
pub fn override_group(k: &str) -> &'static str {
match k {
"fills" | "fill" => "fills",
"strokes" | "stroke" | "strokeWeight" | "strokeAlign" | "dashes" | "dashCap" | "strokeCap" | "startCap" | "endCap" | "strokeJoin"
| "strokeSides" | "strokeTopWeight" | "strokeRightWeight" | "strokeBottomWeight" | "strokeLeftWeight" | "miterLimit" | "miterAngle"
| "widthProfile" | "brush" | "strokeBrush" => "strokes",
"effects" => "effects",
"opacity" | "blend" | "blendMode" => "opacity",
"visible" => "visible",
"name" => "name",
"characters" | "text" => "characters",
"features" | "fontFeatures" | "openTypeFeatures" | "listStyle" | "indentation" | "listSpacing" | "maxLines" | "variationSettings"
| "hangingPunctuation" | "hangingList" | "wrapStyle" | "textWrap" | "textDirection" | "direction" => "textStyle",
"cornerRadius" | "cornerSmoothing" | "topLeftRadius" | "topRightRadius" | "bottomRightRadius" | "bottomLeftRadius" => "corners",
"width" | "height" | "w" | "h" => "size",
"sizingH" | "sizingV" | "layoutSizingHorizontal" | "layoutSizingVertical" | "minWidth" | "maxWidth" | "minHeight" | "maxHeight" => "resizing",
"gap" | "itemSpacing" | "columnGap" | "crossGap" | "counterAxisSpacing" | "rowGap" => "gap",
"padding" | "paddingTop" | "paddingRight" | "paddingBottom" | "paddingLeft" | "paddingHorizontal" | "paddingVertical" => "padding",
"mainAlign" | "primaryAxisAlignItems" | "crossAlign" | "counterAxisAlignItems" | "contentAlign" | "counterAxisAlignContent" => "alignment",
"grids" | "layoutGrids" | "gridStyle" => "grids",
"exports" | "exportSettings" => "exports",
"interactions" => "interactions",
k if k.starts_with("font") || k.starts_with("text") || k.starts_with("letter") || k.starts_with("line") || k.starts_with("paragraph") => {
"textStyle"
}
_ => "other",
}
}
fn string_val(v: &Value) -> Option<String> {
match v {
Value::String(s) => Some(s.clone()),
Value::Number(n) => Some(n.to_string()),
_ => None,
}
}
fn range_of(props: &Map<String, Value>, len: usize) -> (usize, usize) {
let s = props.get("start").and_then(f64_of).map(|v| v.max(0.0) as usize).unwrap_or(0);
let e = props.get("end").and_then(f64_of).map(|v| v.max(0.0) as usize).unwrap_or(len);
(s.min(len), e.min(len))
}
/// Set one text style property on chars `start..end`.
pub fn apply_text_style(cmd: &str, t: &mut TextData, start: usize, end: usize, k: &str, v: &Value) -> Result<()> {
match k {
"fontFamily" => {
let fam = string_val(v).ok_or_else(|| bad(cmd, "`fontFamily` must be a string"))?;
// Keep the style if the new family has it, else the nearest.
let styles = figcraft_text::family_styles(&fam);
t.restyle(start, end, |s| {
s.font_family = fam.clone();
if !styles.is_empty() && !styles.contains(&s.font_style) {
let want = s.weight();
if let Some(best) = styles.iter().min_by_key(|st| (i32::from(style_weight(st)) - i32::from(want)).abs()) {
s.font_style = best.clone();
}
}
});
}
"fontStyle" => {
let st = string_val(v).ok_or_else(|| bad(cmd, "`fontStyle` must be a string"))?;
t.restyle(start, end, |s| s.set_font_style(st.clone()));
}
"fontWeight" => {
let w = f64_of(v).ok_or_else(|| bad(cmd, "`fontWeight` must be a number"))?;
let name = weight_name(w.clamp(1.0, 1000.0) as u16);
t.restyle(start, end, |s| {
let italic = s.italic();
s.set_font_style(styled_name(name, italic));
});
}
"fontVariations" | "variationSettings" => {
// Replaces the custom axis values (null or {} = back to what the style name implies).
let vars = variations_of(cmd, v)?;
t.restyle(start, end, |s| {
s.variations.clear();
for (k, val) in &vars {
if let Some(val) = val {
s.variations.insert(k.clone(), *val);
}
}
});
}
"fontSize" => {
let sz = f64_of(v).ok_or_else(|| bad(cmd, "`fontSize` must be a number"))?.clamp(1.0, 5000.0);
t.restyle(start, end, |s| s.font_size = sz);
}
"lineHeight" => {
let lh = line_height(v).ok_or_else(|| bad(cmd, "lineHeight: auto | px | \"150%\""))?;
t.restyle(start, end, |s| s.line_height = lh);
}
"letterSpacing" => {
let ls = letter_spacing(v).ok_or_else(|| bad(cmd, "letterSpacing: px | \"2%\""))?;
t.restyle(start, end, |s| s.letter_spacing = ls);
}
"textDecoration" => {
let d: TextDecoration = enum_of(v).ok_or_else(|| bad(cmd, "textDecoration: none|underline|strikethrough"))?;
t.restyle(start, end, |s| s.decoration = d);
}
"textDecorationStyle" => {
let d: DecorationStyle = enum_of(v).ok_or_else(|| bad(cmd, "textDecorationStyle: solid|dotted|wavy"))?;
t.restyle(start, end, |s| s.set_look(|l| l.style = d));
}
"textDecorationThickness" | "textDecorationOffset" => {
let m = line_height(v)
.filter(|m| !matches!(m, LineHeight::Pixels(x) | LineHeight::Percent(x) if !x.is_finite() || x.abs() > 10_000.0))
.ok_or_else(|| bad(cmd, format!("{k}: auto | px | \"10%\"")))?;
let thickness = k == "textDecorationThickness";
t.restyle(start, end, |s| s.set_look(|l| *if thickness { &mut l.thickness } else { &mut l.offset } = m));
}
"textDecorationSkipInk" => {
let on = v.as_bool().ok_or_else(|| bad(cmd, "textDecorationSkipInk must be true or false"))?;
t.restyle(start, end, |s| s.set_look(|l| l.skip_ink = on));
}
"textDecorationColor" => {
let auto = v.is_null() || v.as_str().is_some_and(|s| s.eq_ignore_ascii_case("auto"));
let c = if auto { None } else { Some(color_of(v).ok_or_else(|| bad(cmd, "textDecorationColor: a colour, or auto"))?) };
t.restyle(start, end, |s| s.set_look(|l| l.color = c));
}
"textCase" => {
let c: TextCase = enum_of(v).ok_or_else(|| bad(cmd, "textCase: original|upper|lower|title|smallCaps"))?;
t.restyle(start, end, |s| s.case = c);
}
"hyperlink" => {
let l = string_val(v);
t.restyle(start, end, |s| s.link = l.clone());
}
"textFills" => {
let p = if v.is_null() { None } else { Some(paints_of(v).ok_or_else(|| bad(cmd, "textFills: paints"))?) };
t.restyle(start, end, |s| s.fills = p.clone());
}
_ => {}
}
Ok(())
}
/// OpenType feature toggles from `{tag: bool | null}` (null = back to the font's default).
pub fn features_of(cmd: &str, v: &Value) -> Result<Vec<(String, Option<bool>)>> {
let Value::Object(m) = v else { return Err(bad(cmd, "features: {tag: bool}, e.g. {\"liga\": false}")) };
let mut out = Vec::with_capacity(m.len());
for (k, on) in m {
if !valid_feature_tag(k) {
return Err(bad(cmd, format!("`{k}` is not a 4-character OpenType feature tag")));
}
let on = match on {
Value::Null => None,
Value::Bool(b) => Some(*b),
other => Some(f64_of(other).ok_or_else(|| bad(cmd, format!("feature `{k}` must be true, false or null")))? != 0.0),
};
out.push((k.clone(), on));
}
Ok(out)
}
/// Variable font axis values from `{tag: number | null}` (null = back to what the style implies).
/// `null` alone means "no custom values".
pub fn variations_of(cmd: &str, v: &Value) -> Result<Vec<(String, Option<f64>)>> {
let m = match v {
Value::Null => return Ok(Vec::new()),
Value::Object(m) => m,
_ => return Err(bad(cmd, "variations: {axis: number}, e.g. {\"wght\": 550, \"wdth\": 85}")),
};
let mut out = Vec::with_capacity(m.len());
for (k, val) in m {
if !valid_axis_tag(k) {
return Err(bad(cmd, format!("`{k}` is not a 4-character OpenType axis tag")));
}
let val = match val {
Value::Null => None,
other => Some(f64_of(other).filter(|x| x.abs() <= 1e6).ok_or_else(|| bad(cmd, format!("axis `{k}` must be a number or null")))?),
};
out.push((k.clone(), val));
}
Ok(out)
}
/// "Bold" + italic โ "Bold Italic"; "Regular" + italic โ "Italic".
pub fn styled_name(weight: &str, italic: bool) -> String {
match (italic, weight) {
(false, w) => w.to_string(),
(true, "Regular") => "Italic".into(),
(true, w) => format!("{w} Italic"),
}
}
pub fn weight_name(w: u16) -> &'static str {
match w {
0..=149 => "Thin",
150..=249 => "Extra Light",
250..=349 => "Light",
350..=449 => "Regular",
450..=549 => "Medium",
550..=649 => "Semi Bold",
650..=749 => "Bold",
750..=849 => "Extra Bold",
_ => "Black",
}
}
fn set_sizing(cmd: &str, doc: &mut Document, id: NodeId, s: Sizing, horizontal: bool) -> Result<()> {
let parent = doc.get(id)?.parent.filter(|p| doc.node(*p).is_some_and(|p| p.layout.is_some()));
match s {
Sizing::Fill if parent.is_none() => return Err(bad(cmd, "Fill needs an auto layout parent")),
Sizing::Hug if doc.get(id)?.layout.is_none() && !matches!(doc.get(id)?.kind, NodeKind::Text(_)) => {
return Err(bad(cmd, "Hug needs auto layout or text"));
}
_ => {}
}
// A child can't fill the axis its parent hugs along the flow: the parent becomes fixed at its
// current size. Across the flow the parent keeps hugging and the child takes the line's size
// (the largest sibling that doesn't fill); the parent becomes fixed only when no such sibling
// is left. (The other way round, a parent that starts to hug fixes the children that filled it
// along the flow: see `figcraft_layout::coherent_sizing`, applied after every edit.)
if s == Sizing::Fill
&& let Some(p) = parent
{
let pn = doc.get(p)?;
if figcraft_layout::wrapping_row_hugs_across(pn, horizontal) {
return Err(bad(cmd, "Fill container across a wrapping row is not offered"));
}
let along = match pn.layout.as_ref().map(|al| al.mode) {
Some(LayoutMode::Horizontal) => horizontal,
Some(LayoutMode::Vertical) => !horizontal,
_ => true,
};
let others_fill = figcraft_layout::flow_children(doc, p)
.into_iter()
.filter(|c| *c != id)
.all(|c| doc.node(c).is_some_and(|c| (if horizontal { c.child_layout.sizing_h } else { c.child_layout.sizing_v }) == Sizing::Fill));
if along || others_fill {
let cl = &mut doc.get_mut(p)?.child_layout;
let ps = if horizontal { &mut cl.sizing_h } else { &mut cl.sizing_v };
if *ps == Sizing::Hug {
*ps = Sizing::Fixed;
// An instance's own root, or a layer inside one, turned Fixed by this edit: that
// is its resizing now, an override, or the next rebuild from the main would take
// the main's Hug back and the child would stop filling.
if doc.get(p)?.source.is_some() {
doc.get_mut(p)?.overrides.insert("resizing".to_string());
}
}
}
}
// Start from the sizing the layer has in effect (an auto-width text hugs both axes), so the
// other axis keeps its meaning: an auto-width text set to fill its width wraps (auto height).
figcraft_layout::coherent_sizing(doc, id);
let n = doc.get_mut(id)?;
if horizontal {
n.child_layout.sizing_h = s;
} else {
n.child_layout.sizing_v = s;
}
if let NodeKind::Text(t) = &mut n.kind {
t.auto_resize = match (n.child_layout.sizing_h, n.child_layout.sizing_v) {
(Sizing::Hug, _) => TextAutoResize::WidthAndHeight,
(_, Sizing::Hug) => TextAutoResize::Height,
_ if t.truncates() => TextAutoResize::Truncate,
_ => TextAutoResize::None,
};
}
Ok(())
}
/// The hugging parents that `props` setting Fill on `ids` may turn Fixed, as (parent, horizontal):
/// taken before the edit, for [`fixed_notice`].
pub(crate) fn hugging_parents(doc: &Document, ids: &[NodeId], props: &Map<String, Value>) -> Vec<(NodeId, bool)> {
let mut out = Vec::new();
for (horizontal, keys) in [(true, ["sizingH", "layoutSizingHorizontal"]), (false, ["sizingV", "layoutSizingVertical"])] {
if !keys.iter().any(|k| props.get(*k).and_then(sizing) == Some(Sizing::Fill)) {
continue;
}
for p in ids.iter().filter_map(|i| doc.node(*i)).filter_map(|n| n.parent) {
let hugs = doc
.node(p)
.is_some_and(|p| p.layout.is_some() && (if horizontal { p.child_layout.sizing_h } else { p.child_layout.sizing_v }) == Sizing::Hug);
if hugs && !out.contains(&(p, horizontal)) {
out.push((p, horizontal));
}
}
}
out
}
/// The children, as (child, horizontal), that fill an axis of a frame in `ids` which `props` sets
/// to Hug: taken before the edit, for [`fixed_notice`] (the coherence pass turns them Fixed).
pub(crate) fn filling_children(doc: &Document, ids: &[NodeId], props: &Map<String, Value>) -> Vec<(NodeId, bool)> {
let mut out = Vec::new();
for (horizontal, keys) in [(true, ["sizingH", "layoutSizingHorizontal"]), (false, ["sizingV", "layoutSizingVertical"])] {
if !keys.iter().any(|k| props.get(*k).and_then(sizing) == Some(Sizing::Hug)) {
continue;
}
for f in ids.iter().filter_map(|i| doc.node(*i)).filter(|n| n.layout.is_some() && n.kind.is_frame_like()) {
for c in f.children.iter().filter_map(|c| doc.node(*c)) {
let fills = (if horizontal { c.child_layout.sizing_h } else { c.child_layout.sizing_v }) == Sizing::Fill;
if fills && !out.contains(&(c.id, horizontal)) {
out.push((c.id, horizontal));
}
}
}
}
out
}
/// The notice for the layers of [`hugging_parents`] or [`filling_children`] that the edit turned
/// Fixed ("Height set to Fixed for Frame 1"), `None` when every one kept its sizing.
pub(crate) fn fixed_notice(doc: &Document, before: &[(NodeId, bool)]) -> Option<String> {
let notes: Vec<String> = before
.iter()
.filter_map(|(p, horizontal)| {
let p = doc.node(*p)?;
let now = if *horizontal { p.child_layout.sizing_h } else { p.child_layout.sizing_v };
(now == Sizing::Fixed).then(|| format!("{} set to Fixed for {}", if *horizontal { "Width" } else { "Height" }, p.name))
})
.collect();
(!notes.is_empty()).then(|| notes.join("; "))
}
/// Resize a node's box from its top-left, applying constraints / group scaling to children.
/// The page transforms of `id`'s children, to put back with [`restore_worlds`] once a container
/// whose contents stay where they are on the page (a section; a frame resized with Cmd/Ctrl held)
/// has moved or changed size.
pub fn children_worlds(doc: &Document, id: NodeId) -> Vec<(NodeId, Affine)> {
doc.node(id).map(|n| n.children.iter().map(|c| (*c, doc.world_transform(*c))).collect()).unwrap_or_default()
}
pub fn restore_worlds(doc: &mut Document, worlds: &[(NodeId, Affine)]) -> Result<()> {
for (c, w) in worlds {
doc.set_world_transform(*c, *w)?;
}
Ok(())
}
pub fn resize_node(doc: &mut Document, id: NodeId, w: f64, h: f64) -> Result<()> {
let n = doc.get(id)?;
let (ow, oh) = (n.width, n.height);
let group = n.kind.bounds_follow_children();
let section = matches!(n.kind, NodeKind::Section { .. });
figcraft_layout::set_size(doc, id, w, h);
if section {
// Sections have no constraints: what's in them stays as it is.
} else if group {
let kx = if ow > 1e-9 { w / ow } else { 1.0 };
let ky = if oh > 1e-9 { h / oh } else { 1.0 };
figcraft_layout::scale_group_children(doc, id, kx, ky);
} else {
// In an auto layout frame this moves only the children that ignore auto layout.
figcraft_layout::apply_constraints(doc, id, ow, oh);
}
Ok(())
}
/// The design-panel view of a node (used by the UI and inspect).
pub fn describe(doc: &Document, id: NodeId) -> Value {
let Some(n) = doc.node(id) else { return Value::Null };
let c = doc.frame_relative(id).as_coeffs();
let mut v = json!({
"id": n.id,
"name": n.name,
"type": n.kind.type_name(),
"x": c[4], "y": c[5],
"width": n.width, "height": n.height,
"rotation": figcraft_geom::round_to(figcraft_geom::rotation_degrees(n.transform), 3),
"visible": n.visible, "locked": n.locked,
"opacity": n.opacity, "blend": n.blend,
});
if let Some(b) = doc.world_bounds(id) {
v["absoluteBounds"] = json!({"x": b.x0, "y": b.y0, "width": b.width(), "height": b.height()});
}
let _ = Point::ZERO;
let _ = Color::BLACK;
v
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn non_finite_percent_strings_are_rejected() {
for s in ["NaN%", "inf%", "-inf%"] {
assert!(line_height(&json!(s)).is_none(), "line_height accepted {s}");
assert!(letter_spacing(&json!(s)).is_none(), "letter_spacing accepted {s}");
}
assert!(matches!(line_height(&json!("150%")), Some(LineHeight::Percent(p)) if p == 150.0));
}
#[test]
fn four_rejects_non_numeric_entries() {
assert_eq!(four(&json!([10, "abc"])), None);
assert_eq!(four(&json!([10, "abc", null, 20])), None);
assert_eq!(four(&json!([10, 20, 30])), None);
assert_eq!(four(&json!([1, 2, 3, 4])), Some([1.0, 2.0, 3.0, 4.0]));
assert_eq!(four(&json!([1, 2])), Some([1.0, 2.0, 1.0, 2.0]));
}
}
No file is open. Choose one in the tree, or press Ctrl+O (โO on a Mac) to find one by name.
Syntax highlighting could not load. The unmodified read-only text remains available above.