1#![doc(html_root_url = "https://docs.rs/wasm-bindgen-shared/0.2")]
2
3#[cfg(test)]
4mod schema_hash_approval;
5
6// This gets changed whenever our schema changes.
7// At this time versions of wasm-bindgen and wasm-bindgen-cli are required to have the exact same
8// SCHEMA_VERSION in order to work together.
9pub const SCHEMA_VERSION: &str = "0.2.92";
10
11#[macro_export]
12macro_rules! shared_api {
13 ($mac:ident) => {
14 $mac! {
15 struct Program<'a> {
16 exports: Vec<Export<'a>>,
17 enums: Vec<Enum<'a>>,
18 imports: Vec<Import<'a>>,
19 structs: Vec<Struct<'a>>,
20 typescript_custom_sections: Vec<&'a str>,
21 local_modules: Vec<LocalModule<'a>>,
22 inline_js: Vec<&'a str>,
23 unique_crate_identifier: &'a str,
24 package_json: Option<&'a str>,
25 linked_modules: Vec<LinkedModule<'a>>,
26 }
27
28 struct Import<'a> {
29 module: Option<ImportModule<'a>>,
30 js_namespace: Option<Vec<String>>,
31 kind: ImportKind<'a>,
32 }
33
34 struct LinkedModule<'a> {
35 module: ImportModule<'a>,
36 link_function_name: &'a str,
37 }
38
39 enum ImportModule<'a> {
40 Named(&'a str),
41 RawNamed(&'a str),
42 Inline(u32),
43 }
44
45 enum ImportKind<'a> {
46 Function(ImportFunction<'a>),
47 Static(ImportStatic<'a>),
48 Type(ImportType<'a>),
49 Enum(ImportEnum),
50 }
51
52 struct ImportFunction<'a> {
53 shim: &'a str,
54 catch: bool,
55 variadic: bool,
56 assert_no_shim: bool,
57 method: Option<MethodData<'a>>,
58 structural: bool,
59 function: Function<'a>,
60 }
61
62 struct MethodData<'a> {
63 class: &'a str,
64 kind: MethodKind<'a>,
65 }
66
67 enum MethodKind<'a> {
68 Constructor,
69 Operation(Operation<'a>),
70 }
71
72 struct Operation<'a> {
73 is_static: bool,
74 kind: OperationKind<'a>,
75 }
76
77 enum OperationKind<'a> {
78 Regular,
79 Getter(&'a str),
80 Setter(&'a str),
81 IndexingGetter,
82 IndexingSetter,
83 IndexingDeleter,
84 }
85
86 struct ImportStatic<'a> {
87 name: &'a str,
88 shim: &'a str,
89 }
90
91 struct ImportType<'a> {
92 name: &'a str,
93 instanceof_shim: &'a str,
94 vendor_prefixes: Vec<&'a str>,
95 }
96
97 struct ImportEnum {}
98
99 struct Export<'a> {
100 class: Option<&'a str>,
101 comments: Vec<&'a str>,
102 consumed: bool,
103 function: Function<'a>,
104 method_kind: MethodKind<'a>,
105 start: bool,
106 }
107
108 struct Enum<'a> {
109 name: &'a str,
110 variants: Vec<EnumVariant<'a>>,
111 comments: Vec<&'a str>,
112 generate_typescript: bool,
113 }
114
115 struct EnumVariant<'a> {
116 name: &'a str,
117 value: u32,
118 comments: Vec<&'a str>,
119 }
120
121 struct Function<'a> {
122 arg_names: Vec<String>,
123 asyncness: bool,
124 name: &'a str,
125 generate_typescript: bool,
126 generate_jsdoc: bool,
127 variadic: bool,
128 }
129
130 struct Struct<'a> {
131 name: &'a str,
132 fields: Vec<StructField<'a>>,
133 comments: Vec<&'a str>,
134 is_inspectable: bool,
135 generate_typescript: bool,
136 }
137
138 struct StructField<'a> {
139 name: &'a str,
140 readonly: bool,
141 comments: Vec<&'a str>,
142 generate_typescript: bool,
143 generate_jsdoc: bool,
144 }
145
146 struct LocalModule<'a> {
147 identifier: &'a str,
148 contents: &'a str,
149 }
150 }
151 }; // end of mac case
152} // end of mac definition
153
154pub fn new_function(struct_name: &str) -> String {
155 let mut name: String = "__wbg_".to_string();
156 name.extend(iter:struct_name.chars().flat_map(|s: char| s.to_lowercase()));
157 name.push_str(string:"_new");
158 name
159}
160
161pub fn free_function(struct_name: &str) -> String {
162 let mut name: String = "__wbg_".to_string();
163 name.extend(iter:struct_name.chars().flat_map(|s: char| s.to_lowercase()));
164 name.push_str(string:"_free");
165 name
166}
167
168pub fn unwrap_function(struct_name: &str) -> String {
169 let mut name: String = "__wbg_".to_string();
170 name.extend(iter:struct_name.chars().flat_map(|s: char| s.to_lowercase()));
171 name.push_str(string:"_unwrap");
172 name
173}
174
175pub fn free_function_export_name(function_name: &str) -> String {
176 function_name.to_string()
177}
178
179pub fn struct_function_export_name(struct_: &str, f: &str) -> String {
180 let mut name: String = struct_impl Iterator
181 .chars()
182 .flat_map(|s: char| s.to_lowercase())
183 .collect::<String>();
184 name.push(ch:'_');
185 name.push_str(string:f);
186 name
187}
188
189pub fn struct_field_get(struct_: &str, f: &str) -> String {
190 let mut name: String = String::from("__wbg_get_");
191 name.extend(iter:struct_.chars().flat_map(|s: char| s.to_lowercase()));
192 name.push(ch:'_');
193 name.push_str(string:f);
194 name
195}
196
197pub fn struct_field_set(struct_: &str, f: &str) -> String {
198 let mut name: String = String::from("__wbg_set_");
199 name.extend(iter:struct_.chars().flat_map(|s: char| s.to_lowercase()));
200 name.push(ch:'_');
201 name.push_str(string:f);
202 name
203}
204
205pub fn version() -> String {
206 let mut v: String = env!("CARGO_PKG_VERSION").to_string();
207 if let Some(s: &str) = option_env!("WBG_VERSION") {
208 v.push_str(string:" (");
209 v.push_str(string:s);
210 v.push(ch:')');
211 }
212 v
213}
214