fix(anatomy): V1-2.2 marker layer and halo outside the drawing's group

Owner-approved lot B (brief 2026-11-01). The composition root is the
engine's (namespaces and frame); the drawing's root becomes a group and
the marker layer and halo are its siblings, so no root property reaches
a marker. Point hitboxes declare stroke none and visibleFill. Census over
the reader's whole allowlist; R3 references compared under the declared
transform; click proofs in three engines.
This commit is contained in:
bchanot committed 2026-11-01 00:39:57 +01:00
1 parent f1bb19b30b
commit 4f52f5e1c4
23 files changed
+933 -112

No files matched your search

+74
View File
@@ -101,3 +101,77 @@ pub fn view_names(
.map(|v| (v.id().to_owned(), v.name().fr.clone(), v.name().en.clone()))
.collect()
}
/// Owner brief 2026-10-30 (V1-2.2, three MEDIUM): the composition root is the engine's. Applied
/// to a frozen view tree before comparing, written apart from the core: the root keeps its
/// namespaces and `viewBox`; its other attributes and every child before the layer go into a
/// `<g>`; the halo filter leaves the drawing for an engine `<defs>` placed before the layer;
/// each point hitbox (a circle capturing on `all` with no stroke of its own) declares
/// `stroke="none"` and `pointer-events="visibleFill"`.
pub fn with_isolated_layer(tree: &mut Value) {
let root = tree.as_object_mut().unwrap();
let mut children = root["children"].as_array().unwrap().clone();
let mut layer = children.pop().unwrap();
let halo = take_halo(&mut children);
let attrs = root["attrs"].as_object().unwrap().clone();
let (kept, moved): (Vec<_>, Vec<_>) = attrs
.into_iter()
.partition(|(name, _)| ["xmlns", "xmlns:xlink", "viewBox"].contains(&name.as_str()));
let group = json!({
"ns": root["ns"], "name": "g",
"attrs": moved.into_iter().collect::<serde_json::Map<_, _>>(),
"children": children,
});
let mut out = vec![group];
if let Some(halo) = halo {
out.push(json!({ "ns": SVG_NS, "name": "defs", "attrs": {}, "children": [halo] }));
}
for marker in layer["children"].as_array_mut().unwrap() {
let circle = marker["name"] == "circle";
let attrs = marker["attrs"].as_object_mut().unwrap();
let hitbox = circle
&& attrs.get("pointer-events") == Some(&json!("all"))
&& !attrs.contains_key("stroke");
if hitbox {
attrs.insert("stroke".to_owned(), json!("none"));
attrs.insert("pointer-events".to_owned(), json!("visibleFill"));
}
}
out.push(layer);
root.insert(
"attrs".to_owned(),
Value::Object(kept.into_iter().collect()),
);
root.insert("children".to_owned(), Value::Array(out));
}
/// Removes `filter#osteo-halo` from the frozen drawing (and the `<defs>` the engine created for
/// it alone, placed first), answering it.
fn take_halo(children: &mut Vec<Value>) -> Option<Value> {
let first_is_engine_defs = children.first().is_some_and(|c| {
c["name"] == "defs"
&& c["children"]
.as_array()
.is_some_and(|k| k.len() == 1 && k[0]["attrs"]["id"] == "osteo-halo")
});
if first_is_engine_defs {
return Some(children.remove(0)["children"][0].clone());
}
for child in children.iter_mut() {
if let Some(found) = take_from(child) {
return Some(found);
}
}
None
}
fn take_from(node: &mut Value) -> Option<Value> {
let kids = node.get_mut("children")?.as_array_mut()?;
if let Some(at) = kids
.iter()
.position(|k| k["name"] == "filter" && k["attrs"]["id"] == "osteo-halo")
{
return Some(kids.remove(at));
}
kids.iter_mut().find_map(take_from)
}