tsain-pattern 0.1.0

Chain TypeScript and Rust in fast and secure way
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

use super::formatter::{DefaultPropsFormatter, PropsFormatter};

mod props;
mod vars;

pub use props::*;
pub use vars::*;

/// Object Pattern
pub enum TsainPattern {
    Enum(EnumPattern),
    Struct(PropsPattern),
}

pub struct Composition<T> {
    /// Rs type name
    /// * Enum / Struct: Rs ident name
    /// * Variant: "{enum-name}{var-name}"
    rs_name: &'static str,
    /// Ts type name
    /// * Enum / Struct: Ts export name
    /// * Variant: "{enum-name}{var-name}"
    ts_name: &'static str,
    ///
    type_args: Vec<&'static str>,
    /// * Enum: vars
    /// * Struct / Variant: props
    list: T,
    /// skip default brand of "__brand"
    skip_brand: bool,
    ///
    /// [[brand-key, brand's value]]
    extra_brands: Vec<[&'static str; 2]>,
}

impl<T> Composition<T> {
    pub fn new(
        rs_name: &'static str,
        ts_name: &'static str,
        type_args: Vec<&'static str>,
        list: T,
        skip_brand: bool,
        extra_brands: Vec<[&'static str; 2]>,
    ) -> Self {
        Self {
            rs_name,
            ts_name,
            type_args,
            list,
            skip_brand,
            extra_brands,
        }
    }

    fn build_brands_script(&self) -> String {
        let mut pairs = Vec::new();
        if !self.skip_brand {
            pairs.push(format!(r#"readonly __brand: "{}""#, self.ts_name));
        }
        pairs.extend(
            self.extra_brands.iter().map(|[brand_name, brand_ts_type]| {
                format!("readonly {brand_name}: {brand_ts_type}")
            }),
        );

        if pairs.is_empty() {
            Default::default()
        } else {
            let pairs = pairs.join(", ");
            format!(" & {{{}}}", pairs)
        }
    }
}

impl TsainPattern {
    pub fn new_enum(
        rs_name: &'static str,
        ts_name: &'static str,
        type_args: Vec<&'static str>,
        // [Option<(var-"full"-ts-name, props-pattern)>]
        list: Vec<Option<(&'static str, PropsPattern)>>,
    ) -> Self {
        Self::Enum(EnumPattern::new(
            rs_name,
            ts_name,
            type_args,
            list,
            // enum itself should not have brand
            true,
            Default::default(),
        ))
    }

    pub fn new_struct(
        rs_name: &'static str,
        ts_name: &'static str,
        type_args: Vec<&'static str>,
        list: Vec<(&'static str, &'static str)>,
        skip_brand: bool,
        extra_brands: Vec<[&'static str; 2]>,
    ) -> Self {
        Self::Struct(PropsPattern::new(
            rs_name,
            ts_name,
            type_args,
            list,
            skip_brand,
            extra_brands,
        ))
    }

    pub fn rs_name(&self) -> &str {
        match self {
            Self::Enum(Composition { rs_name, .. }) | Self::Struct(Composition { rs_name, .. }) => {
                rs_name
            }
        }
    }

    pub fn format_type_script(&self) -> String {
        match self {
            Self::Enum(e) => e.format_enum_type_script(&DefaultPropsFormatter),
            Self::Struct(e) => DefaultPropsFormatter.format_type_script(e, None),
        }
    }
}