elicit_ui 0.11.1

Typestate-based verified UI system using AccessKit as universal IR
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
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

//! Validation functions that establish proofs for UI accessibility propositions.
//!
//! These functions delegate to the [`Constraint`](crate::constraints::Constraint) trait
//! implementations in [`constraints::wcag`](crate::constraints::wcag), preserving backward
//! compatibility with the existing API.

use crate::constraints::{
    Constraint, ConstraintContext, HasLabelConstraint, KeyboardAccessibleConstraint,
    MinTouchTargetConstraint, NoOverflowConstraint, ValidRoleConstraint,
};
use crate::{VerificationError, Viewport};
use accesskit::NodeId;
use std::collections::BTreeMap;

/// Convert a constraint [`Violation`](crate::constraints::Violation) to a legacy
/// [`VerificationError`].
fn violation_to_error(v: crate::constraints::Violation) -> VerificationError {
    match v {
        crate::constraints::Violation::MissingLabel { element } => {
            VerificationError::missing_label(element)
        }
        crate::constraints::Violation::EmptyLabel { element } => {
            VerificationError::empty_label(element)
        }
        crate::constraints::Violation::TouchTarget {
            element,
            actual_width,
            actual_height,
            ..
        } => VerificationError::below_min_target_size(element, actual_width, actual_height),
        crate::constraints::Violation::Overflow {
            element,
            element_x,
            element_y,
            element_width,
            element_height,
            viewport_width,
            viewport_height,
        } => VerificationError::overflows_viewport(
            element,
            element_x,
            element_y,
            element_width,
            element_height,
            viewport_width,
            viewport_height,
        ),
        // Other violation types don't have legacy equivalents
        _ => VerificationError::tree_error("constraint violation"),
    }
}

/// Validate that an element has a non-empty accessible label.
///
/// Delegates to [`HasLabelConstraint`].
pub fn validate_has_label(
    nodes: &BTreeMap<NodeId, accesskit::Node>,
    node_id: NodeId,
) -> Result<(), VerificationError> {
    let ctx = ConstraintContext {
        nodes,
        viewport: Viewport::new(0, 0),
    };
    HasLabelConstraint
        .check(node_id, &ctx)
        .map_err(violation_to_error)
}

/// Validate that an element has a valid ARIA role.
///
/// Delegates to [`ValidRoleConstraint`].
pub fn validate_valid_role(
    nodes: &BTreeMap<NodeId, accesskit::Node>,
    node_id: NodeId,
) -> Result<(), VerificationError> {
    let ctx = ConstraintContext {
        nodes,
        viewport: Viewport::new(0, 0),
    };
    ValidRoleConstraint
        .check(node_id, &ctx)
        .map_err(violation_to_error)
}

/// Validate that an interactive element meets minimum touch target size (44x44).
///
/// Delegates to [`MinTouchTargetConstraint`].
pub fn validate_min_target_size(
    nodes: &BTreeMap<NodeId, accesskit::Node>,
    node_id: NodeId,
) -> Result<(), VerificationError> {
    let ctx = ConstraintContext {
        nodes,
        viewport: Viewport::new(0, 0),
    };
    MinTouchTargetConstraint
        .check(node_id, &ctx)
        .map_err(violation_to_error)
}

/// Validate that an element fits within viewport boundaries.
///
/// Delegates to [`NoOverflowConstraint`].
pub fn validate_no_overflow(
    nodes: &BTreeMap<NodeId, accesskit::Node>,
    node_id: NodeId,
    viewport: Viewport,
) -> Result<(), VerificationError> {
    let ctx = ConstraintContext { nodes, viewport };
    NoOverflowConstraint
        .check(node_id, &ctx)
        .map_err(violation_to_error)
}

/// Validate that an element is keyboard accessible.
///
/// Delegates to [`KeyboardAccessibleConstraint`].
pub fn validate_keyboard_accessible(
    nodes: &BTreeMap<NodeId, accesskit::Node>,
    node_id: NodeId,
) -> Result<(), VerificationError> {
    let ctx = ConstraintContext {
        nodes,
        viewport: Viewport::new(0, 0),
    };
    KeyboardAccessibleConstraint
        .check(node_id, &ctx)
        .map_err(violation_to_error)
}