bnto-core 0.2.0

Core WASM engine library for Bnto — shared types, traits, and orchestration
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
130

// Parameters for the `input` node: how data enters a recipe.

use super::helpers::{enum_of, min, param, visible_when, visible_when_any};
use crate::metadata::{ParamCondition, ParameterDef, ParameterType};

/// Canonical file extensions offered by the input extension picker.
const EXTENSIONS: [&str; 15] = [
    ".jpg", ".jpeg", ".png", ".webp", ".gif", ".svg", ".csv", ".json", ".txt", ".pdf", ".xml",
    ".zip", ".mp3", ".mp4", ".wav",
];

/// Parameters for the `input` node, in schema order.
pub(super) fn input_params() -> Vec<ParameterDef> {
    vec![
        mode(),
        accept(),
        extensions(),
        label(),
        multiple(),
        max_file_size(),
        max_files(),
        placeholder(),
    ]
}

fn when_file_upload() -> Option<ParamCondition> {
    Some(visible_when("mode", "file-upload"))
}

fn mode() -> ParameterDef {
    let modes = [
        ("file-upload", "File Upload"),
        ("text", "Text"),
        ("url", "URL"),
        ("none", "No Input"),
    ];
    let description = "How data is provided to the recipe.";
    ParameterDef {
        default: Some(serde_json::json!("file-upload")),
        control: Some("select".to_string()),
        ..param("mode", "Mode", description, enum_of(&modes))
    }
}

fn accept() -> ParameterDef {
    let description =
        "MIME types accepted (e.g., \"image/jpeg\", \"image/png\"). Derived from extensions.";
    ParameterDef {
        control: Some("tagPicker".to_string()),
        visible_when: when_file_upload(),
        ..param(
            "accept",
            "Accepted MIME Types",
            description,
            ParameterType::String,
        )
    }
}

fn extensions() -> ParameterDef {
    let options: Vec<(&str, &str)> = EXTENSIONS.iter().map(|e| (*e, *e)).collect();
    let description = "File extensions accepted (e.g., \".jpg\", \".png\").";
    ParameterDef {
        control: Some("tagPicker".to_string()),
        visible_when: when_file_upload(),
        ..param(
            "extensions",
            "File Extensions",
            description,
            enum_of(&options),
        )
    }
}

fn label() -> ParameterDef {
    let description = "Human-readable label for the input control.";
    ParameterDef {
        placeholder: Some("JPEG, PNG, or WebP images".to_string()),
        visible_when: when_file_upload(),
        ..param("label", "Label", description, ParameterType::String)
    }
}

fn multiple() -> ParameterDef {
    let description = "Whether multiple files or items are accepted.";
    ParameterDef {
        default: Some(serde_json::json!(true)),
        control: Some("switch".to_string()),
        visible_when: when_file_upload(),
        ..param("multiple", "Multiple", description, ParameterType::Boolean)
    }
}

fn max_file_size() -> ParameterDef {
    let description = "Maximum file size in bytes. 0 = no limit.";
    ParameterDef {
        default: Some(serde_json::json!(0)),
        constraints: Some(min(0.0, false)),
        visible_when: when_file_upload(),
        ..param(
            "maxFileSize",
            "Max File Size",
            description,
            ParameterType::Number,
        )
    }
}

fn max_files() -> ParameterDef {
    let description = "Maximum number of files. 0 = no limit.";
    ParameterDef {
        default: Some(serde_json::json!(0)),
        constraints: Some(min(0.0, false)),
        visible_when: when_file_upload(),
        ..param("maxFiles", "Max Files", description, ParameterType::Number)
    }
}

fn placeholder() -> ParameterDef {
    let description = "Placeholder text for text or URL input.";
    ParameterDef {
        visible_when: Some(visible_when_any(&[("mode", "text"), ("mode", "url")])),
        ..param(
            "placeholder",
            "Placeholder",
            description,
            ParameterType::String,
        )
    }
}