Skip to content

armgit / macro

Public Imported from GitHub
0

Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.

18.6 KB
Raw Blame
//! Writing what design systems are made of: component property values,
//! definitions, and bindings; variants; and shared style references.
//!
//! Lists Figma keeps more in than the engine models (definitions' sort
//! positions, bindings to fields the engine does not drive, deleted
//! entries) are patched entry by entry, so those survive.

use super::Build;
use crate::edit::flags;
use crate::kiwi::{Msg, Value};
use crate::model::{Guid, PropAssignment, PropDef, PropField, PropRef, PropValue, Props};

/// The messages of a list field.
fn msgs(b: &Build, m: &Msg, field: &str) -> Vec<Msg> {
    match m.get(b.schema, field) {
        Some(Value::List(l)) => l
            .iter()
            .filter_map(|v| match v {
                Value::Msg(m) => Some((**m).clone()),
                _ => None,
            })
            .collect(),
        _ => Vec::new(),
    }
}

fn set_msgs(b: &Build, m: &mut Msg, field: &str, list: Vec<Msg>) {
    if list.is_empty() {
        m.remove(b.schema, field);
    } else {
        m.set(
            b.schema,
            field,
            Value::List(list.into_iter().map(|e| Value::Msg(Box::new(e))).collect()),
        );
    }
}

fn read_guid(b: &Build, m: &Msg, field: &str) -> Option<Guid> {
    let Some(Value::Msg(g)) = m.get(b.schema, field) else {
        return None;
    };
    let n = |f| match g.get(b.schema, f) {
        Some(Value::Uint(v)) => *v,
        _ => 0,
    };
    Some(Guid {
        session: n("sessionID"),
        local: n("localID"),
    })
}

fn read_str<'m>(b: &Build, m: &'m Msg, field: &str) -> Option<&'m str> {
    match m.get(b.schema, field) {
        Some(Value::Str(s)) => Some(s),
        _ => None,
    }
}

fn read_enum<'s>(b: &'s Build, m: &Msg, field: &str) -> Option<&'s str> {
    match m.get(b.schema, field) {
        Some(Value::Enum(def, v)) => b.schema.enum_name(*def, *v),
        _ => None,
    }
}

fn read_bool(b: &Build, m: &Msg, field: &str) -> Option<bool> {
    match m.get(b.schema, field) {
        Some(Value::Bool(v)) => Some(*v),
        _ => None,
    }
}

fn field_name(f: PropField) -> Option<&'static str> {
    match f {
        PropField::Visible => Some("VISIBLE"),
        PropField::Text => Some("TEXT_DATA"),
        PropField::SwappedSymbol => Some("OVERRIDDEN_SYMBOL_ID"),
        PropField::Other => None,
    }
}

impl Build<'_> {
    /// A text value: just the characters (Figma lays the lines out again).
    fn text_value(&self, def: u32, existing: Option<&Msg>, text: &str) -> Msg {
        let s = self.schema;
        let mut t = existing.cloned().unwrap_or_else(|| Msg::new(def));
        t.set(s, "characters", Value::Str(text.into()));
        for f in ["characterStyleIDs", "styleOverrideTable", "lines"] {
            t.remove(s, f);
        }
        t
    }

    /// Sets `value` in the `ComponentPropValue` field `field` of `m`,
    /// keeping that message's other fields.
    fn prop_value(&self, m: &mut Msg, field: &str, value: &PropValue) {
        let s = self.schema;
        let Some(vdef) = self.sub(m.def, field) else {
            return;
        };
        let mut v = match m.get(s, field) {
            Some(Value::Msg(v)) => (**v).clone(),
            _ => Msg::new(vdef),
        };
        match value {
            PropValue::Bool(on) => {
                v.remove(s, "textValue");
                v.remove(s, "guidValue");
                v.set(s, "boolValue", Value::Bool(*on));
            }
            PropValue::Text(text) => {
                v.remove(s, "boolValue");
                v.remove(s, "guidValue");
                if let Some(tdef) = self.sub(vdef, "textValue") {
                    let existing = match v.get(s, "textValue") {
                        Some(Value::Msg(t)) => Some((**t).clone()),
                        _ => None,
                    };
                    let t = self.text_value(tdef, existing.as_ref(), text);
                    v.set(s, "textValue", Value::Msg(Box::new(t)));
                }
            }
            PropValue::Symbol(g) => {
                v.remove(s, "boolValue");
                v.remove(s, "textValue");
                self.guid_field(&mut v, "guidValue", *g);
            }
            PropValue::Other => return,
        }
        m.set(s, field, Value::Msg(Box::new(v)));
    }

    /// Newer files carry each value a second time as variable data
    /// (`varValue`); it is written to match, or dropped when this schema
    /// cannot express it.
    fn var_value(&self, m: &mut Msg, value: &PropValue) {
        let s = self.schema;
        let Some(def) = self.sub(m.def, "varValue") else {
            return;
        };
        let built = (|| {
            let mut data = Msg::new(def);
            let any_def = self.sub(def, "value")?;
            let mut any = Msg::new(any_def);
            let kind = match value {
                PropValue::Bool(on) => {
                    any.set(s, "boolValue", Value::Bool(*on));
                    "BOOLEAN"
                }
                PropValue::Text(text) => {
                    let tdef = self.sub(any_def, "textDataValue")?;
                    let t = self.text_value(tdef, None, text);
                    any.set(s, "textDataValue", Value::Msg(Box::new(t)));
                    "TEXT_DATA"
                }
                PropValue::Symbol(g) => {
                    let sdef = self.sub(any_def, "symbolIdValue")?;
                    let mut sym = Msg::new(sdef);
                    self.guid_field(&mut sym, "guid", *g);
                    any.set(s, "symbolIdValue", Value::Msg(Box::new(sym)));
                    "SYMBOL_ID"
                }
                PropValue::Other => return None,
            };
            data.set(s, "value", Value::Msg(Box::new(any)));
            let dt = self.enum_of(def, "dataType", kind)?;
            let rt = self.enum_of(def, "resolvedDataType", kind)?;
            data.set(s, "dataType", dt);
            data.set(s, "resolvedDataType", rt);
            Some(data)
        })();
        match built {
            Some(data) => {
                m.set(s, "varValue", Value::Msg(Box::new(data)));
            }
            None => m.remove(s, "varValue"),
        }
    }

    /// Writes an instance's component property values: each one the file
    /// has is updated in place; values no longer assigned are dropped.
    pub(super) fn prop_assignments(&self, m: &mut Msg, list: &[PropAssignment]) {
        let Some(def) = self.sub(m.def, "componentPropAssignments") else {
            return;
        };
        let existing = msgs(self, m, "componentPropAssignments");
        let mut out = Vec::with_capacity(list.len());
        for a in list {
            let found = existing
                .iter()
                .find(|e| read_guid(self, e, "defID") == Some(a.def_id))
                .cloned();
            if matches!(a.value, PropValue::Other) {
                // A kind of value the engine does not model: as it was.
                out.extend(found);
                continue;
            }
            let mut e = found.unwrap_or_else(|| {
                let mut e = Msg::new(def);
                self.guid_field(&mut e, "defID", a.def_id);
                e
            });
            self.prop_value(&mut e, "value", &a.value);
            self.var_value(&mut e, &a.value);
            out.push(e);
        }
        set_msgs(self, m, "componentPropAssignments", out);
    }

    /// A component's (or set's) property definitions, by id: existing
    /// entries keep their other fields; removed ones are marked deleted.
    fn prop_defs(&self, m: &mut Msg, defs: &[PropDef]) {
        let s = self.schema;
        let Some(def) = self.sub(m.def, "componentPropDefs") else {
            return;
        };
        let existing = msgs(self, m, "componentPropDefs");
        let mut last_sort = existing
            .iter()
            .filter_map(|e| read_str(self, e, "sortPosition"))
            .max()
            .unwrap_or("")
            .to_owned();
        let mut out = Vec::with_capacity(existing.len().max(defs.len()));
        for d in defs {
            let mut e = match existing
                .iter()
                .find(|e| read_guid(self, e, "id") == Some(d.id))
            {
                Some(e) => e.clone(),
                None => {
                    let mut e = Msg::new(def);
                    self.guid_field(&mut e, "id", d.id);
                    let sort = crate::edit::between(&last_sort, None)
                        .unwrap_or_else(|| format!("{last_sort}O"));
                    e.set(s, "sortPosition", Value::Str(sort.as_str().into()));
                    last_sort = sort;
                    e
                }
            };
            e.set(s, "name", Value::Str(d.name.as_str().into()));
            self.set_enum(&mut e, "type", &d.kind);
            e.remove(s, "isDeleted");
            if let Some(initial) = d.initial.as_ref().filter(|v| **v != PropValue::Other) {
                self.prop_value(&mut e, "initialValue", initial);
                self.var_value(&mut e, initial);
            }
            self.preferred_values(&mut e, d);
            out.push(e);
        }
        // Definitions removed here, and deleted ones the file keeps.
        for mut e in existing {
            let id = read_guid(self, &e, "id");
            if defs.iter().any(|d| Some(d.id) == id) {
                continue;
            }
            e.set(s, "isDeleted", Value::Bool(true));
            out.push(e);
        }
        set_msgs(self, m, "componentPropDefs", out);
    }

    fn preferred_values(&self, e: &mut Msg, d: &PropDef) {
        let s = self.schema;
        let Some(pdef) = self.sub(e.def, "preferredValues") else {
            return;
        };
        let mut pv = match e.get(s, "preferredValues") {
            Some(Value::Msg(p)) => (**p).clone(),
            _ => Msg::new(pdef),
        };
        let current = msgs(self, &pv, "instanceSwapValues");
        let keys: Vec<&str> = current
            .iter()
            .filter_map(|v| read_str(self, v, "key"))
            .collect();
        if keys.len() == d.preferred.len()
            && keys.iter().zip(d.preferred.iter()).all(|(a, b)| *a == &**b)
        {
            return;
        }
        let Some(vdef) = self.sub(pdef, "instanceSwapValues") else {
            return;
        };
        let list = d
            .preferred
            .iter()
            .map(|k| {
                current
                    .iter()
                    .find(|v| read_str(self, v, "key") == Some(k))
                    .cloned()
                    .unwrap_or_else(|| {
                        let mut v = Msg::new(vdef);
                        self.set_enum(&mut v, "type", "COMPONENT");
                        v.set(s, "key", Value::Str(k.as_ref().into()));
                        v
                    })
            })
            .collect();
        set_msgs(self, &mut pv, "instanceSwapValues", list);
        e.set(s, "preferredValues", Value::Msg(Box::new(pv)));
    }

    /// A layer's bindings to its component's properties. Bindings of fields
    /// the engine does not drive, and deleted ones, stay as they were.
    fn prop_refs(&self, m: &mut Msg, refs: &[PropRef]) {
        let Some(def) = self.sub(m.def, "componentPropRefs") else {
            return;
        };
        let existing = msgs(self, m, "componentPropRefs");
        let modeled = |e: &Msg| {
            read_bool(self, e, "isDeleted") != Some(true)
                && matches!(
                    read_enum(self, e, "componentPropNodeField"),
                    Some("VISIBLE" | "TEXT_DATA" | "OVERRIDDEN_SYMBOL_ID")
                )
        };
        let mut out: Vec<Msg> = existing.iter().filter(|e| !modeled(e)).cloned().collect();
        for r in refs {
            let Some(field) = field_name(r.field) else {
                continue;
            };
            let e = existing
                .iter()
                .find(|e| {
                    modeled(e)
                        && read_guid(self, e, "defID") == Some(r.def_id)
                        && read_enum(self, e, "componentPropNodeField") == Some(field)
                })
                .cloned()
                .unwrap_or_else(|| {
                    let mut e = Msg::new(def);
                    self.guid_field(&mut e, "defID", r.def_id);
                    self.set_enum(&mut e, "componentPropNodeField", field);
                    e
                });
            out.push(e);
        }
        set_msgs(self, m, "componentPropRefs", out);
    }

    /// [`flags::COMPONENT`]: the component and variant fields `p` sets.
    pub(super) fn component_fields(&self, m: &mut Msg, p: &Props, edits: u64) {
        let s = self.schema;
        if let Some(defs) = p.prop_defs.as_deref() {
            self.prop_defs(m, defs);
        }
        if let Some(refs) = p.prop_refs.as_deref() {
            self.prop_refs(m, refs);
        }
        if let Some(specs) = p.variant_specs.as_deref()
            && let Some(def) = self.sub(m.def, "variantPropSpecs")
        {
            let list = specs
                .iter()
                .map(|v| {
                    let mut e = Msg::new(def);
                    self.guid_field(&mut e, "propDefId", v.def_id);
                    e.set(s, "value", Value::Str(v.value.as_ref().into()));
                    e
                })
                .collect();
            set_msgs(self, m, "variantPropSpecs", list);
        }
        if let Some(orders) = p.variant_orders.as_deref()
            && let Some(def) = self.sub(m.def, "stateGroupPropertyValueOrders")
        {
            let list = orders
                .iter()
                .map(|o| {
                    let mut e = Msg::new(def);
                    e.set(s, "property", Value::Str(o.property.as_ref().into()));
                    e.set(
                        s,
                        "values",
                        Value::List(
                            o.values
                                .iter()
                                .map(|v| Value::Str(v.as_ref().into()))
                                .collect(),
                        ),
                    );
                    e
                })
                .collect();
            set_msgs(self, m, "stateGroupPropertyValueOrders", list);
        }
        if let Some(v) = p.is_state_group {
            m.set(s, "isStateGroup", Value::Bool(v));
        }
        if let Some(v) = p.props_bubbled {
            m.set(s, "propsAreBubbled", Value::Bool(v));
        }
        match p.swapped_symbol {
            Some(g) => self.guid_field(m, "overriddenSymbolID", g),
            // An instance swapped to another component shows it directly.
            None if edits & flags::INSTANCE_OF != 0 => m.remove(s, "overriddenSymbolID"),
            None => {}
        }
    }

    /// A paint's color variable (`colorVar`: an alias to the variable).
    pub(super) fn color_var(&self, paint: &mut Msg, var: Guid) {
        let s = self.schema;
        let Some(def) = self.sub(paint.def, "colorVar") else {
            return;
        };
        let built = (|| {
            let mut data = Msg::new(def);
            let any_def = self.sub(def, "value")?;
            let mut any = Msg::new(any_def);
            let alias_def = self.sub(any_def, "alias")?;
            let mut alias = Msg::new(alias_def);
            self.guid_field(&mut alias, "guid", var);
            any.set(s, "alias", Value::Msg(Box::new(alias)));
            data.set(s, "value", Value::Msg(Box::new(any)));
            data.set(s, "dataType", self.enum_of(def, "dataType", "ALIAS")?);
            data.set(
                s,
                "resolvedDataType",
                self.enum_of(def, "resolvedDataType", "COLOR")?,
            );
            Some(data)
        })();
        if let Some(data) = built {
            paint.set(s, "colorVar", Value::Msg(Box::new(data)));
        }
    }

    /// The modes a frame picks per variable collection.
    fn mode_by_set(&self, m: &mut Msg, modes: &[(Guid, Guid)]) {
        let s = self.schema;
        let Some(def) = self.sub(m.def, "variableModeBySetMap") else {
            return;
        };
        let Some(entry_def) = self.sub(def, "entries") else {
            return;
        };
        let entries = modes
            .iter()
            .map(|&(set, mode)| {
                let mut e = Msg::new(entry_def);
                if let Some(set_def) = self.sub(entry_def, "variableSetID") {
                    let mut id = Msg::new(set_def);
                    self.guid_field(&mut id, "guid", set);
                    e.set(s, "variableSetID", Value::Msg(Box::new(id)));
                }
                self.guid_field(&mut e, "variableModeID", mode);
                Value::Msg(Box::new(e))
            })
            .collect();
        let mut map = Msg::new(def);
        map.set(s, "entries", Value::List(entries));
        m.set(s, "variableModeBySetMap", Value::Msg(Box::new(map)));
    }

    /// [`flags::STYLES`]: the shared styles `p` uses, and a style node's
    /// own details. Overrides (`guid_path` set) only add references; a
    /// layer's own record drops the ones it no longer uses.
    pub(super) fn style_fields(&self, m: &mut Msg, p: &Props) {
        let s = self.schema;
        let own = p.guid_path.is_none();
        for (field, legacy, value) in [
            ("styleIdForFill", "inheritFillStyleID", p.fill_style),
            (
                "styleIdForStrokeFill",
                "inheritFillStyleIDForStroke",
                p.stroke_style,
            ),
            ("styleIdForEffect", "inheritEffectStyleID", p.effect_style),
            ("styleIdForText", "inheritTextStyleID", p.text_style_id),
        ] {
            match value {
                Some(g) => {
                    if let Some(def) = self.sub(m.def, field) {
                        let mut id = Msg::new(def);
                        self.guid_field(&mut id, "guid", g);
                        m.set(s, field, Value::Msg(Box::new(id)));
                        m.remove(s, legacy);
                    } else {
                        self.guid_field(m, legacy, g);
                    }
                }
                None if own => {
                    m.remove(s, field);
                    m.remove(s, legacy);
                }
                None => {}
            }
        }
        if let Some(t) = p.style_type {
            self.set_enum(m, "styleType", t.name());
        }
        if let Some(sort) = &p.sort_position {
            m.set(s, "sortPosition", Value::Str(sort.as_ref().into()));
        }
        if let Some(v) = p.soft_deleted {
            m.set(s, "isSoftDeleted", Value::Bool(v));
        }
        if let Some(v) = p.internal_only {
            m.set(s, "internalOnly", Value::Bool(v));
        }
        if let Some(modes) = p.mode_by_set.as_deref() {
            self.mode_by_set(m, modes);
        }
    }
}