spack: enhancement (#845)

 - Handle modules (via swcrc)
 - swc.bundle([conf1, conf2])
 - Correct chunking

.github/ISSUE_TEMPLATE/crash_report.md

@@ -13,3 +13,7 @@ assignees: ''
 
 3. Error message gained from `swc --sync <input.js>`
 (--sync is required to get panic message)
+
+4. Backtrace
+
+(You can get it by invoking swc by setting an environment varaible`SWC_DEBUG` to `1`, invoke swc like `SWC_DEBUG=1 npx swc foo.js` on linux / darwin)

common/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "swc_common"
-version = "0.5.13"
+version = "0.5.14"
 authors = ["강동윤 <kdy1997.dev@gmail.com>"]
 license = "Apache-2.0/MIT"
 repository = "https://github.com/swc-project/swc.git"

ecmascript/transforms/src/macros.rs

@@ -240,6 +240,7 @@ macro_rules! validate {
     }};
 }
 
+#[macro_export]
 macro_rules! noop_fold_type {
     ($F:ty, $N:tt) => {
         impl Fold<swc_ecma_ast::$N> for $F {
@@ -316,6 +317,7 @@ macro_rules! noop_fold_type {
     };
 }
 
+#[macro_export]
 macro_rules! noop_visit_type {
     ($F:ty, $N:tt) => {
         impl Visit<swc_ecma_ast::$N> for $F {

native/Cargo.toml

@@ -18,6 +18,7 @@ neon-build = "0.4.0"
 [dependencies]
 swc = { path = "../" }
 spack = { path = "../spack" }
+backtrace = "0.3"
 fxhash = "0.2"
 anyhow = "1"
 serde_json = "1"

native/src/bundle.rs

@@ -4,12 +4,14 @@ use fxhash::FxHashMap;
 use neon::prelude::*;
 use serde::Deserialize;
 use spack::{
-    config::EntryConfig,
     load::Load,
     resolve::{NodeResolver, Resolve},
     BundleKind,
 };
-use std::{path::PathBuf, sync::Arc};
+use std::{
+    panic::{catch_unwind, AssertUnwindSafe},
+    sync::Arc,
+};
 use swc::{config::SourceMapsConfig, Compiler, TransformOutput};
 
 struct ConfigItem {
@@ -38,77 +40,73 @@ impl Task for BundleTask {
     type JsEvent = JsValue;
 
     fn perform(&self) -> Result<Self::Output, Self::Error> {
-        let working_dir = PathBuf::from(self.config.static_items.working_dir.clone());
-        let bundler = spack::Bundler::new(
-            working_dir.clone(),
-            self.swc.clone(),
-            self.config
-                .static_items
-                .config
-                .options
-                .as_ref()
-                .map(|options| options.clone())
-                .unwrap_or_else(|| {
-                    serde_json::from_value(serde_json::Value::Object(Default::default())).unwrap()
-                }),
-            &self.config.resolver,
-            &self.config.loader,
-        );
-        let entries = match &self.config.static_items.config.entry {
-            EntryConfig::File(name) => {
-                let mut m = FxHashMap::default();
-                m.insert(name.clone(), working_dir.join(name));
-                m
-            }
-            EntryConfig::Multiple(files) => {
-                let mut m = FxHashMap::default();
-                for name in files {
-                    m.insert(name.clone(), working_dir.join(name));
-                }
-                m
-            }
-            EntryConfig::Files(v) => v
+        let res = catch_unwind(AssertUnwindSafe(|| {
+            let bundler = spack::Bundler::new(
+                self.swc.clone(),
+                self.config
+                    .static_items
+                    .config
+                    .options
+                    .as_ref()
+                    .map(|options| options.clone())
+                    .unwrap_or_else(|| {
+                        serde_json::from_value(serde_json::Value::Object(Default::default()))
+                            .unwrap()
+                    }),
+                &self.config.resolver,
+                &self.config.loader,
+            );
+
+            let result = bundler.bundle(&self.config.static_items.config)?;
+
+            let result = result
                 .into_iter()
-                .map(|(k, v)| (k.clone(), working_dir.clone().join(v)))
-                .collect(),
+                .map(|bundle| match bundle.kind {
+                    BundleKind::Named { name } | BundleKind::Lib { name } => {
+                        Ok((name, bundle.module))
+                    }
+                    BundleKind::Dynamic => bail!("unimplemented: dynamic code splitting"),
+                })
+                .map(|res| {
+                    res.and_then(|(k, m)| {
+                        // TODO: Source map
+                        let minify = self
+                            .config
+                            .static_items
+                            .config
+                            .options
+                            .as_ref()
+                            .map(|v| {
+                                v.config
+                                    .as_ref()
+                                    .map(|v| v.minify)
+                                    .flatten()
+                                    .unwrap_or(false)
+                            })
+                            .unwrap_or(false);
+
+                        let output =
+                            self.swc
+                                .print(&m, SourceMapsConfig::Bool(true), None, minify)?;
+
+                        Ok((k, output))
+                    })
+                })
+                .collect::<Result<_, _>>()?;
+
+            Ok(result)
+        }));
+
+        let err = match res {
+            Ok(v) => return v,
+            Err(err) => err,
         };
 
-        let result = bundler.bundle(entries)?;
-
-        let result = result
-            .into_iter()
-            .map(|bundle| match bundle.kind {
-                BundleKind::Named { name } | BundleKind::Lib { name } => Ok((name, bundle.module)),
-                BundleKind::Dynamic => bail!("unimplemented: dynamic code splitting"),
-            })
-            .map(|res| {
-                res.and_then(|(k, m)| {
-                    // TODO: Source map
-                    let minify = self
-                        .config
-                        .static_items
-                        .config
-                        .options
-                        .as_ref()
-                        .map(|v| {
-                            v.config
-                                .as_ref()
-                                .map(|v| v.minify)
-                                .flatten()
-                                .unwrap_or(false)
-                        })
-                        .unwrap_or(false);
-
-                    let output = self
-                        .swc
-                        .print(&m, SourceMapsConfig::Bool(true), None, minify)?;
-
-                    Ok((k, output))
-                })
-            })
-            .collect::<Result<_, _>>()?;
+        if let Some(s) = err.downcast_ref::<String>() {
+            bail!("panic detected: {}", s);
+        }
 
-        Ok(result)
+        bail!("panic detected")
     }
 
     fn complete(

native/src/lib.rs

@@ -10,9 +10,12 @@ extern crate serde;
 extern crate swc;
 
 use anyhow::{Context as _, Error};
+use backtrace::Backtrace;
 use neon::prelude::*;
 use path_clean::clean;
 use std::{
+    env,
+    panic::set_hook,
     path::{Path, PathBuf},
     sync::Arc,
 };
@@ -26,6 +29,13 @@ use swc::{
 mod bundle;
 
 fn init(_cx: MethodContext<JsUndefined>) -> NeonResult<ArcCompiler> {
+    if cfg!(debug_assertions) || env::var("SWC_DEBUG").unwrap_or_else(|_| String::new()) == "1" {
+        set_hook(Box::new(|_panic_info| {
+            let backtrace = Backtrace::new();
+            println!("Backtrace: {:?}", backtrace);
+        }));
+    }
+
     let cm = Arc::new(SourceMap::new(FilePathMapping::empty()));
 
     let handler = Arc::new(Handler::with_tty_emitter(

node-swc/__tests__/spack/config_test.js

@@ -10,4 +10,14 @@ it('should handle multiple entry in spack.config.js', async () => {
 
     expect(result.b).toBeTruthy();
     expect(result.b.code.replace('\n', '')).toBe(`console.log('bar');`);
+});
+
+it('should respect .swcrc', async () => {
+    const result = await swc.bundle(path.join(__dirname, '../../tests/spack/config-swcrc/spack.config.js'));
+
+    expect(result.a).toBeTruthy();
+    expect(result.a.code).toContain(`require('./common-`);
+
+    expect(result.b).toBeTruthy();
+    expect(result.b.code).toContain(`require('./common-`);
 });

node-swc/__tests__/spack/multi_entry_test.js

@@ -0,0 +1,34 @@
+const swc = require("../../..");
+const path = require('path');
+
+
+it('should handle multiple entries on same level', async () => {
+    const result = await swc.bundle({
+        entry: {
+            a: path.join(__dirname, '../../tests/spack/mutli-entry-same-level/src/a.js'),
+            b: path.join(__dirname, '../../tests/spack/mutli-entry-same-level/src/b.js'),
+        }
+    });
+
+    expect(result.a).toBeTruthy();
+    expect(result.a.code).toContain(`import { foo } from './common-`);
+
+    expect(result.b).toBeTruthy();
+    expect(result.b.code).toContain(`import { foo } from './common-`);
+});
+
+
+it('should handle multiple entries on different level', async () => {
+    const result = await swc.bundle({
+        entry: {
+            web: path.join(__dirname, '../../tests/spack/mutli-entry-different-level/src/web/index.js'),
+            a: path.join(__dirname, '../../tests/spack/mutli-entry-different-level/src/a.js'),
+        }
+    });
+
+    expect(result.a).toBeTruthy();
+    expect(result.a.code).toContain(`import { foo } from './common-`);
+
+    expect(result.web).toBeTruthy();
+    expect(result.web.code).toContain(`../common`);
+});

node-swc/src/index.ts

@@ -221,6 +221,20 @@ export class Compiler extends wrapNativeSuper(native.Compiler) {
   async bundle(options?: BundleInput | string): Promise<{ [name: string]: Output }> {
     const opts = await compileBundleOptions(options);
 
+    if (Array.isArray(opts)) {
+      const all = await Promise.all(opts.map(async (opt) => {
+        return this.bundle(opt)
+      }));
+      let obj = {} as any;
+      for (const o of all) {
+        obj = {
+          ...obj,
+          ...o,
+        };
+      }
+      return obj;
+    }
+
     return new Promise((resolve, reject) => {
       super.bundle({
         ...opts,

node-swc/src/spack/index.ts

@@ -8,13 +8,21 @@ export async function compileBundleOptions(c: BundleInput | string | undefined):
 
     try {
         const file = typeof f === 'string' ? f : path.resolve('spack.config.js');
-        let configFromFile = require(file);
-        if (configFromFile.default) {
-            configFromFile = configFromFile.default;
+        let configFromFile: BundleInput = require(file);
+        if ((configFromFile as any).default) {
+            configFromFile = (configFromFile as any).default;
+        }
+        if (Array.isArray(configFromFile)) {
+            if (Array.isArray(f)) {
+                return [...configFromFile, ...f]
+            }
+            if (typeof f !== 'string') {
+                configFromFile.push(f);
+            }
+            return configFromFile;
         }
         return Object.assign({}, configFromFile, c);
     } catch (e) {
-        console.log(e);
         if (typeof f === 'string') {
             throw new Error(`Config file does not exist at ${c}`)
         }

node-swc/tests/spack/config-swcrc/.swcrc

@@ -0,0 +1,5 @@
+{
+  "module": {
+    "type": "commonjs"
+  }
+}

node-swc/tests/spack/config-swcrc/common.js

@@ -0,0 +1 @@
+console.log('Prevent inlinig')

node-swc/tests/spack/config-swcrc/entry1.js

@@ -0,0 +1 @@
+import './common'

node-swc/tests/spack/config-swcrc/entry2.js

@@ -0,0 +1 @@
+import './common'

node-swc/tests/spack/config-swcrc/spack.config.js

@@ -0,0 +1,8 @@
+const path = require('path');
+
+module.exports = {
+    entry: {
+        a: path.join(__dirname, 'entry1.js'),
+        b: path.join(__dirname, 'entry2.js'),
+    },
+}

node-swc/tests/spack/mutli-entry-different-level/src/a.js

@@ -0,0 +1,3 @@
+import { foo } from './common'
+
+console.log(foo)

node-swc/tests/spack/mutli-entry-different-level/src/common.js

@@ -0,0 +1,5 @@
+console.log('loading foo')
+export const foo = 'FOO';
+console.log('loaded foo')
+
+

node-swc/tests/spack/mutli-entry-different-level/src/web/index.js

@@ -0,0 +1 @@
+import '../common';

node-swc/tests/spack/mutli-entry-same-level/src/a.js

@@ -0,0 +1,3 @@
+import { foo } from './common'
+
+console.log(foo)

node-swc/tests/spack/mutli-entry-same-level/src/b.js

@@ -0,0 +1,3 @@
+import { foo } from './common'
+
+console.log(foo)

node-swc/tests/spack/mutli-entry-same-level/src/common.js

@@ -0,0 +1,5 @@
+console.log('loading foo')
+export const foo = 'FOO';
+console.log('loaded foo')
+
+

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@swc/core",
-  "version": "1.2.2",
+  "version": "1.2.3",
   "description": "Super-fast alternative for babel",
   "main": "./index.js",
   "author": "강동윤 <kdy1997.dev@gmail.com>",

spack/.gitignore

@@ -1,3 +1,3 @@
-*.js
+/*.js
 *.d.ts
 *.map