adaptive-card-core 0.1.0

Pure-Rust library for validating, optimizing, and transforming Microsoft Adaptive Cards v1.6
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86

//! Card optimizations: accessibility, performance, and modernization.

pub mod accessibility;
pub mod modernize;
pub mod performance;

use crate::host::adapt::adapt_for_host;
use crate::types::{OptimizeOpts, TransformReport};
use serde_json::Value;

/// Apply optimizations selectively based on [`OptimizeOpts`] flags.
#[must_use]
pub fn optimize_card(mut card: Value, opts: &OptimizeOpts) -> TransformReport {
    let mut removed: Vec<String> = Vec::new();
    let mut downgraded: Vec<String> = Vec::new();
    let mut warnings: Vec<String> = Vec::new();

    if opts.accessibility {
        downgraded.extend(accessibility::fix(&mut card));
    }

    if opts.performance {
        downgraded.extend(performance::fix(&mut card));
    }

    if opts.modernize {
        downgraded.extend(modernize::fix(&mut card, opts.target_host));
    }

    if let Some(host) = opts.target_host {
        let report = adapt_for_host(card, host);
        card = report.card;
        removed.extend(report.removed);
        downgraded.extend(report.downgraded);
        warnings.extend(report.warnings);
    }

    TransformReport {
        card,
        removed,
        downgraded,
        warnings,
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use serde_json::json;

    #[test]
    fn accessibility_optimization_adds_speak() {
        let card = json!({
            "type": "AdaptiveCard", "version": "1.6",
            "body": [{ "type": "TextBlock", "text": "Hi" }]
        });
        let report = optimize_card(
            card,
            &OptimizeOpts {
                accessibility: true,
                ..Default::default()
            },
        );
        assert!(report.card.get("speak").is_some());
    }

    #[test]
    fn performance_flattens_and_dedupes() {
        let card = json!({
            "type": "AdaptiveCard", "version": "1.6",
            "body": [
                { "type": "Container", "items": [{ "type": "TextBlock", "text": "A", "id": "t1" }] },
                { "type": "TextBlock", "text": "B", "id": "t1" }
            ]
        });
        let report = optimize_card(
            card,
            &OptimizeOpts {
                performance: true,
                ..Default::default()
            },
        );
        // Flattened: first child is now TextBlock directly
        assert_eq!(report.card["body"][0]["type"], "TextBlock");
    }
}