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
use once_cell::sync::Lazy;
use std::{
fmt::{self, Display, Formatter},
io::{self, Write},
sync::{Arc, RwLock},
};
use swc::{
config::{Config, ModuleConfig, JscConfig, Options},
Compiler,
};
use swc_common::{
errors::{DiagnosticBuilder, Emitter, Handler, SourceMapperDyn},
FileName, FilePathMapping, SourceMap,
Globals, GLOBALS,
};
use swc_ecma_ast::EsVersion;
use swc_ecma_transforms_module::common_js;
pub fn transform_sync(input: &str) -> Option<String> {
let opts = Options {
config: Config {
jsc: JscConfig {
target: Some(EsVersion::Es2017), ..Default::default()
},
module: Some(ModuleConfig::CommonJs(common_js::Config {
..Default::default()
})),
..Default::default()
},
swcrc: false,
..Default::default()
};
let (c, handler, _errors) = compiler();
let fm = c.cm.new_source_file(FileName::Anon, input.into());
let mut out = None;
GLOBALS.set(&Globals::new(), || {
out = c.process_js_file(fm, &handler, &opts).ok().map(|x| x.code);
});
out
}
fn compiler() -> (Compiler, Arc<Handler>, BufferedError) {
let cm = codemap();
let (handler, errors) = new_handler(cm.clone());
let c = Compiler::new(cm.clone());
(c, handler, errors)
}
fn codemap() -> Arc<SourceMap> {
static CM: Lazy<Arc<SourceMap>> =
Lazy::new(|| Arc::new(SourceMap::new(FilePathMapping::empty())));
CM.clone()
}
fn new_handler(_cm: Arc<SourceMapperDyn>) -> (Arc<Handler>, BufferedError) {
let e = BufferedError::default();
let handler = Handler::with_emitter(true, false, Box::new(MyEmiter::default()));
(Arc::new(handler), e)
}
#[derive(Clone, Default)]
struct MyEmiter(BufferedError);
impl Emitter for MyEmiter {
fn emit(&mut self, db: &DiagnosticBuilder<'_>) {
let z = &(self.0).0;
for msg in &db.message {
z.write().unwrap().push_str(&msg.0);
}
}
}
#[derive(Clone, Default)]
pub(crate) struct BufferedError(Arc<RwLock<String>>);
impl Write for BufferedError {
fn write(&mut self, d: &[u8]) -> io::Result<usize> {
self.0
.write()
.unwrap()
.push_str(&String::from_utf8_lossy(d));
Ok(d.len())
}
fn flush(&mut self) -> io::Result<()> {
Ok(())
}
}
impl Display for BufferedError {
fn fmt(&self, f: &mut Formatter) -> fmt::Result {
Display::fmt(&self.0.read().unwrap(), f)
}
}