feat(es/typescript): Add swc_fast_ts_strip

.github/workflows/CI.yml

@@ -168,6 +168,14 @@ jobs:
     if: >-
       ${{ !contains(github.event.head_commit.message, 'chore: ') }}
     runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        pkg:
+          - binding_core_wasm
+          - binding_minifier_wasm
+          - binding_typescript_wasm
+
     steps:
       - uses: actions/checkout@v4
 
@@ -202,7 +210,7 @@ jobs:
 
       - name: Test
         run: |
-          (cd bindings/binding_core_wasm && ./scripts/test.sh)
+          (cd bindings/${{ matrix.pkg }} && ./scripts/test.sh)
 
   cargo-test:
     name: Test - ${{ matrix.settings.crate }} - ${{ matrix.settings.os }}

bindings/binding_minifier_wasm/__tests__/__snapshots__/simple.js.snap

@@ -0,0 +1,7 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`minify should work 1`] = `
+Object {
+  "code": "console.log(1);",
+}
+`;

bindings/binding_minifier_wasm/__tests__/simple.js

@@ -0,0 +1,15 @@
+const swc = require("../pkg");
+
+describe("minify", () => {
+    it("should work", async () => {
+        const output = await swc.minify(
+            `{
+            const a = 1;
+            console.log(a);
+        }`,
+            {}
+        );
+
+        expect(output).toMatchSnapshot();
+    });
+});

bindings/binding_minifier_wasm/scripts/test.sh

@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+
+set -eu
+
+wasm-pack build --out-name wasm --release --scope=swc --target nodejs
+npx jest $@

bindings/binding_typescript_wasm/__tests__/__snapshots__/transform.js.snap

@@ -1,8 +1,25 @@
 // Jest Snapshot v1, https://goo.gl/fbAQLP
 
-exports[`transform in strip-only mode should throw an error when it encounters an enum 1`] = `
+exports[`transform in strip-only mode should throw an error when it encounters a module 1`] = `
+"  x TypeScript namespace declaration is not supported in strip-only mode
+   ,----
+ 1 | module 'foo' {}
+   : ^^^^^^^^^^^^^^^
+   \`----
+"
+`;
+
+exports[`transform in strip-only mode should throw an error when it encounters a namespace 1`] = `
+"  x TypeScript namespace declaration is not supported in strip-only mode
+   ,----
+ 1 | namespace Foo {}
+   : ^^^^^^^^^^^^^^^^
+   \`----
 "
-  x TypeScript enum is not supported in strip-only mode
+`;
+
+exports[`transform in strip-only mode should throw an error when it encounters an enum 1`] = `
+"  x TypeScript enum is not supported in strip-only mode
    ,----
  1 | enum Foo {}
    : ^^^^^^^^^^^
@@ -11,8 +28,7 @@ exports[`transform in strip-only mode should throw an error when it encounters a
 `;
 
 exports[`transform in strip-only mode should throw an error with a descriptive message when it encounters a decorator 1`] = `
-"
-  x Decorators are not supported
+"  x Decorators are not supported
    ,----
  1 | class Foo { @decorator foo() {} }
    :             ^^^^^^^^^^

bindings/binding_typescript_wasm/__tests__/transform.js

@@ -27,13 +27,29 @@ describe("transform", () => {
             ).rejects.toMatchSnapshot();
         });
 
-        it('should throw an error with a descriptive message when it encounters a decorator', async () => {
+        it("should throw an error with a descriptive message when it encounters a decorator", async () => {
             await expect(
                 swc.transform("class Foo { @decorator foo() {} }", {
                     mode: "strip-only",
                 })
             ).rejects.toMatchSnapshot();
-        })
+        });
+
+        it("should throw an error when it encounters a namespace", async () => {
+            await expect(
+                swc.transform("namespace Foo {}", {
+                    mode: "strip-only",
+                })
+            ).rejects.toMatchSnapshot();
+        });
+
+        it("should throw an error when it encounters a module", async () => {
+            await expect(
+                swc.transform("module 'foo' {}", {
+                    mode: "strip-only",
+                })
+            ).rejects.toMatchSnapshot();
+        });
     });
 
     describe("in transform mode", () => {
@@ -44,7 +60,5 @@ describe("transform", () => {
 
             expect(code).toMatchSnapshot();
         });
-
-
     });
 });

bindings/binding_typescript_wasm/src/lib.rs

@@ -9,7 +9,10 @@ use swc_core::{
         FileName, Mark, SourceMap, Spanned, GLOBALS,
     },
     ecma::{
-        ast::{Decorator, EsVersion, Program, TsEnumDecl, TsParamPropParam},
+        ast::{
+            Decorator, EsVersion, Program, TsEnumDecl, TsModuleDecl, TsNamespaceDecl,
+            TsParamPropParam,
+        },
         codegen::text_writer::JsWriter,
         parser::{
             parse_file_as_module, parse_file_as_program, parse_file_as_script, Syntax, TsSyntax,
@@ -263,6 +266,10 @@ impl Visit for Validator {
     }
 
     fn visit_ts_enum_decl(&mut self, e: &TsEnumDecl) {
+        if e.declare {
+            return;
+        }
+
         if matches!(self.mode, Mode::StripOnly) {
             HANDLER.with(|handler| {
                 handler.span_err(
@@ -276,6 +283,42 @@ impl Visit for Validator {
         e.visit_children_with(self);
     }
 
+    fn visit_ts_module_decl(&mut self, n: &TsModuleDecl) {
+        if n.declare {
+            return;
+        }
+
+        if matches!(self.mode, Mode::StripOnly) {
+            HANDLER.with(|handler| {
+                handler.span_err(
+                    n.span(),
+                    "TypeScript namespace declaration is not supported in strip-only mode",
+                );
+            });
+            return;
+        }
+
+        n.visit_children_with(self);
+    }
+
+    fn visit_ts_namespace_decl(&mut self, n: &TsNamespaceDecl) {
+        if n.declare {
+            return;
+        }
+
+        if matches!(self.mode, Mode::StripOnly) {
+            HANDLER.with(|handler| {
+                handler.span_err(
+                    n.span(),
+                    "TypeScript module declaration is not supported in strip-only mode",
+                );
+            });
+            return;
+        }
+
+        n.visit_children_with(self);
+    }
+
     fn visit_ts_param_prop_param(&mut self, n: &TsParamPropParam) {
         if matches!(self.mode, Mode::StripOnly) {
             HANDLER.with(|handler| {