figcraft/crates/format/src/fig/prop_value_tests.rs

//! Component properties as current `.fig` files write them, on synthetic messages: the copy of a
//! set's definitions each variant keeps (`parentPropDefId`, no name or type of its own), and
//! assignments that carry their value only in the variable form (`varValue`).

use figcraft_doc::NodeKind;
use serde_json::Value;

use super::kiwi::Kv;
use super::map::to_rest;

fn g(local: u32) -> Kv<'static> {
    Kv::Object(vec![("sessionID", Kv::Uint(9)), ("localID", Kv::Uint(u64::from(local)))])
}

fn o(fields: Vec<(&'static str, Kv<'static>)>) -> Kv<'static> {
    Kv::Object(fields)
}

fn s(text: &str) -> Kv<'static> {
    Kv::Str(text.into())
}

fn node(local: u32, kind: &'static str, name: &str, parent: Option<u32>, mut fields: Vec<(&'static str, Kv<'static>)>) -> Kv<'static> {
    let mut all = vec![("guid", g(local)), ("type", Kv::Enum(kind)), ("name", s(name))];
    if let Some(parent) = parent {
        all.push(("parentIndex", o(vec![("guid", g(parent)), ("position", s("!"))])));
    }
    all.append(&mut fields);
    o(all)
}

/// A layer's `field` bound to property definition `def`.
fn bound(field: &'static str, def: u32) -> (&'static str, Kv<'static>) {
    let entry = o(vec![
        ("variableField", Kv::Enum(field)),
        ("variableData", o(vec![("value", o(vec![("propRefValue", o(vec![("defId", g(def))]))])), ("dataType", Kv::Enum("PROP_REF"))])),
    ]);
    ("parameterConsumptionMap", o(vec![("entries", Kv::Array(vec![entry]))]))
}

fn definition(id: u32, name: &str, kind: &'static str, initial: Kv<'static>) -> Kv<'static> {
    o(vec![("id", g(id)), ("name", s(name)), ("type", Kv::Enum(kind)), ("initialValue", initial)])
}

/// An assignment of `def` that leaves `value` empty and says it in `varValue` only.
fn variable_assignment(def: u32, data_type: &'static str, value: Kv<'static>) -> Kv<'static> {
    o(vec![
        ("defID", g(def)),
        ("value", o(vec![])),
        ("varValue", o(vec![("value", value), ("dataType", Kv::Enum(data_type)), ("resolvedDataType", Kv::Enum(data_type))])),
    ])
}

fn message(nodes: Vec<Kv<'static>>) -> Kv<'static> {
    let mut all = vec![node(1, "DOCUMENT", "Document", None, vec![]), node(2, "CANVAS", "Page", Some(1), vec![])];
    all.extend(nodes);
    o(vec![("nodeChanges", Kv::Array(all))])
}

fn by_id<'v>(v: &'v Value, id: &str) -> &'v Value {
    fn find<'v>(v: &'v Value, id: &str) -> Option<&'v Value> {
        if v.get("id").and_then(Value::as_str) == Some(id) {
            return Some(v);
        }
        v.get("children").and_then(Value::as_array).into_iter().flatten().find_map(|v| find(v, id))
    }
    find(v, id).unwrap_or_else(|| panic!("no layer {id}"))
}

fn instance_props(doc: &figcraft_doc::Document) -> &std::collections::BTreeMap<String, Value> {
    let instance = doc.ids().filter_map(|id| doc.node(id)).find(|n| n.name == "Instance").unwrap();
    let NodeKind::Instance { props, .. } = &instance.kind else { panic!("not an instance") };
    props
}

/// A "Field" set with a BOOL definition (9:70), a variant whose "Hint text" reads its copy (9:71),
/// and an instance of the variant that sets the property false through definition `assigned`.
fn field_set(assigned: u32) -> Kv<'static> {
    message(vec![
        node(
            9,
            "FRAME",
            "Field",
            Some(2),
            vec![
                ("isStateGroup", Kv::Bool(true)),
                ("componentPropDefs", Kv::Array(vec![definition(70, "Hint", "BOOL", o(vec![("boolValue", Kv::Bool(true))]))])),
            ],
        ),
        node(
            10,
            "SYMBOL",
            "State=Default",
            Some(9),
            vec![("componentPropDefs", Kv::Array(vec![o(vec![("id", g(71)), ("parentPropDefId", g(70))])]))],
        ),
        node(11, "TEXT", "Hint text", Some(10), vec![bound("VISIBLE", 71)]),
        node(
            20,
            "INSTANCE",
            "Instance",
            Some(2),
            vec![
                ("symbolData", o(vec![("symbolID", g(10))])),
                ("componentPropAssignments", Kv::Array(vec![o(vec![("defID", g(assigned)), ("value", o(vec![("boolValue", Kv::Bool(false))]))])])),
            ],
        ),
    ])
}

#[test]
fn variant_layers_bind_to_the_set_properties_their_copies_name() {
    let msg = field_set(71);
    let (rest, _, _) = to_rest(&msg, "Synthetic", crate::rest::MAX_NODES);
    assert_eq!(by_id(&rest["document"], "9:9")["componentPropertyDefinitions"]["Hint#9:70"]["type"], "BOOLEAN");
    assert_eq!(by_id(&rest["document"], "9:11")["componentPropertyReferences"]["visible"], "Hint#9:70");
    assert_eq!(by_id(&rest["document"], "9:20")["componentProperties"]["Hint#9:70"]["value"], false);

    let (doc, _) = crate::rest::import_fig(&rest, &crate::rest::no_images).unwrap();
    let hint = doc.ids().filter_map(|id| doc.node(id)).find(|n| n.name == "Hint text" && n.source.is_none()).unwrap();
    assert_eq!(hint.prop_refs.get("visible").map(String::as_str), Some("Hint"));
    assert_eq!(instance_props(&doc).get("Hint"), Some(&Value::Bool(false)));
}

/// An assignment reaches layers that read another copy of its definition: here the instance sets
/// the set's own definition while the variant's layer reads the variant's copy.
#[test]
fn assignments_reach_layers_that_read_another_copy_of_their_definition() {
    let (rest, _, _) = to_rest(&field_set(70), "Synthetic", crate::rest::MAX_NODES);
    let instance = by_id(&rest["document"], "9:20");
    assert_eq!(instance["componentProperties"]["Hint#9:70"]["value"], false);
    assert_eq!(by_id(instance, "I9:20;9:11")["visible"], false);
}

#[test]
fn property_values_written_only_as_variables_are_applied() {
    let msg = message(vec![
        node(
            10,
            "SYMBOL",
            "Field",
            Some(2),
            vec![(
                "componentPropDefs",
                Kv::Array(vec![
                    definition(70, "Hint", "BOOL", o(vec![("boolValue", Kv::Bool(true))])),
                    definition(71, "Label", "TEXT", o(vec![("textValue", o(vec![("characters", s("Label"))]))])),
                    definition(72, "Icon", "INSTANCE_SWAP", o(vec![("guidValue", g(40))])),
                ]),
            )],
        ),
        node(11, "TEXT", "Hint text", Some(10), vec![bound("VISIBLE", 70)]),
        node(12, "TEXT", "Label", Some(10), vec![("textData", o(vec![("characters", s("Label"))])), bound("TEXT_DATA", 71)]),
        node(13, "INSTANCE", "Icon", Some(10), vec![("symbolData", o(vec![("symbolID", g(40))])), bound("OVERRIDDEN_SYMBOL_ID", 72)]),
        node(40, "SYMBOL", "Mail", Some(2), vec![]),
        node(41, "SYMBOL", "Card", Some(2), vec![]),
        node(
            20,
            "INSTANCE",
            "Instance",
            Some(2),
            vec![
                ("symbolData", o(vec![("symbolID", g(10))])),
                (
                    "componentPropAssignments",
                    Kv::Array(vec![
                        variable_assignment(70, "BOOLEAN", o(vec![("boolValue", Kv::Bool(false))])),
                        variable_assignment(71, "TEXT_DATA", o(vec![("textDataValue", o(vec![("characters", s("Name on card"))]))])),
                        variable_assignment(72, "SYMBOL_ID", o(vec![("symbolIdValue", o(vec![("guid", g(41))]))])),
                    ]),
                ),
            ],
        ),
    ]);
    let (rest, _, _) = to_rest(&msg, "Synthetic", crate::rest::MAX_NODES);
    let instance = by_id(&rest["document"], "9:20");
    assert_eq!(instance["componentProperties"]["Hint#9:70"]["value"], false);
    assert_eq!(instance["componentProperties"]["Label#9:71"]["value"], "Name on card");
    assert_eq!(instance["componentProperties"]["Icon#9:72"]["value"], "9:41");
    assert_eq!(by_id(instance, "I9:20;9:11")["visible"], false);
    assert_eq!(by_id(instance, "I9:20;9:12")["characters"], "Name on card");
    assert_eq!(by_id(instance, "I9:20;9:13")["componentId"], "9:41");

    let (doc, _) = crate::rest::import_fig(&rest, &crate::rest::no_images).unwrap();
    let props = instance_props(&doc);
    assert_eq!(props.get("Hint"), Some(&Value::Bool(false)));
    assert_eq!(props.get("Label"), Some(&Value::String("Name on card".into())));
}

/// #2022: a set keeps each named text definition under its own name (Figma writes one per variant,
/// plus leftovers of deleted variants), and each variant's text reads its own copy.
#[test]
fn a_set_keeps_each_named_text_definition_and_layers_read_their_own() {
    let text = |chars: &str| o(vec![("textValue", o(vec![("characters", s(chars))]))]);
    let names = ["Type=Flag /  State=Default label", "Type=Flag /  State=Selected label", "Type=Issue /  State=Default label"];
    let set_defs: Vec<Kv<'static>> =
        names.iter().zip([70, 71, 72]).zip(["One", "Two", "Gone"]).map(|((n, id), c)| definition(id, n, "TEXT", text(c))).collect();
    let copies = |first: u32| Kv::Array((0..3).map(|k| o(vec![("id", g(first + k)), ("parentPropDefId", g(70 + k))])).collect());
    let msg = message(vec![
        node(9, "FRAME", "Chip", Some(2), vec![("isStateGroup", Kv::Bool(true)), ("componentPropDefs", Kv::Array(set_defs))]),
        node(10, "SYMBOL", "Type=Flag, State=Default", Some(9), vec![("componentPropDefs", copies(80))]),
        node(11, "TEXT", "Label", Some(10), vec![bound("TEXT_DATA", 80)]),
        node(20, "SYMBOL", "Type=Flag, State=Selected", Some(9), vec![("componentPropDefs", copies(90))]),
        node(21, "TEXT", "Label", Some(20), vec![bound("TEXT_DATA", 91)]),
    ]);
    let (rest, _, _) = to_rest(&msg, "Synthetic", crate::rest::MAX_NODES);
    let defs = &by_id(&rest["document"], "9:9")["componentPropertyDefinitions"];
    for (k, n) in names.iter().enumerate() {
        assert_eq!(defs[format!("{n}#9:{}", 70 + k)]["type"], "TEXT", "{n}");
    }
    assert_eq!(defs.as_object().map(|d| d.len()), Some(3), "{defs}");
    assert_eq!(by_id(&rest["document"], "9:11")["componentPropertyReferences"]["characters"], format!("{}#9:70", names[0]));
    assert_eq!(by_id(&rest["document"], "9:21")["componentPropertyReferences"]["characters"], format!("{}#9:71", names[1]));

    let (doc, _) = crate::rest::import_fig(&rest, &crate::rest::no_images).unwrap();
    let refs: Vec<Option<String>> = doc
        .ids()
        .filter_map(|id| doc.node(id))
        .filter(|n| n.name == "Label" && n.source.is_none())
        .map(|n| n.prop_refs.get("characters").cloned())
        .collect();
    assert_eq!(refs.len(), 2, "{refs:?}");
    assert!(refs.contains(&Some(names[0].to_string())) && refs.contains(&Some(names[1].to_string())), "{refs:?}");
    for set in doc.ids().filter_map(|id| doc.node(id)).filter(|n| matches!(n.kind, NodeKind::Component { .. })) {
        let NodeKind::Component { props, .. } = &set.kind else { continue };
        assert!(names.iter().all(|n| props.contains_key(*n)), "{} holds {:?}", set.name, props.keys().collect::<Vec<_>>());
    }
}