rspack_plugin_javascript 0.103.0-rc.0

rspack javascript plugin
Documentation
use std::sync::LazyLock;

use rspack_core::DependencyRange;
use rspack_error::{Diagnostic, Error, Severity};
use rspack_regex::RspackRegex;
use rspack_util::{SpanExt, swc::AstSubRangeExt};
use swc_next_ecma_ast::{Ast, CallExpression, Expr, ExprData, GetSpan, MemberExpression};

use super::JavascriptParser;
use crate::Atom;

static DEFAULT_CONTEXT_REGEXP: LazyLock<RspackRegex> =
  LazyLock::new(|| RspackRegex::new(r"^\.\/.*$").expect("reg failed"));

pub mod expr_name {
  pub const MODULE: &str = "module";
  pub const MODULE_HOT: &str = "module.hot";
  pub const MODULE_HOT_ACCEPT: &str = "module.hot.accept";
  pub const MODULE_HOT_DECLINE: &str = "module.hot.decline";
  pub const MODULE_REQUIRE: &str = "module.require";
  pub const REQUIRE: &str = "require";
  pub const REQUIRE_RESOLVE: &str = "require.resolve";
  pub const REQUIRE_RESOLVE_WEAK: &str = "require.resolveWeak";
  pub const IMPORT_META_PREFIX: &str = "import.meta.";
  pub const IMPORT_META: &str = "import.meta";
  pub const IMPORT_META_FILENAME: &str = "import.meta.filename";
  pub const IMPORT_META_DIRNAME: &str = "import.meta.dirname";
  pub const IMPORT_META_URL: &str = "import.meta.url";
  pub const IMPORT_META_RESOLVE: &str = "import.meta.resolve";
  pub const IMPORT_META_VERSION: &str = "import.meta.webpack";
  pub const IMPORT_META_MAIN: &str = "import.meta.main";
  pub const IMPORT_META_RSPACK_RSC: &str = "import.meta.rspackRsc";
  pub const IMPORT_META_HOT: &str = "import.meta.webpackHot";
  pub const IMPORT_META_HOT_ACCEPT: &str = "import.meta.webpackHot.accept";
  pub const IMPORT_META_HOT_DECLINE: &str = "import.meta.webpackHot.decline";
  pub const IMPORT_META_CONTEXT: &str = "import.meta.webpackContext";
  pub const IMPORT_META_GLOB: &str = "import.meta.glob";
}

pub fn parse_order_string(x: &str) -> Option<i32> {
  match x {
    "true" => Some(0),
    "false" => None,
    _ => x.parse::<i32>().ok(),
  }
}

pub fn static_string_from_expr(ast: &Ast<'_>, expr: Expr) -> Option<String> {
  match ast.expr_data(expr) {
    ExprData::StringLiteral(string) => Some(
      ast
        .get_wtf8(string.value(ast))
        .to_string_lossy()
        .into_owned(),
    ),
    ExprData::TemplateLiteral(template)
      if template.expressions(ast).is_empty() && template.quasis(ast).len() == 1 =>
    {
      let element = ast.first(template.quasis(ast))?;
      Some(ast.get_utf8(element.raw(ast)).to_string())
    }
    _ => None,
  }
}

/// Range from the end of the sole argument to the end of the call, to be
/// replaced by a bare `)`. Replacing a `resolve` callee with a comment turns the
/// argument list into a parenthesized expression, where a trailing comma is a
/// syntax error.
pub fn resolve_call_trailing_comma_range(
  parser: &JavascriptParser,
  call_expr: CallExpression,
) -> Option<DependencyRange> {
  let ast = parser.ast.ast;
  let argument = ast.nodes(call_expr.arguments(ast)).next_back()?;
  let start = argument.span(ast).real_hi();
  let end = call_expr.span(ast).real_hi();
  let tail = parser.source().get(start as usize..end as usize)?;

  // There is exactly one argument, so any comma here is the trailing one or
  // sits inside a comment that is fine to drop along with it.
  tail.contains(',').then(|| DependencyRange::new(start, end))
}

pub fn create_traceable_error(
  title: String,
  message: String,
  source: String,
  span: DependencyRange,
) -> Error {
  Error::from_string(
    Some(source),
    span.start as usize,
    span.end as usize,
    title,
    message,
  )
}

#[inline]
pub fn default_context_reg_exp() -> RspackRegex {
  DEFAULT_CONTEXT_REGEXP.clone()
}

pub fn context_reg_exp(
  expr: &str,
  flags: &str,
  error_span: Option<DependencyRange>,
  parser: &mut JavascriptParser,
) -> Option<RspackRegex> {
  if expr.is_empty() {
    return None;
  }
  let regexp = RspackRegex::with_flags(expr, flags).expect("reg failed");
  clean_regexp_in_context_module(regexp, error_span, parser)
}

pub fn clean_regexp_in_context_module(
  regexp: RspackRegex,
  error_span: Option<DependencyRange>,
  parser: &mut JavascriptParser,
) -> Option<RspackRegex> {
  if regexp.sticky() || regexp.global() {
    if let Some(error_span) = error_span {
      let mut error = create_traceable_error(
        "Critical dependency".into(),
        "Contexts can't use RegExps with the 'g' or 'y' flags".to_string(),
        parser.source.to_string(),
        error_span,
      );
      error.severity = Severity::Warning;
      parser.add_warning(Diagnostic::from(error));
    } else {
      let mut err = Error::warning("Contexts can't use RegExps with the 'g' or 'y' flags".into());
      err.code = Some("Critical dependency".into());
      parser.add_warning(err.into());
    }
    None
  } else {
    Some(regexp)
  }
}

pub fn get_non_optional_part<'a>(members: &'a [Atom], members_optionals: &[bool]) -> &'a [Atom] {
  let mut i = 0;
  while i < members.len() && matches!(members_optionals.get(i), Some(false)) {
    i += 1;
  }
  if i != members.len() {
    &members[0..i]
  } else {
    members
  }
}

pub fn get_non_optional_member_chain_from_expr(
  ast: &Ast<'_>,
  mut expr: Expr,
  mut count: i32,
) -> Expr {
  while count != 0 {
    if let Some(member) = expr.as_member_expression(ast) {
      expr = member.object(ast);
      count -= 1;
    } else if let Some(chain) = expr.as_chain_expression(ast) {
      let expression = chain.expression(ast);
      expr = if let Some(member) = expression.as_member_expression(ast) {
        member.object(ast)
      } else if let Some(call) = expression.as_call_expression(ast)
        && let Some(member) = call.callee(ast).as_member_expression(ast)
      {
        member.object(ast)
      } else {
        unreachable!()
      };
      count -= 1;
    } else {
      unreachable!()
    }
  }
  expr
}

pub fn get_non_optional_member_chain_from_member(
  ast: &Ast<'_>,
  member: MemberExpression,
  mut count: i32,
) -> Expr {
  count -= 1;
  get_non_optional_member_chain_from_expr(ast, member.object(ast), count)
}