crates/core/tests/un_webpack_interop_rule.rs

GitHub
mod common;

use common::{assert_eq_normalized, render_pipeline, render_rule};
use wakaru_core::rules::UnWebpackInterop;

/// Render applying only UnWebpackInterop in isolation.
fn render(input: &str) -> String {
    render_rule(input, UnWebpackInterop::new)
}

// ── Ternary (expression) form ──────────────────────────────────────

#[test]
fn ternary_getter_call_inlined() {
    let input = r#"
var _lib = require("./lib");
var _lib2 = () => _lib && _lib.__esModule ? _lib.default : _lib;
console.log(_lib2());
"#;
    let expected = r#"
var _lib = require("./lib");
console.log(_lib);
"#;
    assert_eq_normalized(&render(input), expected.trim());
}

#[test]
fn ternary_getter_dot_a_inlined() {
    let input = r#"
var _lib = require("./lib");
var _lib2 = () => _lib && _lib.__esModule ? _lib.default : _lib;
console.log(_lib2.a);
"#;
    let expected = r#"
var _lib = require("./lib");
console.log(_lib);
"#;
    assert_eq_normalized(&render(input), expected.trim());
}

// ── Block-statement (if/return) form ───────────────────────────────

#[test]
fn block_getter_call_inlined() {
    let input = r#"
var _lib = require("./lib");
var _lib2 = () => { if (_lib && _lib.__esModule) { return _lib.default; } return _lib; };
console.log(_lib2());
"#;
    let expected = r#"
var _lib = require("./lib");
console.log(_lib);
"#;
    assert_eq_normalized(&render(input), expected.trim());
}

#[test]
fn block_getter_dot_a_inlined() {
    let input = r#"
var _lib = require("./lib");
var _lib2 = () => { if (_lib && _lib.__esModule) { return _lib.default; } return _lib; };
console.log(_lib2.a);
"#;
    let expected = r#"
var _lib = require("./lib");
console.log(_lib);
"#;
    assert_eq_normalized(&render(input), expected.trim());
}

// ── Multiple getters ───────────────────────────────────────────────

#[test]
fn multiple_getters_all_inlined() {
    let input = r#"
var _a = require("./a");
var _b = require("./b");
var _a2 = () => _a && _a.__esModule ? _a.default : _a;
var _b2 = () => _b && _b.__esModule ? _b.default : _b;
console.log(_a2(), _b2());
"#;
    let expected = r#"
var _a = require("./a");
var _b = require("./b");
console.log(_a, _b);
"#;
    assert_eq_normalized(&render(input), expected.trim());
}

// ── Unsafe usages → getter is kept ─────────────────────────────────

#[test]
fn getter_called_with_args_not_inlined() {
    let input = r#"
var _lib = require("./lib");
var _lib2 = () => _lib && _lib.__esModule ? _lib.default : _lib;
console.log(_lib2("unexpected"));
"#;
    let output = render(input);
    insta::assert_snapshot!(output);
}

#[test]
fn getter_used_as_value_not_inlined() {
    let input = r#"
var _lib = require("./lib");
var _lib2 = () => _lib && _lib.__esModule ? _lib.default : _lib;
var ref = _lib2;
"#;
    let output = render(input);
    insta::assert_snapshot!(output);
}

#[test]
fn getter_member_not_dot_a_not_inlined() {
    let input = r#"
var _lib = require("./lib");
var _lib2 = () => _lib && _lib.__esModule ? _lib.default : _lib;
console.log(_lib2.b);
"#;
    let output = render(input);
    insta::assert_snapshot!(output);
}

// ── Non-require base → no match ────────────────────────────────────

#[test]
fn non_require_base_not_matched() {
    let input = r#"
var _lib = someOtherCall();
var _lib2 = () => _lib && _lib.__esModule ? _lib.default : _lib;
console.log(_lib2());
"#;
    let output = render(input);
    insta::assert_snapshot!(output);
}

// ── Mixed safe and unsafe usage → getter is kept ───────────────────

#[test]
fn mixed_usage_not_inlined() {
    let input = r#"
var _lib = require("./lib");
var _lib2 = () => _lib && _lib.__esModule ? _lib.default : _lib;
console.log(_lib2());
var ref = _lib2;
"#;
    let output = render(input);
    insta::assert_snapshot!(output);
}

// ── Computed property access forms ─────────────────────────────────

#[test]
fn computed_esmodule_access() {
    let input = r#"
var _lib = require("./lib");
var _lib2 = () => _lib && _lib["__esModule"] ? _lib["default"] : _lib;
console.log(_lib2());
"#;
    let expected = r#"
var _lib = require("./lib");
console.log(_lib);
"#;
    assert_eq_normalized(&render(input), expected.trim());
}

#[test]
fn computed_dot_a_access() {
    let input = r#"
var _lib = require("./lib");
var _lib2 = () => _lib && _lib.__esModule ? _lib.default : _lib;
console.log(_lib2["a"]);
"#;
    let expected = r#"
var _lib = require("./lib");
console.log(_lib);
"#;
    assert_eq_normalized(&render(input), expected.trim());
}

// ── Direct webpack require.n helper form ───────────────────────────

#[test]
fn direct_require_n_getter_call_inlined_for_require_binding() {
    let input = r#"
var _lib = require("./lib");
var _lib2 = require.n(_lib);
console.log(_lib2().method());
"#;
    let expected = r#"
var _lib = require("./lib");
console.log(_lib.method());
"#;
    assert_eq_normalized(&render(input), expected.trim());
}

#[test]
fn direct_require_n_getter_call_inlined_for_import_binding() {
    let input = r#"
import _lib from "./lib";
const _lib2 = require.n(_lib);
console.log(_lib2()().astSync(source));
"#;
    let expected = r#"
import _lib from "./lib";
console.log(_lib().astSync(source));
"#;
    assert_eq_normalized(&render(input), expected.trim());
}

#[test]
fn direct_require_n_getter_dot_a_inlined() {
    let input = r#"
import _lib from "./lib";
const _lib2 = require.n(_lib);
console.log(_lib2.a);
"#;
    let expected = r#"
import _lib from "./lib";
console.log(_lib);
"#;
    assert_eq_normalized(&render(input), expected.trim());
}

#[test]
fn direct_require_n_getter_used_as_value_not_inlined() {
    let input = r#"
import _lib from "./lib";
const _lib2 = require.n(_lib);
const ref = _lib2;
"#;
    let output = render(input);
    insta::assert_snapshot!(output);
}

#[test]
fn pipeline_inlines_direct_require_n_after_esm_imports_exist() {
    let input = r#"
import _lib from "./lib";
const _lib2 = require.n(_lib);
console.log(_lib2()().astSync(source));
"#;
    let expected = r#"
import _lib from "./lib";
console.log(_lib().astSync(source));
"#;
    assert_eq_normalized(&render_pipeline(input), expected.trim());
}

// ── Webpack require.t namespace helper form ────────────────────────

#[test]
fn require_t_mode_2_named_property_read_uses_module_binding() {
    let input = r#"
const react = require("./react");
let useId = require.t(react, 2).useId || (() => undefined);
"#;
    let expected = r#"
const react = require("./react");
let useId = react.useId || (() => undefined);
"#;
    assert_eq_normalized(&render(input), expected.trim());
}

#[test]
fn require_t_mode_2_cached_namespace_property_read_uses_module_binding() {
    let input = r#"
let ns;
const react = require("./react");
let useId = (ns || (ns = require.t(react, 2)))["useId".toString()] || (() => undefined);
"#;
    let expected = r#"
const react = require("./react");
let useId = react["useId".toString()] || (() => undefined);
"#;
    assert_eq_normalized(&render(input), expected.trim());
}

#[test]
fn require_t_cached_namespace_with_later_cache_use_not_inlined() {
    let input = r#"
let ns;
const react = require("./react");
let useId = (ns || (ns = require.t(react, 2))).useId;
console.log(ns);
"#;
    let output = render(input);
    insta::assert_snapshot!(output);
}

#[test]
fn require_t_mode_2_default_property_read_returns_module_binding() {
    let input = r#"
const lib = require("./lib");
let value = require.t(lib, 2).default;
"#;
    let expected = r#"
const lib = require("./lib");
let value = lib;
"#;
    assert_eq_normalized(&render(input), expected.trim());
}

#[test]
fn require_t_dynamic_property_read_not_inlined() {
    let input = r#"
const react = require("./react");
let useId = require.t(react, 2)[name];
"#;
    let output = render(input);
    insta::assert_snapshot!(output);
}

#[test]
fn require_t_non_mode_2_not_inlined() {
    let input = r#"
const lib = require("./lib");
let value = require.t(lib, 19).default;
"#;
    let output = render(input);
    insta::assert_snapshot!(output);
}

// ── Webpack require.o hasOwnProperty helper form ───────────────────

#[test]
fn require_o_rewrites_to_has_own_property_call() {
    let input = r#"
if (!require.o(map, request)) {
  throw new Error("missing");
}
"#;
    let expected = r#"
if (!Object.prototype.hasOwnProperty.call(map, request)) {
  throw new Error("missing");
}
"#;
    assert_eq_normalized(&render(input), expected.trim());
}

#[test]
fn require_o_with_spread_arg_not_rewritten() {
    let input = r#"
const ok = require.o(map, ...keys);
"#;
    let output = render(input);
    insta::assert_snapshot!(output);
}

#[test]
fn shadowed_require_o_not_rewritten() {
    let input = r#"
function outer(require) {
  return require.o(map, request);
}
"#;
    assert_eq_normalized(&render(input), input);
}

// ── No require bindings → rule is a no-op ──────────────────────────

#[test]
fn no_require_bindings_noop() {
    let input = r#"
var _lib = import("./lib");
var _lib2 = () => _lib && _lib.__esModule ? _lib.default : _lib;
console.log(_lib2());
"#;
    let output = render(input);
    insta::assert_snapshot!(output);
}

#[test]
fn shadowed_require_binding_not_matched() {
    let input = r#"
function outer(require) {
  var _lib = require("./lib");
  var _lib2 = () => _lib && _lib.__esModule ? _lib.default : _lib;
  console.log(_lib2());
}
"#;
    assert_eq_normalized(&render(input), input);
}

#[test]
fn getter_replacement_avoids_inner_shadowing() {
    let input = r#"
var r = require("./path-to-regexp");
var o = () => r && r.__esModule ? r.default : r;
var holder = { r };
function compile(pattern, options) {
  var r = {};
  return [holder, o()(pattern, [], options)];
}
"#;
    let expected = r#"
var _r = require("./path-to-regexp");
var holder = {
  r: _r
};
function compile(pattern, options) {
  var r = {};
  return [holder, _r(pattern, [], options)];
}
"#;
    assert_eq_normalized(&render(input), expected.trim());
}

#[test]
fn getter_replacement_avoids_later_scope_shadowing() {
    let input = r#"
var r = require("./path-to-regexp");
var o = () => r && r.__esModule ? r.default : r;
function compile(pattern, options) {
  const result = o()(pattern, [], options);
  var r = {};
  return result;
}
"#;
    let expected = r#"
var _r = require("./path-to-regexp");
function compile(pattern, options) {
  const result = _r(pattern, [], options);
  var r = {};
  return result;
}
"#;
    assert_eq_normalized(&render(input), expected.trim());
}

#[test]
fn getter_replacement_avoids_catch_param_shadowing() {
    let input = r#"
var r = require("./path-to-regexp");
var o = () => r && r.__esModule ? r.default : r;
function compile() {
  try {
    return null;
  } catch (r) {
    return o();
  }
}
"#;
    let expected = r#"
var _r = require("./path-to-regexp");
function compile() {
  try {
    return null;
  } catch (r) {
    return _r;
  }
}
"#;
    assert_eq_normalized(&render(input), expected.trim());
}

#[test]
fn getter_replacement_avoids_block_scope_shadowing() {
    let input = r#"
var r = require("./path-to-regexp");
var o = () => r && r.__esModule ? r.default : r;
{
  let r = {};
  console.log(o());
}
"#;
    let expected = r#"
var _r = require("./path-to-regexp");
{
  let r = {};
  console.log(_r);
}
"#;
    assert_eq_normalized(&render(input), expected.trim());
}