feat(rstest_plugin): handle import.meta.dirname and import.meta.filename

Author: fi3ework

crates/rspack_plugin_javascript/src/visitors/dependency/parser/mod.rs

@@ -231,7 +231,7 @@ pub struct JavascriptParser<'parser> {
   pub(crate) worker_index: u32,
   pub(crate) build_meta: &'parser mut BuildMeta,
   pub build_info: &'parser mut BuildInfo,
-  pub(crate) resource_data: &'parser ResourceData,
+  pub resource_data: &'parser ResourceData,
   pub(crate) plugin_drive: Rc<JavaScriptParserPluginDrive>,
   pub(crate) definitions_db: ScopeInfoDB,
   pub(crate) compiler_options: &'parser CompilerOptions,

crates/rspack_plugin_rstest/src/parser_plugin.rs

@@ -1,13 +1,46 @@
-use rspack_plugin_javascript::JavascriptParserPlugin;
+use rspack_core::{ConstDependency, SpanExt};
+use rspack_plugin_javascript::{
+  utils, utils::eval, visitors::JavascriptParser, JavascriptParserPlugin,
+};
+use swc_core::common::Spanned;
 
 use crate::module_path_name_dependency::{ModulePathNameDependency, NameType};
 
 const DIR_NAME: &str = "__dirname";
 const FILE_NAME: &str = "__filename";
+const IMPORT_META_DIRNAME: &str = "import.meta.dirname";
+const IMPORT_META_FILENAME: &str = "import.meta.filename";
+
+#[derive(PartialEq)]
+enum ModulePathType {
+  DirName,
+  FileName,
+}
 
 #[derive(Debug, Default)]
 pub struct RstestParserPlugin;
 
+impl RstestParserPlugin {
+  fn import_meta(&self, parser: &mut JavascriptParser, r#type: ModulePathType) -> String {
+    if r#type == ModulePathType::FileName {
+      if let Some(resource_path) = &parser.resource_data.resource_path {
+        format!("'{}'", resource_path.clone().into_string())
+      } else {
+        "''".to_string()
+      }
+    } else {
+      let resource_path = parser
+        .resource_data
+        .resource_path
+        .as_deref()
+        .and_then(|p| p.parent())
+        .map(|p| p.to_string())
+        .unwrap_or_default();
+      format!("'{}'", resource_path)
+    }
+  }
+}
+
 impl JavascriptParserPlugin for RstestParserPlugin {
   fn identifier(
     &self,
@@ -36,4 +69,92 @@ impl JavascriptParserPlugin for RstestParserPlugin {
       _ => None,
     }
   }
+
+  fn evaluate_typeof<'a>(
+    &self,
+    _parser: &mut JavascriptParser,
+    expr: &'a swc_core::ecma::ast::UnaryExpr,
+    for_name: &str,
+  ) -> Option<utils::eval::BasicEvaluatedExpression<'a>> {
+    let mut evaluated = None;
+    if for_name == IMPORT_META_DIRNAME || for_name == IMPORT_META_FILENAME {
+      evaluated = Some("string".to_string());
+    }
+    evaluated.map(|e| eval::evaluate_to_string(e, expr.span.real_lo(), expr.span.real_hi()))
+  }
+
+  fn evaluate_identifier(
+    &self,
+    parser: &mut JavascriptParser,
+    ident: &str,
+    start: u32,
+    end: u32,
+  ) -> Option<eval::BasicEvaluatedExpression<'static>> {
+    if ident == IMPORT_META_DIRNAME {
+      Some(eval::evaluate_to_string(
+        self.import_meta(parser, ModulePathType::DirName),
+        start,
+        end,
+      ))
+    } else if ident == IMPORT_META_FILENAME {
+      Some(eval::evaluate_to_string(
+        self.import_meta(parser, ModulePathType::FileName),
+        start,
+        end,
+      ))
+    } else {
+      None
+    }
+  }
+
+  fn r#typeof(
+    &self,
+    parser: &mut JavascriptParser,
+    unary_expr: &swc_core::ecma::ast::UnaryExpr,
+    for_name: &str,
+  ) -> Option<bool> {
+    if for_name == IMPORT_META_DIRNAME || for_name == IMPORT_META_FILENAME {
+      parser
+        .presentational_dependencies
+        .push(Box::new(ConstDependency::new(
+          unary_expr.span().into(),
+          "'string'".into(),
+          None,
+        )));
+      Some(true)
+    } else {
+      None
+    }
+  }
+
+  fn member(
+    &self,
+    parser: &mut JavascriptParser,
+    member_expr: &swc_core::ecma::ast::MemberExpr,
+    for_name: &str,
+  ) -> Option<bool> {
+    if for_name == IMPORT_META_DIRNAME {
+      let result = self.import_meta(parser, ModulePathType::DirName);
+      parser
+        .presentational_dependencies
+        .push(Box::new(ConstDependency::new(
+          member_expr.span().into(),
+          result.into(),
+          None,
+        )));
+      Some(true)
+    } else if for_name == IMPORT_META_FILENAME {
+      let result = self.import_meta(parser, ModulePathType::FileName);
+      parser
+        .presentational_dependencies
+        .push(Box::new(ConstDependency::new(
+          member_expr.span().into(),
+          result.into(),
+          None,
+        )));
+      Some(true)
+    } else {
+      None
+    }
+  }
 }

packages/rspack-test-tools/tests/configCases/plugins/rstest/index.js

@@ -4,16 +4,28 @@ const path = require('path');
 it("Insert module path names with concatenateModules", () => {
 	const sourceDir = path.resolve(__dirname, "../../../../");
 	const content = fs.readFileSync(path.resolve(__dirname, "modulePathName.js"), "utf-8");
+	// __dirname and __filename renamed after concatenation
 	expect(content).toContain(`const foo_filename = '${path.resolve(sourceDir, "./configCases/plugins/rstest/src/foo.js")}'`);
-	expect(content).toMatch(`const bar_dirname = '${path.resolve(sourceDir, "./configCases/plugins/rstest/src")}'`);
+	expect(content).toMatch(`const foo_dirname = '${path.resolve(sourceDir, "./configCases/plugins/rstest/src")}'`);
+
+	expect(content).toMatch(`const metaFile1 = '${path.resolve(sourceDir, "./configCases/plugins/rstest/src/foo.js")}'`)
+	expect(content).toMatch(`const metaDir1 = '${path.resolve(sourceDir, "./configCases/plugins/rstest/src")}'`)
+
+	expect(content).toContain(`const typeofMetaDir = 'string'`);
+	expect(content).toContain(`const typeofMetaFile = 'string'`);
 });
 
 it("Insert module path names without concatenateModules", () => {
 	const sourceDir = path.resolve(__dirname, "../../../../");
 	const content = fs.readFileSync(path.resolve(__dirname, "modulePathNameWithoutConcatenate.js"), "utf-8");
 	expect(content).toContain(`const __filename = '${path.resolve(sourceDir, "./configCases/plugins/rstest/src/foo.js")}'`);
 	expect(content).toMatch(`const __dirname = '${path.resolve(sourceDir, "./configCases/plugins/rstest/src")}'`);
-
 	expect(content.match(/const __dirname = /g).length).toBe(2);
 	expect(content.match(/const __filename = /g).length).toBe(2);
+
+	expect(content).toMatch(`const metaFile1 = '${path.resolve(sourceDir, "./configCases/plugins/rstest/src/foo.js")}'`)
+	expect(content).toMatch(`const metaDir1 = '${path.resolve(sourceDir, "./configCases/plugins/rstest/src")}'`)
+
+	expect(content).toContain(`const typeofMetaDir = 'string'`);
+	expect(content).toContain(`const typeofMetaFile = 'string'`);
 });

packages/rspack-test-tools/tests/configCases/plugins/rstest/src/bar.js

@@ -1 +1,2 @@
-export const barValue = 'bar: ' + __dirname
+export const file = __filename
+export const dir = __dirname

packages/rspack-test-tools/tests/configCases/plugins/rstest/src/baz.js

@@ -1,3 +1,18 @@
-export const fooValue1 = 'foo: ' + __filename
-export const fooValue2 = 'foo: ' + __filename
-export const fooValue3 = 'foo: ' + __filename
+export const file1 = __filename
+export const file2 = __filename
+export const metaFile1 = import.meta.filename
+export const typeofMetaFile = typeof import.meta.filename
+
+export const dir1 =  __dirname
+export const dir2 =  __dirname
+export const metaDir1 = import.meta.dirname
+export const typeofMetaDir = typeof import.meta.dirname
+
+if (import.meta.filename.indexOf("foo.js") === -1) {
+  require("fail")
+};
+
+if (import.meta.dirname.indexOf("plugins/rstest/src") === -1) {
+  require("fail")
+};
+

packages/rspack-test-tools/tests/configCases/plugins/rstest/src/foo.js

@@ -1,12 +1,15 @@
-import { fooValue1, fooValue2, fooValue3 } from './foo'
-import { barValue } from './bar'
-import { bazValue1, bazValue2 } from './baz'
+import { file1, file2, metaFile1, dir1, dir2, metaDir1, typeofMetaFile, typeofMetaDir } from './foo'
+import { file, dir } from './bar'
 
 console.log(
-	fooValue1,
-	fooValue2,
-	fooValue3,
-	barValue,
-	bazValue1,
-	bazValue2
+	file1,
+	file2,
+	metaFile1,
+	dir1,
+	dir2,
+	metaDir1,
+	typeofMetaFile,
+	typeofMetaDir,
+	file,
+	dir
 )