oxc_transformer 0.136.0

A collection of JavaScript tools written in Rust.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115

//! 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/v7.28.4/packages/babel-plugin-transform-export-namespace-from>
//! * "export ns from" TC39 proposal: <https://github.com/tc39/proposal-export-ns-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;

impl ExportNamespaceFrom {
    pub fn new() -> Self {
        Self
    }
}

impl<'a> Traverse<'a, TransformState<'a>> for ExportNamespaceFrom {
    fn exit_program(&mut self, program: &mut Program<'a>, ctx: &mut TraverseCtx<'a>) {
        // Early return if there's no `export * as ns from "mod"` to transform
        let has_export_namespace = program.body.iter().any(
            |stmt| matches!(stmt, Statement::ExportAllDeclaration(decl) if decl.exported.is_some()),
        );
        if !has_export_namespace {
            return;
        }

        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();
                    let exported_name = exported.unwrap();

                    // Create a unique binding for the import based on the exported name
                    let binding = ctx.generate_uid_based_on_node(
                        &exported_name,
                        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,
                        NONE,
                        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_name, 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;
    }
}