Very Popular
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410use crate::error::{DiagnosticBuffer, ErrorBuffer};use crate::fast_refresh::react_refresh_fold;use crate::fixer::compat_fixer_fold;use crate::import_map::ImportHashMap;use crate::jsx::aleph_jsx_fold;use crate::resolve::Resolver;use crate::resolve_fold::{resolve_fold, ExportsParser};use crate::source_type::SourceType;
use std::{cell::RefCell, cmp::min, path::Path, rc::Rc};use swc_common::{ chain, comments::SingleThreadedComments, errors::{Handler, HandlerFlags}, FileName, Globals, Mark, SourceMap,};use swc_ecma_transforms_compat::{es2015, es2016, es2017, es2018, es2020};use swc_ecma_transforms_proposal::decorators;use swc_ecma_transforms_typescript::strip;use swc_ecmascript::{ ast::{Module, Program}, codegen::{text_writer::JsWriter, Node}, parser::{lexer::Lexer, EsConfig, JscTarget, StringInput, Syntax, TsConfig}, transforms::{fixer, helpers, hygiene, pass::Optional, react}, visit::{Fold, FoldWith},};
/// Options for transpiling a module.#[derive(Debug, Clone)]pub struct EmitOptions { pub target: JscTarget, pub jsx_factory: String, pub jsx_fragment_factory: String, pub is_dev: bool, pub transpile_only: bool, pub resolve_star_exports: bool, pub source_map: bool,}
impl Default for EmitOptions { fn default() -> Self { EmitOptions { target: JscTarget::Es2020, jsx_factory: "React.createElement".into(), jsx_fragment_factory: "React.Fragment".into(), is_dev: false, transpile_only: false, resolve_star_exports: false, source_map: false, } }}
#[derive(Clone)]pub struct SWC { pub specifier: String, pub module: Module, pub source_type: SourceType, pub source_map: Rc<SourceMap>, pub comments: SingleThreadedComments,}
impl SWC { /// parse the source of the module. /// /// ### Arguments /// /// - `specifier` - The module specifier for the module. /// - `source` - The source code for the module. /// - `target` - The target for the module. /// pub fn parse( specifier: &str, source: &str, source_type: Option<SourceType>, ) -> Result<Self, anyhow::Error> { let source_map = SourceMap::default(); let source_file = source_map.new_source_file( FileName::Real(Path::new(specifier).to_path_buf()), source.into(), ); let sm = &source_map; let error_buffer = ErrorBuffer::new(); let source_type = match source_type { Some(source_type) => match source_type { SourceType::Unknown => SourceType::from(Path::new(specifier)), _ => source_type, }, None => SourceType::from(Path::new(specifier)), }; let syntax = get_syntax(&source_type); let input = StringInput::from(&*source_file); let comments = SingleThreadedComments::default(); let lexer = Lexer::new(syntax, JscTarget::Es2020, input, Some(&comments)); let mut parser = swc_ecmascript::parser::Parser::new_from(lexer); let handler = Handler::with_emitter_and_flags( Box::new(error_buffer.clone()), HandlerFlags { can_emit_warnings: true, dont_buffer_diagnostics: true, ..HandlerFlags::default() }, ); let module = parser .parse_module() .map_err(move |err| { let mut diagnostic = err.into_diagnostic(&handler); diagnostic.emit(); DiagnosticBuffer::from_error_buffer(error_buffer, |span| sm.lookup_char_pos(span.lo)) }) .unwrap();
Ok(SWC { specifier: specifier.into(), module, source_type, source_map: Rc::new(source_map), comments, }) }
/// transform a JS/TS/JSX/TSX file into a JS file, based on the supplied options. /// /// ### Arguments /// /// - `resolver` - a resolver to resolve import/export url. /// - `options` - the options for emit code. /// pub fn transform( self, resolver: Rc<RefCell<Resolver>>, options: &EmitOptions, ) -> Result<(String, Option<String>), anyhow::Error> { swc_common::GLOBALS.set(&Globals::new(), || { let specifier_is_remote = resolver.borrow().specifier_is_remote; let transpile_only = options.transpile_only; let is_ts = match self.source_type { SourceType::TS => true, SourceType::TSX => true, _ => false, }; let is_jsx = match self.source_type { SourceType::JSX => true, SourceType::TSX => true, _ => false, }; let (aleph_jsx_fold, aleph_jsx_builtin_resolve_fold) = aleph_jsx_fold(resolver.clone(), self.source_map.clone(), options.is_dev); let root_mark = Mark::fresh(Mark::root()); let mut passes = chain!( Optional::new( resolve_fold( resolver.clone(), self.source_map.clone(), options.resolve_star_exports, ), !transpile_only ), Optional::new(aleph_jsx_fold, is_jsx && !transpile_only), Optional::new(aleph_jsx_builtin_resolve_fold, is_jsx && !transpile_only), Optional::new( react_refresh_fold( "$RefreshReg$", "$RefreshSig$", false, self.source_map.clone() ), options.is_dev && !specifier_is_remote && !transpile_only ), Optional::new( react::jsx( self.source_map.clone(), Some(&self.comments), react::Options { pragma: options.jsx_factory.clone(), pragma_frag: options.jsx_fragment_factory.clone(), // this will use `Object.assign()` instead of the `_extends` helper when spreading props. use_builtins: true, ..Default::default() }, ), is_jsx && !transpile_only ), Optional::new( decorators::decorators(decorators::Config { legacy: true, emit_metadata: false }), !transpile_only ), Optional::new(es2020(), options.target < JscTarget::Es2020), Optional::new(strip(), is_ts), Optional::new(es2018(), options.target < JscTarget::Es2018), Optional::new(es2017(), options.target < JscTarget::Es2017), Optional::new(es2016(), options.target < JscTarget::Es2016), Optional::new( es2015(root_mark, Default::default()), options.target < JscTarget::Es2015 ), Optional::new(compat_fixer_fold(), options.target < JscTarget::Es2015), Optional::new( helpers::inject_helpers(), options.target < JscTarget::Es2020 ), Optional::new(hygiene(), options.target < JscTarget::Es2020), fixer(Some(&self.comments)), );
self.apply_transform(&mut passes, options.source_map) }) }
pub fn parse_export_names(&self) -> Result<Vec<String>, anyhow::Error> { let program = Program::Module(self.module.clone()); let mut parser = ExportsParser { names: vec![] }; program.fold_with(&mut parser); Ok(parser.names) }
/// Apply transform with fold. pub fn apply_transform<T: Fold>( &self, mut tr: T, source_map: bool, ) -> Result<(String, Option<String>), anyhow::Error> { let program = Program::Module(self.module.clone()); let program = helpers::HELPERS.set(&helpers::Helpers::new(false), || program.fold_with(&mut tr)); let mut buf = Vec::new(); let mut src_map_buf = Vec::new(); let src_map = if source_map { Some(&mut src_map_buf) } else { None }; { let writer = Box::new(JsWriter::new( self.source_map.clone(), "\n", &mut buf, src_map, )); let mut emitter = swc_ecmascript::codegen::Emitter { cfg: swc_ecmascript::codegen::Config { minify: false, // todo: use swc minify in the future, currently use terser }, comments: Some(&self.comments), cm: self.source_map.clone(), wr: writer, }; program.emit_with(&mut emitter).unwrap(); }
// output let src = String::from_utf8(buf).unwrap(); if source_map { let mut buf = Vec::new(); self .source_map .build_source_map_from(&mut src_map_buf, None) .to_writer(&mut buf) .unwrap(); Ok((src, Some(String::from_utf8(buf).unwrap()))) } else { Ok((src, None)) } }}
fn get_es_config(jsx: bool) -> EsConfig { EsConfig { class_private_methods: true, class_private_props: true, class_props: true, dynamic_import: true, export_default_from: true, export_namespace_from: true, import_meta: true, jsx, nullish_coalescing: true, num_sep: true, optional_chaining: true, top_level_await: true, ..EsConfig::default() }}
fn get_ts_config(tsx: bool) -> TsConfig { TsConfig { tsx, decorators: true, dynamic_import: true, ..TsConfig::default() }}
fn get_syntax(source_type: &SourceType) -> Syntax { match source_type { SourceType::JS => Syntax::Es(get_es_config(false)), SourceType::JSX => Syntax::Es(get_es_config(true)), SourceType::TS => Syntax::Typescript(get_ts_config(false)), SourceType::TSX => Syntax::Typescript(get_ts_config(true)), _ => Syntax::Es(get_es_config(false)), }}
#[allow(dead_code)]pub fn t<T: Fold>(specifier: &str, source: &str, tr: T, expect: &str) -> bool { let module = SWC::parse(specifier, source, None).expect("could not parse module"); let (code, _) = swc_common::GLOBALS.set(&Globals::new(), || { module .apply_transform(tr, false) .expect("could not transpile module") }); let matched = code.as_str().trim().eq(expect.trim());
if !matched { let mut p: usize = 0; for i in 0..min(code.len(), expect.len()) { if code.get(i..i + 1) != expect.get(i..i + 1) { p = i; break; } } println!( "{}\x1b[0;31m{}\x1b[0m", code.get(0..p).unwrap(), code.get(p..).unwrap() ); } matched}
#[allow(dead_code)]pub fn st(specifer: &str, source: &str, bundling: bool) -> (String, Rc<RefCell<Resolver>>) { let module = SWC::parse(specifer, source, None).expect("could not parse module"); let resolver = Rc::new(RefCell::new(Resolver::new( specifer, ImportHashMap::default(), Some("https://deno.land/x/aleph@v0.3.0".into()), None, bundling, vec![], ))); let (code, _) = module .transform(resolver.clone(), &EmitOptions::default()) .expect("could not transform module"); println!("{}", code); (code, resolver)}
#[cfg(test)]mod tests { use super::*;
#[test] fn ts() { let source = r#" enum D { A, B, C, }
function enumerable(value: boolean) { return function ( _target: any, _propertyKey: string, descriptor: PropertyDescriptor, ) { descriptor.enumerable = value; }; }
export class A { private b: string; protected c: number = 1; e: "foo"; constructor (public d = D.A) { const e = "foo" as const; this.e = e; } @enumerable(false) bar() {} } "#; let (code, _) = st("https://deno.land/x/mod.ts", source, false); assert!(code.contains("var D;\n(function(D) {\n")); assert!(code.contains("_applyDecoratedDescriptor(")); }
#[test] fn jsx() { let source = r#" import React from "https://esm.sh/react" export default function Index() { return ( <> <h1 className="title">Hello World</h1> </> ) } "#; let (code, _) = st("/pages/index.tsx", source, false); assert!(code.contains("React.createElement(React.Fragment, null")); assert!(code.contains("React.createElement(\"h1\", {")); assert!(code.contains("className: \"title\"")); }}