Struct Panel 

pub struct Panel {
    pub id: String,
    pub kind: PanelKind,
    pub namespace: String,
    pub props: Props,
    pub rows: Vec<Vec<Value>>,
    pub source: Option<PanelSource>,
    pub fields: Vec<Field>,
    pub children: Vec<Panel>,
    pub published: bool,
}

A resolved panel: definition facts plus whatever rows were loaded for it.

Fields

id: String

kind: PanelKind

namespace: String

props: Props

panel_prop(Id, Key, Value) pairs, values as sent.

rows: Vec<Vec<Value>>

Rows: either the live panel_source result or the panel_data snapshot. Resolution happens outside this crate — see PanelSource.

source: Option<PanelSource>

fields: Vec<Field>

Form fields — parts of a form panel.

children: Vec<Panel>

Child panels — parts of a dashboard (or any non-form container).

published: bool

Whether the publisher marked this panel published.

Matches the server: published must be true (or "true"); an absent prop means not published.

Implementations

impl Panel

pub fn all_from_facts(facts: &PanelFacts) -> Vec<Panel>

Build every panel present in facts.

Parts (form fields, dashboard children) are folded into their container and removed from the top-level result, so callers get panels, not panels-and-their-parts.

Examples found in repository

examples/parse_fixture.rs (line 54)

fn main() {
    let path = std::env::args()
        .nth(1)
        .expect("usage: parse_fixture <facts.json>");
    let raw = std::fs::read_to_string(&path).expect("read fixture");
    let doc: BTreeMap<String, Value> =
        serde_json::from_str(&raw).expect("fixture is a JSON object");

    let rows = |key: &str| -> Vec<Value> {
        doc.get(key)
            .and_then(Value::as_array)
            .cloned()
            .unwrap_or_default()
    };

    let facts = PanelFacts {
        panels: rows("panels"),
        props: rows("props"),
        data: rows("data"),
        sources: rows("sources"),
        field_inputs: rows("field_inputs"),
        field_triggers: rows("field_triggers"),
        field_emits: rows("field_emits"),
    };

    println!(
        "input rows: panels={} props={} data={} sources={} fields(in/trig/emit)={}/{}/{}",
        facts.panels.len(),
        facts.props.len(),
        facts.data.len(),
        facts.sources.len(),
        facts.field_inputs.len(),
        facts.field_triggers.len(),
        facts.field_emits.len()
    );

    let panels = Panel::all_from_facts(&facts);
    println!("parsed panels: {}\n", panels.len());

    let mut unknown = 0;
    for p in &panels {
        let kind = p.kind.as_str().to_string();
        if matches!(p.kind, datagrout_panels::PanelKind::Unknown(_)) {
            unknown += 1;
        }
        println!(
            "{:<24} {:<11} ns={:<20} props={:<2} rows={:<3} cols={:<2} source={} fields={} children={} published={}",
            p.id,
            kind,
            p.namespace,
            p.props.len(),
            p.rows.len(),
            p.rows.first().map(Vec::len).unwrap_or(0),
            p.source.is_some(),
            p.fields.len(),
            p.children.len(),
            p.published
        );
        for c in &p.children {
            println!(
                "    └ {:<20} {:<11} rows={:<3} columns={:?}",
                c.id,
                c.kind.as_str(),
                c.rows.len(),
                c.columns()
            );
        }
    }

    // Anything a renderer would fall back on is worth calling out by name.
    println!("\nunknown kinds: {unknown}");
    let titled = panels
        .iter()
        .filter(|p| p.props.contains_key("title"))
        .count();
    println!("panels with a title prop: {titled}/{}", panels.len());
}

pub fn from_facts(facts: &PanelFacts, id: &str) -> Option<Panel>

Build a single panel by id, or None if it is absent.

pub fn all_from_list(response: &Value) -> Vec<Panel>

Build every panel from a smart_panel.list response.

Accepts either the whole response ({"panels": [...]}) or the bare array. Each entry carries id, kind, namespace, props, and optionally data_preview, source_info and field_ids.

Rows are a preview. data_preview holds at most the first few rows; a renderer that needs the full set still reads panel_data or runs the live source. Field-level metadata (field_input / field_trigger / field_emit) is not part of the list output and comes back empty.

impl Panel

pub fn title(&self) -> String

pub fn description(&self) -> Option<String>

pub fn slot(&self) -> String

Layout slot hint. The server defaults this to "main".

pub fn parent(&self) -> Option<String>

The container this panel is a part of, if any.

pub fn columns(&self) -> Vec<String>

Column headers for table panels — the columns prop, a list.

Examples found in repository

examples/parse_fixture.rs (line 82)

fn main() {
    let path = std::env::args()
        .nth(1)
        .expect("usage: parse_fixture <facts.json>");
    let raw = std::fs::read_to_string(&path).expect("read fixture");
    let doc: BTreeMap<String, Value> =
        serde_json::from_str(&raw).expect("fixture is a JSON object");

    let rows = |key: &str| -> Vec<Value> {
        doc.get(key)
            .and_then(Value::as_array)
            .cloned()
            .unwrap_or_default()
    };

    let facts = PanelFacts {
        panels: rows("panels"),
        props: rows("props"),
        data: rows("data"),
        sources: rows("sources"),
        field_inputs: rows("field_inputs"),
        field_triggers: rows("field_triggers"),
        field_emits: rows("field_emits"),
    };

    println!(
        "input rows: panels={} props={} data={} sources={} fields(in/trig/emit)={}/{}/{}",
        facts.panels.len(),
        facts.props.len(),
        facts.data.len(),
        facts.sources.len(),
        facts.field_inputs.len(),
        facts.field_triggers.len(),
        facts.field_emits.len()
    );

    let panels = Panel::all_from_facts(&facts);
    println!("parsed panels: {}\n", panels.len());

    let mut unknown = 0;
    for p in &panels {
        let kind = p.kind.as_str().to_string();
        if matches!(p.kind, datagrout_panels::PanelKind::Unknown(_)) {
            unknown += 1;
        }
        println!(
            "{:<24} {:<11} ns={:<20} props={:<2} rows={:<3} cols={:<2} source={} fields={} children={} published={}",
            p.id,
            kind,
            p.namespace,
            p.props.len(),
            p.rows.len(),
            p.rows.first().map(Vec::len).unwrap_or(0),
            p.source.is_some(),
            p.fields.len(),
            p.children.len(),
            p.published
        );
        for c in &p.children {
            println!(
                "    └ {:<20} {:<11} rows={:<3} columns={:?}",
                c.id,
                c.kind.as_str(),
                c.rows.len(),
                c.columns()
            );
        }
    }

    // Anything a renderer would fall back on is worth calling out by name.
    println!("\nunknown kinds: {unknown}");
    let titled = panels
        .iter()
        .filter(|p| p.props.contains_key("title"))
        .count();
    println!("panels with a title prop: {titled}/{}", panels.len());
}

pub fn prop_str(&self, key: &str) -> Option<String>

Read a prop as text. See prop_str.

pub fn prop_list(&self, key: &str) -> Vec<String>

Read a prop as a list. See prop_list.

pub fn prop_bool(&self, key: &str) -> Option<bool>

Read a prop as a boolean. See prop_bool.

pub fn prop_f64(&self, key: &str) -> Option<f64>

Read a prop as a number. See prop_f64.

Trait Implementations

impl Clone for Panel

fn clone(&self) -> Panel

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Panel

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Panel

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Panel

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.