postcard-bindgen-core 0.3.5

A crate to generate bindings for the postcard binary format for other languages than Rust - Core Crate
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
131
132
133
134
135
136
137
138
139
140
141
142
143
144

pub mod impls;

use genco::prelude::js::Tokens;

pub trait BindingTypeGenerateable {
    fn gen_ser_body(&self) -> Tokens;

    fn gen_des_body(&self) -> Tokens;

    fn gen_ty_check_body(&self) -> Tokens;

    fn gen_ts_typings_body(&self) -> Tokens;
}

mod ser {
    use genco::prelude::js::Tokens;

    use crate::{
        code_gen::{
            generateable::{types::JsTypeGenerateable, VariableAccess, VariablePath},
            utils::semicolon_chain,
        },
        registry::StructField,
        type_info::JsType,
    };

    pub fn gen_accessors_indexed(
        fields: impl AsRef<[JsType]>,
        variable_path: VariablePath,
    ) -> Tokens {
        semicolon_chain(fields.as_ref().iter().enumerate().map(|(index, field)| {
            let path = variable_path
                .to_owned()
                .modify_push(VariableAccess::Indexed(index));
            field.gen_ser_accessor(path)
        }))
    }

    pub fn gen_accessors_fields(
        fields: impl AsRef<[StructField]>,
        variable_path: VariablePath,
    ) -> Tokens {
        semicolon_chain(fields.as_ref().iter().map(|field| {
            let path = variable_path
                .to_owned()
                .modify_push(VariableAccess::Field(field.name.into()));
            field.js_type.gen_ser_accessor(path)
        }))
    }
}

mod des {
    use genco::{prelude::js::Tokens, quote};

    use crate::{
        code_gen::{
            generateable::types::{self, JsTypeGenerateable},
            utils::comma_chain,
        },
        registry::StructField,
        type_info::JsType,
    };

    pub fn gen_accessors_fields(fields: impl AsRef<[StructField]>) -> Tokens {
        let body = comma_chain(fields.as_ref().iter().map(|field| {
            field
                .js_type
                .gen_des_accessor(types::des::FieldAccessor::Object(field.name))
        }));
        quote!({ $body })
    }

    pub fn gen_accessors_indexed(fields: impl AsRef<[JsType]>) -> Tokens {
        let body = comma_chain(
            fields
                .as_ref()
                .iter()
                .map(|js_type| js_type.gen_des_accessor(types::des::FieldAccessor::Array)),
        );
        quote!([$body])
    }
}

mod ty_check {
    use genco::{prelude::js::Tokens, quote};

    use crate::{
        code_gen::{
            generateable::{types::JsTypeGenerateable, VariableAccess, VariablePath},
            utils::and_chain,
        },
        registry::StructField,
        type_info::JsType,
    };

    pub fn gen_object_checks(
        fields: impl AsRef<[StructField]>,
        variable_path: VariablePath,
    ) -> Tokens {
        let field_checks = and_chain(fields.as_ref().iter().map(|field| {
            let path = variable_path
                .to_owned()
                .modify_push(VariableAccess::Field(field.name.into()));
            field.js_type.gen_ty_check(path)
        }));
        quote!(typeof $variable_path === "object" && $field_checks)
    }

    pub fn gen_array_checks(fields: impl AsRef<[JsType]>, variable_path: VariablePath) -> Tokens {
        let arr_len = fields.as_ref().len();
        let field_checks = and_chain(fields.as_ref().iter().enumerate().map(|(index, field)| {
            let path = variable_path
                .to_owned()
                .modify_push(VariableAccess::Indexed(index));
            field.gen_ty_check(path)
        }));
        quote!(Array.isArray($(variable_path.to_owned())) && $variable_path.length === $arr_len && $field_checks)
    }
}

pub mod ts {
    use genco::{prelude::js::Tokens, quote};

    use crate::{
        code_gen::{generateable::types::JsTypeGenerateable, utils::comma_chain},
        registry::StructField,
        type_info::JsType,
    };

    pub fn gen_typings_indexed(fields: impl AsRef<[JsType]>) -> Tokens {
        let body = comma_chain(fields.as_ref().iter().map(|f| quote!($(f.gen_ts_type()))));
        quote!([$body])
    }

    pub fn gen_typings_fields(fields: impl AsRef<[StructField]>) -> Tokens {
        let body = comma_chain(
            fields
                .as_ref()
                .iter()
                .map(|f| quote!($(f.name): $(f.js_type.gen_ts_type()))),
        );
        quote!({ $body })
    }
}