use rspack_intern::Atom;
use rspack_util::swc::AstSubRangeExt;
use swc_next_ecma_ast::{
GetSpan, ImportDeclaration, ImportDeclarationSpecifierData, Stmt, StmtData, SubRange,
};
use crate::{
JS_DEFAULT_KEYWORD, JavascriptParserPlugin,
visitors::{
ExportAllDeclaration, ExportImport, ExportNamedDeclaration, JavascriptParser,
module_export_name_to_atom,
},
};
impl JavascriptParser<'_> {
pub fn module_pre_walk_module_items(&mut self, statements: SubRange<Stmt>) {
let ast = self.ast.ast;
for statement in ast.nodes(statements) {
self.statement_path.push(statement.span(ast).into());
match ast.stmt_data(statement) {
StmtData::ImportDeclaration(declaration) => {
self.module_pre_walk_import_declaration(declaration);
}
StmtData::ExportAllDeclaration(declaration) => {
self.module_pre_walk_export_all_declaration(ExportAllDeclaration(declaration));
}
StmtData::ExportNamedDeclaration(declaration) => {
self.module_pre_walk_export_named_declaration(ExportNamedDeclaration(declaration));
}
_ => {}
}
self.prev_statement = self.statement_path.pop();
}
}
pub fn module_pre_walk_import_declaration(&mut self, declaration: ImportDeclaration) {
let ast = self.ast.ast;
let drive = self.plugin_drive();
let source = ast
.get_wtf8(declaration.source(ast).value(ast))
.to_string_lossy();
drive.import(self, declaration, &source);
let specifiers = declaration.specifiers(ast);
if specifiers.is_empty() {
return;
}
let source_atom = Atom::from(source.as_ref());
for specifier in ast.nodes(specifiers) {
match ast.import_declaration_specifier_data(specifier) {
ImportDeclarationSpecifierData::ImportSpecifier(named) => {
let local = named.local(ast);
let identifier_name = Atom::from(ast.get_utf8(local.name(ast)));
let export_name = module_export_name_to_atom(ast, named.imported(ast));
drive.import_specifier(
self,
declaration,
&source_atom,
Some(&export_name),
&identifier_name,
local,
);
}
ImportDeclarationSpecifierData::ImportDefaultSpecifier(default) => {
let identifier_name = Atom::from(ast.get_utf8(default.local(ast).name(ast)));
drive.import_specifier(
self,
declaration,
&source_atom,
Some(&JS_DEFAULT_KEYWORD),
&identifier_name,
default.local(ast),
);
}
ImportDeclarationSpecifierData::ImportNamespaceSpecifier(namespace) => {
let identifier_name = Atom::from(ast.get_utf8(namespace.local(ast).name(ast)));
drive.import_specifier(
self,
declaration,
&source_atom,
None,
&identifier_name,
namespace.local(ast),
);
}
}
}
}
pub fn module_pre_walk_export_all_declaration(&mut self, declaration: ExportAllDeclaration) {
let ast = self.ast.ast;
let drive = self.plugin_drive();
let exported_name = declaration.exported_name(ast);
let exported_name_span = declaration.exported_name_span(ast);
let statement = ExportImport::All(declaration);
let source = statement.source(ast);
drive.export_import(self, statement, &source);
drive.export_import_specifier(
self,
statement,
&source,
None,
exported_name.as_ref(),
exported_name_span,
);
}
pub fn module_pre_walk_export_named_declaration(&mut self, export: ExportNamedDeclaration) {
let ast = self.ast.ast;
let Some(source) = export.source(ast) else {
return;
};
let drive = self.plugin_drive();
drive.export_import(self, ExportImport::Named(export), &source);
for (local, exported, span) in export.named_export_specifiers(ast) {
drive.export_import_specifier(
self,
ExportImport::Named(export),
&source,
Some(&local),
Some(&exported),
Some(span),
);
}
}
}