feat(bindings): Create a minifier-only package (#7993)

.github/workflows/publish-node.yml

@@ -205,7 +205,17 @@ jobs:
       - name: Upload artifact
         uses: actions/upload-artifact@v3
         with:
-          name: bindings-${{ matrix.settings.target }}
+          name: |
+            bindings-${{ matrix.settings.target }}
+          path: |
+            swc*
+          if-no-files-found: error
+      # Separate step for fail-fast
+      - name: Upload minifier artifacts
+        uses: actions/upload-artifact@v3
+        with:
+          name: |
+            minifier-${{ matrix.settings.target }}
           path: |
             swc*
           if-no-files-found: error
@@ -459,6 +469,7 @@ jobs:
           npm config set provenance true
           echo "//registry.npmjs.org/:_authToken=$NPM_TOKEN" >> ~/.npmrc
           npm publish --access public
+          (cd ./packages/minifier && npm publish --access public)
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
           NPM_TOKEN: ${{ secrets.NPM_TOKEN }}

bindings/Cargo.toml

@@ -1,5 +1,11 @@
 [workspace]
-members = ["binding_core_node", "binding_core_wasm", "swc_cli"]
+members = [
+    "binding_core_node",
+    "binding_core_wasm",
+    "binding_minifier_node",
+    "binding_minifier_wasm",
+    "swc_cli",
+]
 
 [profile.release]
 # lto = true

bindings/binding_minifier_node/Cargo.toml

@@ -0,0 +1,44 @@
+[package]
+authors = ["강동윤 <[email protected]>"]
+build   = "build.rs"
+edition = "2021"
+exclude = ["artifacts.json", "index.node"]
+license = "Apache-2.0"
+name    = "binding_minifier_node"
+publish = false
+version = "0.1.0"
+
+[lib]
+bench      = false
+crate-type = ["cdylib"]
+
+[build-dependencies]
+napi-build = { version = "2" }
+
+[dependencies]
+anyhow = "1.0.66"
+backtrace = "0.3"
+napi = { version = "2", default-features = false, features = [
+  "napi3",
+  "serde-json",
+] }
+napi-derive = { version = "2", default-features = false, features = [
+  "type-def",
+] }
+node_macro_deps = { path = "../node_macro_deps" }
+path-clean = "0.1"
+serde = { version = "1", features = ["derive"] }
+serde_json = { version = "1", features = ["unbounded_depth"] }
+tracing = { version = "0.1.37", features = ["release_max_level_info"] }
+tracing-chrome = "0.5.0"
+tracing-futures = "0.2.5"
+tracing-subscriber = { version = "0.3.9", features = ["env-filter"] }
+
+swc_core = { version = "0.83.18", features = [
+  "allocator_node",
+  "ecma_ast",
+  "ecma_codegen",
+  "common_concurrent",
+  "ecma_minifier",
+] }
+swc_node_base = "0.5.8"

bindings/binding_minifier_node/build.rs

@@ -0,0 +1,23 @@
+use std::{
+    env,
+    fs::File,
+    io::{BufWriter, Write},
+    path::Path,
+};
+
+extern crate napi_build;
+
+fn main() {
+    let out_dir = env::var("OUT_DIR").expect("Outdir should exist");
+    let dest_path = Path::new(&out_dir).join("triple.txt");
+    let mut f =
+        BufWriter::new(File::create(&dest_path).expect("Failed to create target triple text"));
+    write!(
+        f,
+        "{}",
+        env::var("TARGET").expect("Target should be specified")
+    )
+    .expect("Failed to write target triple text");
+
+    napi_build::setup();
+}

bindings/binding_minifier_node/src/lib.rs

@@ -0,0 +1,64 @@
+#![recursion_limit = "2048"]
+#![allow(dead_code)]
+
+#[macro_use]
+extern crate napi_derive;
+
+extern crate swc_node_base;
+
+use std::{env, panic::set_hook, sync::Arc};
+
+use backtrace::Backtrace;
+use swc_core::{
+    base::Compiler,
+    common::{sync::Lazy, FilePathMapping, SourceMap},
+};
+
+mod minify;
+mod util;
+
+static COMPILER: Lazy<Arc<Compiler>> = Lazy::new(|| {
+    let cm = Arc::new(SourceMap::new(FilePathMapping::empty()));
+
+    Arc::new(Compiler::new(cm))
+});
+
+#[napi::module_init]
+fn init() {
+    if cfg!(debug_assertions) || env::var("SWC_DEBUG").unwrap_or_default() == "1" {
+        set_hook(Box::new(|panic_info| {
+            let backtrace = Backtrace::new();
+            println!("Panic: {:?}\nBacktrace: {:?}", panic_info, backtrace);
+        }));
+    }
+}
+
+fn get_compiler() -> Arc<Compiler> {
+    COMPILER.clone()
+}
+
+#[napi(js_name = "Compiler")]
+pub struct JsCompiler {
+    _compiler: Arc<Compiler>,
+}
+
+#[napi]
+impl JsCompiler {
+    #[napi(constructor)]
+    #[allow(clippy::new_without_default)]
+    #[tracing::instrument(level = "info", skip_all)]
+    pub fn new() -> Self {
+        Self {
+            _compiler: COMPILER.clone(),
+        }
+    }
+}
+
+pub type ArcCompiler = Arc<Compiler>;
+
+/// Hack for `Type Generation`
+#[napi(object)]
+pub struct TransformOutput {
+    pub code: String,
+    pub map: Option<String>,
+}

bindings/binding_minifier_node/src/minify.rs

@@ -0,0 +1,106 @@
+use std::sync::Arc;
+
+use napi::{
+    bindgen_prelude::{AbortSignal, AsyncTask, Buffer},
+    Task,
+};
+use serde::Deserialize;
+use swc_core::{
+    base::{
+        config::{ErrorFormat, JsMinifyOptions},
+        TransformOutput,
+    },
+    common::{collections::AHashMap, sync::Lrc, FileName, SourceFile, SourceMap},
+    node::{deserialize_json, get_deserialized, MapErr},
+};
+
+use crate::{get_compiler, util::try_with};
+
+struct MinifyTask {
+    c: Arc<swc_core::base::Compiler>,
+    code: String,
+    options: String,
+}
+
+#[derive(Deserialize)]
+#[serde(untagged)]
+enum MinifyTarget {
+    /// Code to minify.
+    Single(String),
+    /// `{ filename: code }`
+    Map(AHashMap<String, String>),
+}
+
+impl MinifyTarget {
+    fn to_file(&self, cm: Lrc<SourceMap>) -> Lrc<SourceFile> {
+        match self {
+            MinifyTarget::Single(code) => cm.new_source_file(FileName::Anon, code.clone()),
+            MinifyTarget::Map(codes) => {
+                assert_eq!(
+                    codes.len(),
+                    1,
+                    "swc.minify does not support concatting multiple files yet"
+                );
+
+                let (filename, code) = codes.iter().next().unwrap();
+
+                cm.new_source_file(FileName::Real(filename.clone().into()), code.clone())
+            }
+        }
+    }
+}
+
+#[napi]
+impl Task for MinifyTask {
+    type JsValue = TransformOutput;
+    type Output = TransformOutput;
+
+    fn compute(&mut self) -> napi::Result<Self::Output> {
+        let input: MinifyTarget = deserialize_json(&self.code)?;
+        let options: JsMinifyOptions = deserialize_json(&self.options)?;
+
+        try_with(self.c.cm.clone(), false, ErrorFormat::Normal, |handler| {
+            let fm = input.to_file(self.c.cm.clone());
+
+            self.c.minify(fm, handler, &options)
+        })
+        .convert_err()
+    }
+
+    fn resolve(&mut self, _env: napi::Env, output: Self::Output) -> napi::Result<Self::JsValue> {
+        Ok(output)
+    }
+}
+
+#[napi]
+fn minify(code: Buffer, opts: Buffer, signal: Option<AbortSignal>) -> AsyncTask<MinifyTask> {
+    crate::util::init_default_trace_subscriber();
+    let code = String::from_utf8_lossy(code.as_ref()).to_string();
+    let options = String::from_utf8_lossy(opts.as_ref()).to_string();
+
+    let c = get_compiler();
+
+    let task = MinifyTask { c, code, options };
+
+    AsyncTask::with_optional_signal(task, signal)
+}
+
+#[napi]
+pub fn minify_sync(code: Buffer, opts: Buffer) -> napi::Result<TransformOutput> {
+    crate::util::init_default_trace_subscriber();
+    let code: MinifyTarget = get_deserialized(code)?;
+    let opts = get_deserialized(opts)?;
+
+    let c = get_compiler();
+
+    let fm = code.to_file(c.cm.clone());
+
+    try_with(
+        c.cm.clone(),
+        false,
+        // TODO(kdy1): Maybe make this configurable?
+        ErrorFormat::Normal,
+        |handler| c.minify(fm, handler, &opts),
+    )
+    .convert_err()
+}