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

crates/swc_ecma_transforms_typescript/src/transform.rs

@@ -22,7 +22,7 @@ use crate::{
     retain::{should_retain_module_item, should_retain_stmt},
     semantic::SemanticInfo,
     shared::enum_member_id_atom,
-    ts_enum::{TsEnumRecordKey, TsEnumRecordValue},
+    ts_enum::{EnumValueComputer, TsEnumRecordKey, TsEnumRecordValue},
     utils::{assign_value_to_this_private_prop, assign_value_to_this_prop, Factory},
 };
 
@@ -1063,7 +1063,16 @@ impl Transform {
                     member_name: name.clone(),
                 };
 
-                let value = self.semantic.enum_record.get(&key).unwrap().clone();
+                let mut value = self.semantic.enum_record.get(&key).unwrap().clone();
+
+                if let TsEnumRecordValue::Opaque(expr) = &mut value {
+                    *expr = m.init.unwrap();
+                    expr.visit_mut_with(&mut EnumValueComputer {
+                        enum_id: &id.to_id(),
+                        unresolved_ctxt: self.unresolved_ctxt,
+                        record: &self.semantic.enum_record,
+                    });
+                }
 
                 EnumMemberItem { span, name, value }
             })

crates/swc_ecma_transforms_typescript/src/ts_enum.rs

@@ -112,11 +112,7 @@ pub(crate) struct EnumValueComputer<'a> {
 /// https://github.com/microsoft/TypeScript/pull/50528
 impl EnumValueComputer<'_> {
     pub fn compute(&mut self, expr: Box<Expr>) -> TsEnumRecordValue {
-        let mut expr = self.compute_rec(expr);
-        if let TsEnumRecordValue::Opaque(expr) = &mut expr {
-            expr.visit_mut_with(self);
-        }
-        expr
+        self.compute_rec(expr)
     }
 
     fn compute_rec(&self, expr: Box<Expr>) -> TsEnumRecordValue {
@@ -155,6 +151,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/issue_6219.js

@@ -1,4 +1,4 @@
 var A = function(A) {
-    A[A["a"] = a] = "a";
+    A[A["a"] = A.a] = "a";
     return A;
 }(A || {});

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,11 @@
+var Foo = function(Foo) {
+    Foo[Foo["a"] = (()=>{
+        let Bar = /*#__PURE__*/ function(Bar) {
+            Bar["a"] = "a";
+            Bar["b"] = "b";
+            return 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/2/output.js

@@ -2,7 +2,7 @@ var x = 10;
 var Foo = function(Foo) {
     Foo[Foo["a"] = 10] = "a";
     Foo[Foo["b"] = 10] = "b";
-    Foo[Foo["c"] = 10 + x] = "c";
+    Foo[Foo["c"] = Foo.b + x] = "c";
     Foo[Foo["d"] = Foo.c] = "d";
     return Foo;
 }(Foo || {});

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");