fix(es/typescript): Handle TypeScript expressions in enum transformation

crates/swc_ecma_transforms_typescript/src/transform.rs

@@ -1074,17 +1074,22 @@ impl Transform {
             return FoldedDecl::Empty;
         }
 
-        let opaque = member_list
-            .iter()
-            .any(|item| matches!(item.value, TsEnumRecordValue::Opaque(..)));
+        let namespace_export = self.namespace_id.is_some() && is_export;
+        let iife = !is_first || namespace_export;
+
+        let mut opaque = false;
 
         let stmts = member_list
             .into_iter()
             .filter(|item| !ts_enum_safe_remove || !item.is_const())
-            .map(|item| item.build_assign(&id.to_id()));
+            .map(|mut item| {
+                if let TsEnumRecordValue::Opaque(ref mut expr) = item.value {
+                    opaque = true;
+                    expr.visit_mut_with(self);
+                }
 
-        let namespace_export = self.namespace_id.is_some() && is_export;
-        let iife = !is_first || namespace_export;
+                item.build_assign(&id.to_id())
+            });
 
         let body = if !iife {
             let return_stmt: Stmt = ReturnStmt {

crates/swc_ecma_transforms_typescript/src/ts_enum.rs

@@ -155,6 +155,14 @@ impl EnumValueComputer<'_> {
             Expr::Bin(e) => self.compute_bin(e),
             Expr::Member(e) => self.compute_member(e),
             Expr::Tpl(e) => self.compute_tpl(e),
+            // Handle TypeScript type expressions by stripping them
+            // and computing the inner expression
+            Expr::TsAs(TsAsExpr { expr, .. })
+            | Expr::TsNonNull(TsNonNullExpr { expr, .. })
+            | Expr::TsTypeAssertion(TsTypeAssertion { expr, .. })
+            | Expr::TsConstAssertion(TsConstAssertion { expr, .. })
+            | Expr::TsInstantiation(TsInstantiation { expr, .. })
+            | Expr::TsSatisfies(TsSatisfiesExpr { expr, .. }) => self.compute_rec(expr),
             _ => TsEnumRecordValue::Opaque(expr),
         }
     }

crates/swc_ecma_transforms_typescript/tests/__swc_snapshots__/tests/strip.rs/ts_enum_with_nested_class.js

@@ -0,0 +1,8 @@
+var Foo = function(Foo) {
+    Foo[Foo["a"] = (class {
+        constructor(b){
+            this.b = b;
+        }
+    }, 0)] = "a";
+    return Foo;
+}(Foo || {});

crates/swc_ecma_transforms_typescript/tests/__swc_snapshots__/tests/strip.rs/ts_enum_with_nested_enum.js

@@ -0,0 +1,10 @@
+var Foo = function(Foo) {
+    Foo[Foo["a"] = (()=>{
+        (function(Bar) {
+            Bar["a"] = "a";
+            Bar["b"] = "b";
+        })(Bar);
+        return 0;
+    })()] = "a";
+    return Foo;
+}(Foo || {});

crates/swc_ecma_transforms_typescript/tests/__swc_snapshots__/tests/strip.rs/ts_enum_with_opaque_expr.js

@@ -0,0 +1,4 @@
+var Foo = function(Foo) {
+    Foo[Foo["a"] = foo('x')] = "a";
+    return Foo;
+}(Foo || {});

crates/swc_ecma_transforms_typescript/tests/__swc_snapshots__/tests/strip.rs/ts_enum_with_type_assertion.js

@@ -0,0 +1,5 @@
+var RefType = /*#__PURE__*/ function(RefType) {
+    RefType["property"] = "11";
+    RefType["event"] = "22";
+    return RefType;
+}(RefType || {});

crates/swc_ecma_transforms_typescript/tests/fixture/issue-3001/1/output.js

@@ -3,7 +3,7 @@ var Foo = function(Foo) {
     Foo[Foo["a"] = 0] = "a";
     Foo[Foo["b"] = 0] = "b";
     Foo[Foo["c"] = 1] = "c";
-    Foo[Foo["d"] = 1 + Foo.c * x] = "d";
+    Foo[Foo["d"] = 1 + 1 * x] = "d";
     Foo[Foo["e"] = 2 * Foo.d] = "e";
     Foo[Foo["f"] = Foo.e * 10] = "f";
     return Foo;

crates/swc_ecma_transforms_typescript/tests/fixture/issue-3001/2/output.js

@@ -17,6 +17,6 @@ var Baz = function(Baz) {
     Baz[Baz["a"] = 0] = "a";
     Baz[Baz["b"] = 1] = "b";
     // @ts-ignore
-    Baz[Baz["x"] = Baz.a.toString()] = "x";
+    Baz[Baz["x"] = 0..toString()] = "x";
     return Baz;
 }(Baz || {});

crates/swc_ecma_transforms_typescript/tests/strip.rs

@@ -353,6 +353,43 @@ to!(
 }"
 );
 
+to!(
+    ts_enum_with_type_assertion,
+    "enum RefType {
+  property = '11' as any,
+  event = '22' as any,
+}"
+);
+
+to!(
+    ts_enum_with_opaque_expr,
+    "enum Foo {
+    a = foo('x' as any),
+}"
+);
+
+to!(
+    ts_enum_with_nested_class,
+    "enum Foo {
+    a = (class {
+        constructor(public b: string) { }
+    }, 0)
+}"
+);
+
+to!(
+    ts_enum_with_nested_enum,
+    "enum Foo {
+    a = (() => {
+        enum Bar {
+            a = 'a',
+            b = 'b',
+        }
+        return 0;
+    })(),
+}"
+);
+
 to!(module_01, "module 'foo'{ }");
 
 to!(declare_01, "declare var env: FOO");