bnto-core 0.18.2

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

// Parameters for the `loop` container: forEach / times / while iteration.

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

/// Parameters for the `loop` node, in schema order.
pub(super) fn loop_params() -> Vec<ParameterDef> {
    vec![mode(), items(), count(), condition(), break_condition()]
}

fn mode() -> ParameterDef {
    let modes = [
        ("forEach", "For Each"),
        ("times", "N Times"),
        ("while", "While"),
    ];
    let description = "How the loop iterates: over items, N times, or while a condition holds.";
    ParameterDef {
        constraints: Some(required(true)),
        control: Some("select".to_string()),
        ..param("mode", "Mode", description, enum_of(&modes))
    }
}

fn items() -> ParameterDef {
    let description = "Optional template expression for the item source. The Rust engine iterates over the incoming file batch by default — this is only needed for custom data sources.";
    ParameterDef {
        placeholder: Some("{{index . \"list-files\" \"files\"}}".to_string()),
        visible_when: Some(visible_when("mode", "forEach")),
        ..param("items", "Items", description, ParameterType::String)
    }
}

fn count() -> ParameterDef {
    let description = "Number of times to repeat.";
    ParameterDef {
        constraints: Some(min(0.0, false)),
        visible_when: Some(visible_when("mode", "times")),
        required_when: Some(visible_when("mode", "times")),
        ..param("count", "Count", description, ParameterType::Number)
    }
}

fn condition() -> ParameterDef {
    let description = "Expr expression that must evaluate to true to continue looping.";
    ParameterDef {
        placeholder: Some("counter < 10".to_string()),
        visible_when: Some(visible_when("mode", "while")),
        required_when: Some(visible_when("mode", "while")),
        ..param("condition", "Condition", description, ParameterType::String)
    }
}

fn break_condition() -> ParameterDef {
    let description = "Optional expr expression — breaks out of the loop early when true.";
    ParameterDef {
        placeholder: Some("item.status == 'done'".to_string()),
        ..param(
            "breakCondition",
            "Break Condition",
            description,
            ParameterType::String,
        )
    }
}