feat(transformer): add ES2020 export namespace from transformation

Author: sapphi-red

crates/oxc_transformer/src/es2020/export_namespace_from.rs

@@ -0,0 +1,103 @@
+//! ES2020: Export Namespace From
+//!
+//! This plugin transforms `export * as ns from "mod"` to `import * as _ns from "mod"; export { _ns as ns }`.
+//!
+//! > This plugin is included in `preset-env`, in ES2020
+//!
+//! ## Example
+//!
+//! Input:
+//! ```js
+//! export * as ns from "mod";
+//! ```
+//!
+//! Output:
+//! ```js
+//! import * as _ns from "mod";
+//! export { _ns as ns };
+//! ```
+//!
+//! ## Implementation
+//!
+//! Implementation based on [@babel/plugin-transform-export-namespace-from](https://babeljs.io/docs/babel-plugin-transform-export-namespace-from).
+//!
+//! ## References:
+//! * Babel plugin implementation: <https://github.com/babel/babel/tree/main/packages/babel-plugin-transform-export-namespace-from>
+
+use oxc_allocator::TakeIn;
+use oxc_ast::{NONE, ast::*};
+use oxc_semantic::SymbolFlags;
+use oxc_span::SPAN;
+use oxc_traverse::Traverse;
+
+use crate::{context::TraverseCtx, state::TransformState};
+
+pub struct ExportNamespaceFrom<'a, 'ctx> {
+    _ctx: &'ctx crate::context::TransformCtx<'a>,
+}
+
+impl<'a, 'ctx> ExportNamespaceFrom<'a, 'ctx> {
+    pub fn new(ctx: &'ctx crate::context::TransformCtx<'a>) -> Self {
+        Self { _ctx: ctx }
+    }
+}
+
+impl<'a> Traverse<'a, TransformState<'a>> for ExportNamespaceFrom<'a, '_> {
+    fn exit_program(&mut self, program: &mut Program<'a>, ctx: &mut TraverseCtx<'a>) {
+        let mut new_statements = ctx.ast.vec_with_capacity(program.body.len());
+
+        for stmt in program.body.take_in(ctx.ast) {
+            match stmt {
+                Statement::ExportAllDeclaration(export_all) if export_all.exported.is_some() => {
+                    // Transform `export * as ns from "mod"` to:
+                    // `import * as _ns from "mod"; export { _ns as ns };`
+
+                    let ExportAllDeclaration { span, exported, source, export_kind, .. } =
+                        export_all.unbox();
+
+                    // Create a unique binding for the import
+                    let binding = ctx.generate_uid("ns", program.scope_id(), SymbolFlags::Import);
+
+                    // Create `import * as _ns from "mod"`
+                    let import_specifier = ImportDeclarationSpecifier::ImportNamespaceSpecifier(
+                        ctx.ast.alloc_import_namespace_specifier(
+                            SPAN,
+                            binding.create_binding_identifier(ctx),
+                        ),
+                    );
+
+                    let import_decl = ctx.ast.alloc_import_declaration(
+                        SPAN,
+                        Some(ctx.ast.vec1(import_specifier)),
+                        source,
+                        None, // phase
+                        NONE, // with_clause
+                        export_kind,
+                    );
+                    new_statements.push(Statement::ImportDeclaration(import_decl));
+
+                    // Create `export { _ns as ns }`
+                    let local =
+                        ModuleExportName::IdentifierReference(binding.create_read_reference(ctx));
+                    let export_specifier =
+                        ctx.ast.export_specifier(span, local, exported.unwrap(), export_kind);
+
+                    let export_named_decl = ctx.ast.alloc_export_named_declaration(
+                        SPAN,
+                        None,
+                        ctx.ast.vec1(export_specifier),
+                        None,
+                        export_kind,
+                        NONE,
+                    );
+                    new_statements.push(Statement::ExportNamedDeclaration(export_named_decl));
+                }
+                _ => {
+                    new_statements.push(stmt);
+                }
+            }
+        }
+
+        program.body = new_statements;
+    }
+}

crates/oxc_transformer/src/es2020/mod.rs

@@ -7,9 +7,11 @@ use crate::{
     state::TransformState,
 };
 
+mod export_namespace_from;
 mod nullish_coalescing_operator;
 mod optional_chaining;
 mod options;
+use export_namespace_from::ExportNamespaceFrom;
 use nullish_coalescing_operator::NullishCoalescingOperator;
 pub use optional_chaining::OptionalChaining;
 pub use options::ES2020Options;
@@ -19,6 +21,7 @@ pub struct ES2020<'a, 'ctx> {
     options: ES2020Options,
 
     // Plugins
+    export_namespace_from: ExportNamespaceFrom<'a, 'ctx>,
     nullish_coalescing_operator: NullishCoalescingOperator<'a, 'ctx>,
     optional_chaining: OptionalChaining<'a, 'ctx>,
 }
@@ -28,13 +31,20 @@ impl<'a, 'ctx> ES2020<'a, 'ctx> {
         Self {
             ctx,
             options,
+            export_namespace_from: ExportNamespaceFrom::new(ctx),
             nullish_coalescing_operator: NullishCoalescingOperator::new(ctx),
             optional_chaining: OptionalChaining::new(ctx),
         }
     }
 }
 
 impl<'a> Traverse<'a, TransformState<'a>> for ES2020<'a, '_> {
+    fn exit_program(&mut self, program: &mut Program<'a>, ctx: &mut TraverseCtx<'a>) {
+        if self.options.export_namespace_from {
+            self.export_namespace_from.exit_program(program, ctx);
+        }
+    }
+
     fn enter_expression(&mut self, expr: &mut Expression<'a>, ctx: &mut TraverseCtx<'a>) {
         if self.options.nullish_coalescing_operator {
             self.nullish_coalescing_operator.enter_expression(expr, ctx);

crates/oxc_transformer/src/es2020/options.rs

@@ -3,6 +3,9 @@ use serde::Deserialize;
 #[derive(Debug, Default, Clone, Copy, Deserialize)]
 #[serde(default, rename_all = "camelCase", deny_unknown_fields)]
 pub struct ES2020Options {
+    #[serde(skip)]
+    pub export_namespace_from: bool,
+
     #[serde(skip)]
     pub nullish_coalescing_operator: bool,
 

crates/oxc_transformer/src/lib.rs

@@ -212,6 +212,7 @@ impl<'a> Traverse<'a, TransformState<'a>> for TransformerImpl<'a, '_> {
             typescript.exit_program(program, ctx);
         }
         self.x2_es2022.exit_program(program, ctx);
+        self.x2_es2020.exit_program(program, ctx);
         self.x2_es2018.exit_program(program, ctx);
         self.common.exit_program(program, ctx);
     }

crates/oxc_transformer/src/options/babel/plugins.rs

@@ -63,6 +63,7 @@ pub struct BabelPlugins {
     // ES2019
     pub optional_catch_binding: bool,
     // ES2020
+    pub export_namespace_from: bool,
     pub optional_chaining: bool,
     pub nullish_coalescing_operator: bool,
     // ES2021
@@ -148,6 +149,7 @@ impl TryFrom<PluginPresetEntries> for BabelPlugins {
                 }
                 "transform-async-generator-functions" => p.async_generator_functions = true,
                 "transform-optional-catch-binding" => p.optional_catch_binding = true,
+                "transform-export-namespace-from" => p.export_namespace_from = true,
                 "transform-optional-chaining" => p.optional_chaining = true,
                 "transform-nullish-coalescing-operator" => p.nullish_coalescing_operator = true,
                 "transform-logical-assignment-operators" => p.logical_assignment_operators = true,

crates/oxc_transformer/src/options/env.rs

@@ -74,6 +74,7 @@ impl EnvOptions {
             },
             es2019: ES2019Options { optional_catch_binding: true },
             es2020: ES2020Options {
+                export_namespace_from: true,
                 nullish_coalescing_operator: true,
                 // Turn this on would throw error for all bigints.
                 big_int: false,
@@ -150,6 +151,7 @@ impl From<EngineTargets> for EnvOptions {
                 optional_catch_binding: o.has_feature(ES2019OptionalCatchBinding),
             },
             es2020: ES2020Options {
+                export_namespace_from: o.has_feature(ES2020ExportNamespaceFrom),
                 nullish_coalescing_operator: o.has_feature(ES2020NullishCoalescingOperator),
                 big_int: o.has_feature(ES2020BigInt),
                 optional_chaining: o.has_feature(ES2020OptionalChaining),

crates/oxc_transformer/src/options/mod.rs

@@ -226,6 +226,8 @@ impl TryFrom<&BabelOptions> for TransformOptions {
         };
 
         let es2020 = ES2020Options {
+            export_namespace_from: options.plugins.export_namespace_from
+                || env.es2020.export_namespace_from,
             optional_chaining: options.plugins.optional_chaining || env.es2020.optional_chaining,
             nullish_coalescing_operator: options.plugins.nullish_coalescing_operator
                 || env.es2020.nullish_coalescing_operator,

crates/oxc_transformer/tests/integrations/export_namespace_from.rs

@@ -0,0 +1,121 @@
+use oxc_transformer::{BabelOptions, ES2020Options, EnvOptions, TransformOptions};
+
+use crate::test;
+
+#[test]
+fn test_export_namespace_from() {
+    let cases = [
+        (
+            r#"export * as ns from "mod";"#,
+            r#"import * as _ns from 'mod';
+export { _ns as ns };
+"#,
+        ),
+        (
+            r#"export * as foo from "bar";"#,
+            r#"import * as _ns from 'bar';
+export { _ns as foo };
+"#,
+        ),
+        (
+            r#"export * as myModule from "./module";"#,
+            r#"import * as _ns from './module';
+export { _ns as myModule };
+"#,
+        ),
+        (
+            r#"export * as default from "mod";"#,
+            r#"import * as _ns from 'mod';
+export { _ns as default };
+"#,
+        ),
+    ];
+
+    let options = TransformOptions {
+        env: EnvOptions {
+            es2020: ES2020Options { export_namespace_from: true, ..ES2020Options::default() },
+            ..EnvOptions::default()
+        },
+        ..TransformOptions::default()
+    };
+
+    for (input, expected) in cases {
+        let result = test(input, &options);
+        assert_eq!(result, Ok(expected.to_string()), "Failed to transform: {}", input);
+    }
+}
+
+#[test]
+fn test_export_namespace_from_disabled() {
+    let input = r#"export * as ns from "mod";"#;
+    let options = TransformOptions {
+        env: EnvOptions {
+            es2020: ES2020Options { export_namespace_from: false, ..ES2020Options::default() },
+            ..EnvOptions::default()
+        },
+        ..TransformOptions::default()
+    };
+
+    let result = test(input, &options);
+    // When disabled, the transformation should not happen
+    assert_eq!(result, Ok("export * as ns from 'mod';\n".to_string()));
+}
+
+#[test]
+fn test_export_star_without_alias() {
+    // Regular export * should not be transformed
+    let input = r#"export * from "mod";"#;
+    let options = TransformOptions {
+        env: EnvOptions {
+            es2020: ES2020Options { export_namespace_from: true, ..ES2020Options::default() },
+            ..EnvOptions::default()
+        },
+        ..TransformOptions::default()
+    };
+
+    let result = test(input, &options);
+    // Should remain unchanged
+    assert_eq!(result, Ok("export * from 'mod';\n".to_string()));
+}
+
+#[test]
+fn test_export_namespace_from_with_babel_plugin() {
+    // Test using babel plugin option
+    let input = r#"export * as ns from "mod";"#;
+    let babel_options = BabelOptions {
+        plugins: serde_json::from_str(r#"[["transform-export-namespace-from"]]"#).unwrap(),
+        ..BabelOptions::default()
+    };
+    let options = TransformOptions::try_from(&babel_options).unwrap();
+
+    let result = test(input, &options);
+    assert_eq!(result, Ok("import * as _ns from 'mod';\nexport { _ns as ns };\n".to_string()));
+}
+
+#[test]
+fn test_export_namespace_from_with_old_target() {
+    // Test that it works with old browser targets that don't support the syntax
+    let input = r#"export * as ns from "mod";"#;
+    let options = TransformOptions {
+        env: EnvOptions::from_browserslist_query("chrome 70").unwrap(),
+        ..TransformOptions::default()
+    };
+
+    let result = test(input, &options);
+    // Chrome 70 doesn't support export * as, so it should be transformed
+    assert_eq!(result, Ok("import * as _ns from 'mod';\nexport { _ns as ns };\n".to_string()));
+}
+
+#[test]
+fn test_export_namespace_from_with_modern_target() {
+    // Test that it doesn't transform for modern browsers that support the syntax
+    let input = r#"export * as ns from "mod";"#;
+    let options = TransformOptions {
+        env: EnvOptions::from_browserslist_query("chrome 90").unwrap(),
+        ..TransformOptions::default()
+    };
+
+    let result = test(input, &options);
+    // Chrome 90 supports export * as, so it should not be transformed
+    assert_eq!(result, Ok("export * as ns from 'mod';\n".to_string()));
+}

crates/oxc_transformer/tests/integrations/main.rs

@@ -1,4 +1,5 @@
 mod es_target;
+mod export_namespace_from;
 mod targets;
 
 use std::path::Path;