Merge main branch and fix chunk characteristics implementation

- Resolve conflicts with main branch changes
- Update pnpm-lock.yaml to latest versions
- Fixed API extractor issues

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: ScriptedAlchemy

.cargo/config.toml

@@ -43,10 +43,6 @@ rustflags = [
 [target.'cfg(target_vendor = "apple")']
 rustflags = ["-C", "link-args=-Wl,-undefined,dynamic_lookup,-no_fixup_chains,-all_load"]
 
-# To be able to run unit tests on Linux, support compilation to 'x86_64-unknown-linux-gnu'.
-[target.'cfg(target_os = "linux")']
-rustflags = ["-C", "link-args=-Wl,--warn-unresolved-symbols"]
-
 # To be able to run unit tests on Windows, support compilation to 'x86_64-pc-windows-msvc'.
 # Use Hybrid CRT to reduce the size of the binary (Coming by default with Windows 10 and later versions).
 [target.'cfg(target_os = "windows")']

crates/node_binding/napi-binding.d.ts

@@ -404,8 +404,8 @@ export declare class JsModuleGraph {
 }
 
 export declare class JsResolver {
-  resolveSync(path: string, request: string): JsResourceData | false
-  resolve(path: string, request: string, callback: (err: null | Error, req?: JsResourceData) => void): void
+  resolveSync(path: string, request: string): string | undefined
+  resolve(path: string, request: string, callback: (err: null | Error, req?: string) => void): void
   withOptions(raw?: RawResolveOptionsWithDependencyType | undefined | null): JsResolver
 }
 
@@ -463,7 +463,7 @@ export declare class NativeWatchResult {
 
 export declare class RawExternalItemFnCtx {
   data(): RawExternalItemFnCtxData
-  getResolver(): JsResolver
+  getResolve(options?: RawResolveOptionsWithDependencyType | undefined | null): (context: string, path: string, callback: (error?: Error, text?: string) => void) => void
 }
 
 export declare class ReadonlyResourceData {
@@ -2598,6 +2598,7 @@ export interface RawSubresourceIntegrityPluginOptions {
 }
 
 export interface RawSwcJsMinimizerOptions {
+  ecma: any
   compress: any
   mangle: any
   format: any

crates/rspack_binding_api/src/raw_options/raw_builtins/raw_swc_js_minimizer.rs

@@ -32,6 +32,7 @@ pub struct RawSwcJsMinimizerRspackPluginOptions {
 #[derive(Debug)]
 #[napi(object, object_to_js = false)]
 pub struct RawSwcJsMinimizerOptions {
+  pub ecma: serde_json::Value,
   pub compress: serde_json::Value,
   pub mangle: serde_json::Value,
   pub format: serde_json::Value,
@@ -78,6 +79,11 @@ impl TryFrom<RawSwcJsMinimizerRspackPluginOptions> for PluginOptions {
       BoolOrDataConfig<rspack_plugin_swc_js_minimizer::MangleOptions>,
     >(value.minimizer_options.mangle)?
     .or(|| BoolOrDataConfig::from_bool(true));
+
+    let ecma = try_deserialize_into::<rspack_plugin_swc_js_minimizer::TerserEcmaVersion>(
+      value.minimizer_options.ecma,
+    )?;
+
     Ok(Self {
       extract_comments: into_extract_comments(value.extract_comments),
       test: value.test.map(into_asset_conditions),
@@ -86,6 +92,7 @@ impl TryFrom<RawSwcJsMinimizerRspackPluginOptions> for PluginOptions {
       minimizer_options: MinimizerOptions {
         compress,
         mangle,
+        ecma,
         format: try_deserialize_into(value.minimizer_options.format)?,
         module: value.minimizer_options.module,
         minify: value.minimizer_options.minify,

crates/rspack_binding_api/src/raw_options/raw_external.rs

@@ -1,6 +1,9 @@
-use std::{fmt::Debug, sync::Arc};
+use std::{fmt::Debug, path::Path, sync::Arc};
 
-use napi::bindgen_prelude::{Either4, Promise};
+use napi::{
+  bindgen_prelude::{Either4, Function, FunctionCallContext, Promise},
+  Either, Env,
+};
 use napi_derive::napi;
 use rspack_core::{
   ExternalItem, ExternalItemFnCtx, ExternalItemFnResult, ExternalItemValue,
@@ -10,7 +13,10 @@ use rspack_napi::threadsafe_function::ThreadsafeFunction;
 use rspack_regex::RspackRegex;
 use rustc_hash::FxHashMap as HashMap;
 
-use crate::JsResolver;
+use crate::{
+  callbackify, normalize_raw_resolve_options_with_dependency_type, ErrorCode,
+  RawResolveOptionsWithDependencyType, ResolveRequest,
+};
 
 #[napi(object)]
 pub struct RawHttpExternalsRspackPluginOptions {
@@ -105,12 +111,74 @@ impl RawExternalItemFnCtx {
     }
   }
 
-  #[napi]
-  pub fn get_resolver(&self) -> JsResolver {
-    JsResolver::new(
-      self.resolver_factory.clone(),
-      self.resolve_options_with_dependency_type.clone(),
-    )
+  #[napi(
+    ts_return_type = "(context: string, path: string, callback: (error?: Error, text?: string) => void) => void"
+  )]
+  pub fn get_resolve<'a>(
+    &self,
+    env: &'a Env,
+    options: Option<RawResolveOptionsWithDependencyType>,
+  ) -> napi::Result<Function<'a, (String, String, Function<'static>), ()>> {
+    let first = Arc::new(self.resolve_options_with_dependency_type.clone());
+    let second = Arc::new(
+      normalize_raw_resolve_options_with_dependency_type(options, first.resolve_to_context)
+        .map_err(|e| napi::Error::from_reason(e.to_string()))?,
+    );
+    let resolver_factory = self.resolver_factory.clone();
+
+    let f: Function<(String, String, Function<'static>), ()> =
+      env.create_function_from_closure("resolve", move |ctx: FunctionCallContext| {
+        let context = ctx.get::<String>(0)?;
+        let request = ctx.get::<String>(1)?;
+        let callback = ctx.get::<Function<'static>>(2)?;
+
+        let first_clone = first.clone();
+        let second_clone = second.clone();
+        let resolver_factory = resolver_factory.clone();
+
+        callbackify(
+          callback,
+          async move {
+            let merged_resolve_options = match second_clone.resolve_options.as_ref() {
+              Some(second_resolve_options) => match first_clone.resolve_options.as_ref() {
+                Some(resolve_options) => Some(Box::new(
+                  resolve_options
+                    .clone()
+                    .merge(*second_resolve_options.clone()),
+                )),
+                None => Some(second_resolve_options.clone()),
+              },
+              None => first_clone.resolve_options.clone(),
+            };
+
+            let merged_options = ResolveOptionsWithDependencyType {
+              resolve_options: merged_resolve_options,
+              resolve_to_context: second_clone.resolve_to_context,
+              dependency_category: second_clone.dependency_category,
+            };
+            let resolver = resolver_factory.get(merged_options);
+
+            match resolver.resolve(Path::new(&context), &request).await {
+              Ok(rspack_core::ResolveResult::Resource(resource)) => {
+                let resolve_request = ResolveRequest::from(resource);
+                Ok(match serde_json::to_string(&resolve_request) {
+                  Ok(json) => Either::<String, ()>::A(json),
+                  Err(_) => Either::B(()),
+                })
+              }
+              Ok(rspack_core::ResolveResult::Ignored) => Ok(Either::B(())),
+              Err(err) => Err(napi::Error::new(
+                ErrorCode::Napi(napi::Status::GenericFailure),
+                format!("{err:?}"),
+              )),
+            }
+          },
+          None::<fn()>,
+        )
+        .map_err(|e| napi::Error::from_reason(e.reason.to_string()))
+      })?;
+
+    Ok(f)
   }
 }
 

crates/rspack_binding_api/src/resolver.rs

@@ -5,16 +5,41 @@ use napi::{
   Either,
 };
 use napi_derive::napi;
-use rspack_core::{ResolveOptionsWithDependencyType, Resolver, ResolverFactory, ResourceData};
+use rspack_core::{ResolveOptionsWithDependencyType, Resolver, ResolverFactory};
+use serde::Serialize;
 
 use crate::{
   callbackify,
   raw_resolve::{
     normalize_raw_resolve_options_with_dependency_type, RawResolveOptionsWithDependencyType,
   },
-  ErrorCode, JsResourceData,
+  ErrorCode,
 };
 
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ResolveRequest {
+  pub path: String,
+  pub query: String,
+  pub fragment: String,
+  pub description_file_data: Option<serde_json::Value>,
+  pub description_file_path: Option<String>,
+}
+
+impl From<rspack_core::Resource> for ResolveRequest {
+  fn from(value: rspack_core::Resource) -> Self {
+    let (description_file_path, description_file_data) =
+      value.description_data.map(|data| data.into_parts()).unzip();
+    Self {
+      path: value.path.to_string(),
+      query: value.query,
+      fragment: value.fragment,
+      description_file_data: description_file_data.map(std::sync::Arc::unwrap_or_clone),
+      description_file_path: description_file_path.map(|path| path.to_string_lossy().into_owned()),
+    }
+  }
+}
+
 #[napi]
 #[derive(Debug)]
 pub struct JsResolver {
@@ -38,31 +63,21 @@ impl JsResolver {
 }
 #[napi]
 impl JsResolver {
-  #[napi(ts_return_type = "JsResourceData | false")]
-  pub fn resolve_sync(
-    &self,
-    path: String,
-    request: String,
-  ) -> napi::Result<Either<JsResourceData, bool>> {
-    block_on(self._resolve(path, request))
-  }
-
-  async fn _resolve(
-    &self,
-    path: String,
-    request: String,
-  ) -> napi::Result<Either<JsResourceData, bool>> {
-    match self.resolver.resolve(Path::new(&path), &request).await {
-      Ok(rspack_core::ResolveResult::Resource(resource)) => {
-        Ok(Either::A(ResourceData::from(resource).into()))
+  #[napi]
+  pub fn resolve_sync(&self, path: String, request: String) -> napi::Result<Either<String, ()>> {
+    block_on(async {
+      match self.resolver.resolve(Path::new(&path), &request).await {
+        Ok(rspack_core::ResolveResult::Resource(resource)) => {
+          Ok(Either::A(resource.path.to_string()))
+        }
+        Ok(rspack_core::ResolveResult::Ignored) => Ok(Either::B(())),
+        Err(err) => Err(napi::Error::from_reason(format!("{err:?}"))),
       }
-      Ok(rspack_core::ResolveResult::Ignored) => Ok(Either::B(false)),
-      Err(err) => Err(napi::Error::from_reason(format!("{err:?}"))),
-    }
+    })
   }
 
   #[napi(
-    ts_args_type = "path: string, request: string, callback: (err: null | Error, req?: JsResourceData) => void"
+    ts_args_type = "path: string, request: string, callback: (err: null | Error, req?: string) => void"
   )]
   pub fn resolve(
     &self,
@@ -75,10 +90,14 @@ impl JsResolver {
       f,
       async move {
         match resolver.resolve(Path::new(&path), &request).await {
-          Ok(rspack_core::ResolveResult::Resource(resource)) => Ok(
-            Either::<JsResourceData, bool>::A(ResourceData::from(resource).into()),
-          ),
-          Ok(rspack_core::ResolveResult::Ignored) => Ok(Either::B(false)),
+          Ok(rspack_core::ResolveResult::Resource(resource)) => {
+            let resolve_request = ResolveRequest::from(resource);
+            Ok(match serde_json::to_string(&resolve_request) {
+              Ok(json) => Either::<String, ()>::A(json),
+              Err(_) => Either::B(()),
+            })
+          }
+          Ok(rspack_core::ResolveResult::Ignored) => Ok(Either::B(())),
           Err(err) => Err(napi::Error::new(
             ErrorCode::Napi(napi::Status::GenericFailure),
             format!("{err:?}"),

crates/rspack_loader_swc/Cargo.toml

@@ -33,7 +33,7 @@ serde                          = { workspace = true, features = ["derive"] }
 serde_json                     = { workspace = true }
 swc                            = { workspace = true, features = ["manual-tokio-runtime"] }
 swc_config                     = { workspace = true }
-swc_core                       = { workspace = true, features = ["base", "ecma_ast", "common", "ecma_preset_env"] }
+swc_core                       = { workspace = true, features = ["base", "ecma_ast", "common", "ecma_preset_env", "ecma_helpers_inline"] }
 tokio                          = { workspace = true }
 tracing                        = { workspace = true }
 

crates/rspack_plugin_circular_dependencies/src/lib.rs

@@ -268,6 +268,7 @@ impl CircularDependencyRspackPlugin {
     &self,
     module_map: &IdentifierMap<GraphModule>,
     cycle: &[ModuleIdentifier],
+    compilation: &Compilation,
   ) -> bool {
     for [module_id, target_id] in cycle.array_windows::<2>() {
       // If any dependency in the cycle is purely asynchronous, then it does not count as a runtime
@@ -276,9 +277,18 @@ impl CircularDependencyRspackPlugin {
         return true;
       }
 
+      let Some(module) = compilation
+        .module_by_identifier(module_id)
+        .and_then(|m| m.as_normal_module())
+      else {
+        continue;
+      };
+
       // Not all cycles are errors, so filter out any cycles containing
       // explicitly-ignored modules.
-      if self.is_ignored_module(module_id) || self.is_ignored_connection(module_id, target_id) {
+      if self.is_ignored_module(module.resource_resolved_data().resource.as_str())
+        || self.is_ignored_connection(module_id, target_id)
+      {
         return true;
       }
     }
@@ -374,7 +384,7 @@ async fn optimize_modules(&self, compilation: &mut Compilation) -> Result<Option
       };
 
       for cycle in detector.find_cycles_from(module_id) {
-        if self.is_cycle_ignored(&module_map, &cycle) {
+        if self.is_cycle_ignored(&module_map, &cycle, compilation) {
           self
             .handle_cycle_ignored(entrypoint_name.clone(), cycle, compilation)
             .await?

crates/rspack_plugin_javascript/src/parser_and_generator/mod.rs

@@ -44,9 +44,6 @@ pub struct JavaScriptParserAndGenerator {
   // TODO
   #[cacheable(with=Skip)]
   parser_plugins: Vec<BoxJavascriptParserPlugin>,
-  // TODO
-  #[cacheable(with=Skip)]
-  parser_pre_plugins: Vec<BoxJavascriptParserPlugin>,
 }
 
 impl std::fmt::Debug for JavaScriptParserAndGenerator {
@@ -63,10 +60,6 @@ impl JavaScriptParserAndGenerator {
     self.parser_plugins.push(parser_plugin);
   }
 
-  pub fn add_parser_pre_plugin(&mut self, parser_plugin: BoxJavascriptParserPlugin) {
-    self.parser_pre_plugins.push(parser_plugin);
-  }
-
   fn source_block(
     &self,
     compilation: &Compilation,
@@ -144,7 +137,6 @@ impl ParserAndGenerator for JavaScriptParserAndGenerator {
       module_identifier,
       loaders,
       module_parser_options,
-      additional_data,
       mut parse_meta,
       ..
     } = parse_context;
@@ -269,8 +261,6 @@ impl ParserAndGenerator for JavaScriptParserAndGenerator {
         &mut semicolons,
         unresolved_mark,
         &mut self.parser_plugins,
-        &mut self.parser_pre_plugins,
-        additional_data,
         parse_meta,
       )
     }) {

crates/rspack_plugin_javascript/src/parser_plugin/common_js_exports_parse_plugin.rs

@@ -224,9 +224,6 @@ impl JavascriptParser<'_> {
   }
 
   fn is_this_member_expr_start<E: ExprLike>(&self, expr: &E) -> bool {
-    if self.enter_call != 0 {
-      return false;
-    }
     fn walk_each<E: ExprLike>(parser: &JavascriptParser, expr: &E) -> bool {
       if parser.is_top_level_this_expr(expr) {
         true