diff --git a/crates/engine/src/design_context_tests.rs b/crates/engine/src/design_context_tests.rs index 3aa0ab09b..4e5588480 100644 --- a/crates/engine/src/design_context_tests.rs +++ b/crates/engine/src/design_context_tests.rs @@ -286,3 +286,67 @@ fn junk_parameters_are_errors_not_panics() { assert!(s.execute("inspect.designContext", &json!({"ids": []})).is_ok()); assert!(s.execute("inspect.designContext", &json!({"maxNodes": 0})).is_ok()); } + +/// A colour variable in collection Theme (Light, Dark): (collection id, variable id). +fn variable(s: &mut Session, name: &str, light: &str, dark: &str) -> (Value, String) { + let c = s.execute("variable.createCollection", &json!({"name": format!("{name} theme"), "modes": ["Light", "Dark"]})).unwrap()["id"].clone(); + let v = s.execute("variable.create", &json!({"collection": c, "name": name, "type": "color", "values": {"Light": light, "Dark": dark}})).unwrap(); + (c, v["id"].as_str().unwrap().to_string()) +} + +#[test] +fn a_variable_an_alias_reads_is_joined_too() { + let mut s = session(); + let (c, brand) = variable(&mut s, "brand", "#3B5BDB", "#748FFC"); + let button = s + .execute("variable.create", &json!({"collection": c, "name": "button", "type": "color", "values": {"Light": "#000000", "Dark": "#000000"}})) + .unwrap()["id"] + .as_str() + .unwrap() + .to_string(); + for mode in ["Light", "Dark"] { + s.execute("variable.set", &json!({"variable": button, "mode": mode, "value": {"alias": brand}})).unwrap(); + } + let r = node(&mut s, json!({"type": "rectangle", "width": 10, "height": 10, "props": {"fill": {"$var": button}}})); + let v = context(&mut s, json!({"ids": [r]})); + assert!(v["variables"].get(&button).is_some()); + assert_eq!(v["variables"][&brand]["name"], "brand", "the aliased variable is defined as well: {}", v["variables"]); +} + +#[test] +fn a_variable_a_shared_style_binds_is_joined() { + let mut s = session(); + let (_, brand) = variable(&mut s, "brand", "#3B5BDB", "#748FFC"); + let r = node(&mut s, json!({"type": "rectangle", "width": 10, "height": 10, "props": {"fill": "#FF0000"}})); + let st = s.execute("style.create", &json!({"type": "paint", "name": "Brand/Fill", "from": r})).unwrap()["id"].clone(); + s.execute("style.bind", &json!({"style": st, "field": "fill", "variable": brand})).unwrap(); + s.execute("style.apply", &json!({"style": st, "ids": [r]})).unwrap(); + let v = context(&mut s, json!({"ids": [r]})); + assert_eq!(only(&v)["tokens"]["style.fill"]["name"], "Brand/Fill"); + assert_eq!(v["variables"][&brand]["name"], "brand", "the style's variable is defined: {}", v["variables"]); +} + +#[test] +fn every_returned_text_layer_has_its_font_listed() { + let mut s = session(); + let title = node(&mut s, json!({"type": "text", "text": "Title", "props": {"fontFamily": "Serif Display Test"}})); + let busy = node(&mut s, json!({"type": "frame", "x": 300, "width": 200, "height": 200})); + for _ in 0..12 { + node(&mut s, json!({"type": "rectangle", "parent": busy, "width": 4, "height": 4})); + } + let v = context(&mut s, json!({"ids": [title, busy], "maxNodes": 2})); + assert_eq!(v["target"]["layers"], 2); + let families: Vec<&str> = v["fonts"].as_array().unwrap().iter().map(|f| f["family"].as_str().unwrap()).collect(); + assert_eq!(families, ["Serif Display Test"], "{}", v["fonts"]); +} + +#[test] +fn a_malformed_target_is_refused_rather_than_read_as_the_selection() { + let mut s = session(); + let (f, _, _) = card(&mut s); + s.execute("select.set", &json!({"ids": [f]})).unwrap(); + for p in [json!({"id": "not-an-id"}), json!({"id": true}), json!({"ids": [f, "nope"]}), json!({"ids": "1"})] { + assert!(s.execute("inspect.designContext", &p).is_err(), "{p}"); + } + assert_eq!(context(&mut s, json!({"ids": []}))["target"]["layers"], 0, "an empty list reads nothing"); +} diff --git a/crates/engine/src/dev/design_context.rs b/crates/engine/src/dev/design_context.rs index bb2d6aff5..f196b7495 100644 --- a/crates/engine/src/dev/design_context.rs +++ b/crates/engine/src/dev/design_context.rs @@ -45,6 +45,8 @@ struct Used { left_out: usize, /// Reached `depth` with children left. cut_by_depth: bool, + /// Font families of the text layers placed, with their styles. + fonts: BTreeMap>, } /// `property` of a layer has no direct CSS equivalent, because `why`. @@ -183,6 +185,11 @@ fn code(doc: &Document, id: NodeId) -> Vec { fn layer(doc: &Document, id: NodeId, depth: usize, cap: usize, used: &mut Used) -> Option { let n = doc.node(id)?; used.nodes += 1; + if let NodeKind::Text(t) = &n.kind { + for (_, _, style) in t.spans() { + used.fonts.entry(style.font_family.clone()).or_default().insert(style.font_style.clone()); + } + } let Value::Object(mut explicit) = node_json(doc, id, 0) else { return None }; explicit.remove("childCount"); let mut out = Map::new(); @@ -251,8 +258,8 @@ fn value_json(v: &figcraft_doc::VariableValue) -> Value { } } -/// The variables the tree uses: every mode's stored and resolved value. A value that is an alias -/// or a calculation stays in `value`, and aliased variables are listed too, in `aliases`. +/// `ids`' variables: every mode's stored and resolved value. A value that is an alias or a +/// calculation stays in `value`; the variables it reads are in `ids` too ([`referenced`]). fn variables_json(doc: &Document, ids: &BTreeSet, missing: &mut Vec) -> Value { let store = &doc.variables; let mut out = Map::new(); @@ -287,6 +294,37 @@ fn variables_json(doc: &Document, ids: &BTreeSet, missing: &mut Vec BTreeSet { + let mut out: BTreeSet = used.variables.clone(); + out.extend(doc.styles.iter().filter(|st| used.styles.contains(&st.id)).flat_map(|st| st.bound.values().cloned())); + let mut todo: Vec = out.iter().cloned().collect(); + while let Some(id) = todo.pop() { + if out.len() >= MAX_VARIABLES { + break; + } + let Some(var) = doc.variables.variables.iter().find(|v| v.id == id) else { continue }; + for value in var.values.values() { + let reads: Vec<&String> = match value { + figcraft_doc::VariableValue::Alias(other) => vec![other], + figcraft_doc::VariableValue::ColorAlpha { variable, .. } => vec![variable], + figcraft_doc::VariableValue::ColorMix { from, to, .. } => from.variable().into_iter().chain(to.variable()).collect(), + _ => vec![], + }; + for other in reads { + if out.insert(other.clone()) { + todo.push(other.clone()); + } + } + } + } + out +} + /// The shared styles the tree uses, with what each sets. fn styles_json(doc: &Document, ids: &BTreeSet, missing: &mut Vec) -> Value { let mut out = Map::new(); @@ -320,29 +358,13 @@ fn components_json(doc: &Document, ids: &BTreeSet) -> Value { Value::Object(out) } -/// The font families under `ids`' tree, with their styles. -fn fonts(doc: &Document, roots: &[NodeId], cap: usize) -> Value { - let mut used: BTreeMap> = BTreeMap::new(); - let mut stack: Vec = roots.to_vec(); - let mut seen = 0usize; - while let Some(id) = stack.pop() { - seen += 1; - if seen > cap { - break; - } - let Some(n) = doc.node(id) else { continue }; - if let NodeKind::Text(t) = &n.kind { - for (_, _, s) in t.spans() { - used.entry(s.font_family.clone()).or_default().insert(s.font_style.clone()); - } - } - stack.extend(n.children.iter().copied()); - } +/// The font families the tree's text layers use, with their styles, and whether each is installed. +fn fonts(doc: &Document, used: &BTreeMap>) -> Value { let gone = crate::fonts::missing(doc); Value::Array( - used.into_iter() + used.iter() .map(|(family, styles)| { - let installed = !gone.iter().any(|m| m.family.eq_ignore_ascii_case(&family)); + let installed = !gone.iter().any(|m| m.family.eq_ignore_ascii_case(family)); json!({"family": family, "styles": styles, "installed": installed}) }) .collect(), @@ -353,6 +375,13 @@ fn fonts(doc: &Document, roots: &[NodeId], cap: usize) -> Value { fn roots(s: &Session, p: &Value) -> Result<(&'static str, Vec)> { let cmd = "inspect.designContext"; let doc = s.doc()?; + let malformed = || bad(cmd, "ids: a list of layer ids (or id: one)"); + match (get(p, "ids"), get(p, "id")) { + (Some(Value::Array(list)), _) if list.iter().all(|i| crate::params::id_of(i).is_some()) => {} + (Some(_), _) => return Err(malformed()), + (None, Some(one)) if crate::params::id_of(one).is_none() => return Err(malformed()), + _ => {} + } if get(p, "ids").is_some() || get(p, "id").is_some() { let ids: Vec = targets(s, p); if let Some(gone) = ids.iter().find(|i| !doc.contains(**i)) { @@ -400,10 +429,10 @@ fn design_context(s: &mut Session, p: &Value) -> Result { let mut missing = vec![ json!({"what": "responsive behaviour", "why": "the file stores no breakpoints: sizes are as designed here, and constraints, sizing and annotations are all it says about other widths"}), ]; - let variables = variables_json(doc, &used.variables, &mut missing); + let variables = variables_json(doc, &referenced(doc, &used), &mut missing); let styles = styles_json(doc, &used.styles, &mut missing); let components = components_json(doc, &used.components); - let fonts = fonts(doc, &ids, cap.saturating_mul(4)); + let fonts = fonts(doc, &used.fonts); let page = doc.node(s.page()?).map(|n| n.name.clone()); let mut out = json!({ "version": VERSION, diff --git a/docs/mcp.md b/docs/mcp.md index cad511f21..858f64003 100644 --- a/docs/mcp.md +++ b/docs/mcp.md @@ -431,7 +431,7 @@ a later step can use `{"$step": 0, "field": "ids/0"}` to target the first match. | `document` | `name`, `page`, `colorProfile` | | `target` | `source` (`selection`, `ids`, `page`, `document`), `ids`, `layers` in the tree | | `nodes` | The tree, below | -| `variables` | By id: `name`, `collection`, `type`, `codeSyntax`, and `modes` with each `mode`'s stored `value` and `resolved` value | +| `variables` | By id: `name`, `collection`, `type`, `codeSyntax`, and `modes` with each `mode`'s stored `value` and `resolved` value. The tree's layers and shared styles bind them, or another one reads them as an alias or in a colour calculation | | `styles` | By id: the shared styles the tree uses | | `components` | By id: `name`, `type`, `properties` with variants, `codeLinks` | | `fonts` | `family`, `styles`, and whether it's `installed` |