crates/core/tests/webpack5_chunk_unpack.rs

GitHub
use wakaru_core::{unpack, unpack_raw, DecompileOptions};

fn expect_unpack(source: &str, filename: &str) -> Vec<(String, String)> {
    let output = unpack(
        source,
        DecompileOptions {
            filename: filename.to_string(),
            ..Default::default()
        },
    )
    .expect("unpack should succeed");
    assert!(
        !output.has_errors(),
        "unexpected warnings: {:?}",
        output.warnings
    );
    output.modules
}

fn expect_heuristic_unpack_raw(source: &str, filename: &str) -> Vec<(String, String)> {
    let output = unpack_raw(
        source,
        &DecompileOptions {
            filename: filename.to_string(),
            heuristic_split: true,
            ..Default::default()
        },
    )
    .expect("raw unpack should succeed");
    assert!(
        !output.has_errors(),
        "unexpected warnings: {:?}",
        output.warnings
    );
    output.modules
}

#[test]
fn webpack5_chunk_rewrites_numeric_require() {
    // When modules within the same chunk reference each other by numeric ID,
    // require(N) should become require("./module-N.js") so un_esm can convert to import.
    let source = r#"
(self.webpackChunk_N_E = self.webpackChunk_N_E || []).push([
  [0],
  {
    100: function(module, exports, require) {
      "use strict";
      require.r(exports);
      require.d(exports, {
        helper: function() { return helper; }
      });
      function helper() { return 42; }
    },
    200: function(module, exports, require) {
      "use strict";
      require.r(exports);
      var h = require(100);
      exports.default = h.helper();
    }
  }
]);
"#;

    let pairs = expect_unpack(source, "chunk.js");

    let mod_200 = pairs
        .iter()
        .find(|(name, _)| name == "module-200.js")
        .expect("module-200.js should exist");

    // require(100) should be rewritten to an import from ./module-100.js
    assert!(
        !mod_200.1.contains("require(100)"),
        "module-200 should not have raw require(100), got:\n{}",
        mod_200.1
    );
    assert!(
        mod_200.1.contains("./module-100.js"),
        "module-200 should reference ./module-100.js, got:\n{}",
        mod_200.1
    );
}

#[test]
fn webpack5_chunk_heuristic_skips_scope_split_without_import_bearing_entry() {
    let source = r#"
(self.webpackChunk_N_E = self.webpackChunk_N_E || []).push([
  [0],
    {
    100: function(module, exports, require) {
      "use strict";
      var external = require(200);
      function helperA1() { return external.value; }
      function helperA2() { return helperA1() + 1; }
      function helperA3() { return helperA2() * 2; }
      function helperA4() { return helperA3() + 3; }
      function publicA() { return helperA4(); }

      function helperB1() { return 10; }
      function helperB2() { return helperB1() + 10; }
      function helperB3() { return helperB2() * 20; }
      function helperB4() { return helperB3() + 30; }
      function publicB() { return helperB4(); }

      require.r(exports);
      require.d(exports, {
        publicA: function() { return publicA; },
        publicB: function() { return publicB; }
      });
    },
    200: function(module, exports, require) {
      "use strict";
      exports.value = 40;
    }
  }
]);
"#;

    let pairs = expect_heuristic_unpack_raw(source, "chunk.js");
    let filenames: Vec<&str> = pairs.iter().map(|(name, _)| name.as_str()).collect();

    assert_eq!(
        filenames,
        vec!["module-100.js", "module-200.js"],
        "unsafe scope split should be rejected until the entry imports recovered chunks"
    );
}

#[test]
fn webpack5_chunk_unpacks_modules() {
    let source = r#"
(self.webpackChunk_N_E = self.webpackChunk_N_E || []).push([
  [123],
  {
    11111: function(module, exports, require) {
      "use strict";
      require.r(exports);
      require.d(exports, {
        M: function() { return i; },
        u: function() { return o; }
      });
      var o = 1;
      var i = 2;
    },
    22222: function(module, exports, require) {
      "use strict";
      require.r(exports);
      require.d(exports, {
        Z: function() { return s; }
      });
      function s() { return 0; }
    }
  }
]);
"#;

    let pairs = expect_unpack(source, "chunk.js");

    assert_eq!(
        pairs.len(),
        2,
        "expected 2 modules, got {:?}",
        pairs.iter().map(|(name, _)| name).collect::<Vec<_>>()
    );

    // Check module IDs are used as filenames
    let filenames: Vec<&str> = pairs.iter().map(|(name, _)| name.as_str()).collect();
    assert!(
        filenames.contains(&"module-11111.js"),
        "expected module-11111.js, got {:?}",
        filenames
    );
    assert!(
        filenames.contains(&"module-22222.js"),
        "expected module-22222.js, got {:?}",
        filenames
    );

    // Check that require.r and require.d were normalized
    for (name, code) in &pairs {
        assert!(
            !code.contains("require.r("),
            "module {name} still has require.r"
        );
        assert!(
            !code.contains("require.d("),
            "module {name} still has require.d"
        );
    }
}

#[test]
fn webpack5_chunk_unpacks_arrow_and_method_factories() {
    let source = r#"
(self.webpackChunk_N_E = self.webpackChunk_N_E || []).push([
  [7],
  {
    100: (module, exports, require) => {
      "use strict";
      var dep = require(200);
      exports.default = dep.value;
    },
    200(module, exports, require) {
      "use strict";
      exports.value = 42;
    }
  }
]);
"#;

    let pairs = expect_unpack(source, "chunk.js");

    assert_eq!(pairs.len(), 2);
    let mod_100 = pairs
        .iter()
        .find(|(name, _)| name == "module-100.js")
        .expect("module-100.js should exist");
    assert!(
        mod_100.1.contains("./module-200.js"),
        "numeric require should be rewritten for arrow factory:\n{}",
        mod_100.1
    );
    assert!(
        pairs.iter().any(|(name, _)| name == "module-200.js"),
        "method factory module should be emitted"
    );
}

#[test]
fn webpack5_chunk_rewrites_numeric_require_in_method_factory() {
    let source = r#"
(self.webpackChunk_N_E = self.webpackChunk_N_E || []).push([
  [7],
  {
    100(module, exports, require) {
      "use strict";
      var dep = require(200);
      exports.default = dep.value;
    },
    200(module, exports, require) {
      "use strict";
      exports.value = 42;
    }
  }
]);
"#;

    let pairs = expect_unpack(source, "chunk.js");

    assert_eq!(pairs.len(), 2);
    let mod_100 = pairs
        .iter()
        .find(|(name, _)| name == "module-100.js")
        .expect("module-100.js should exist");
    assert!(
        !mod_100.1.contains("require(200)"),
        "raw numeric require should not remain in method factory:\n{}",
        mod_100.1
    );
    assert!(
        mod_100.1.contains("./module-200.js"),
        "numeric require should be rewritten for method factory:\n{}",
        mod_100.1
    );
}

#[test]
fn webpack5_chunk_with_string_keys() {
    let source = r#"
(self.webpackChunk_N_E = self.webpackChunk_N_E || []).push([
  [123],
  {
    "68494": function(U, B, G) {
      "use strict";
      G.r(B);
      G.d(B, {
        "default": function() { return V; }
      });
      function V() { return 42; }
    }
  }
]);
"#;

    let pairs = expect_unpack(source, "chunk.js");

    assert_eq!(pairs.len(), 1);
    assert!(
        !pairs[0].1.contains("G.r("),
        "require.r should be normalized"
    );
    assert!(
        !pairs[0].1.contains("G.d("),
        "require.d should be normalized"
    );
}

#[test]
fn webpack5_chunk_with_webpack4_style_require_d() {
    // Chunks can use webpack4-style require.d(exports, "name", getter)
    let source = r#"
(self.webpackChunk_N_E = self.webpackChunk_N_E || []).push([
  [1],
  {
    100: function(module, exports, require) {
      "use strict";
      require.r(exports);
      require.d(exports, "foo", function() { return bar; });
      var bar = 42;
    }
  }
]);
"#;

    let pairs = expect_unpack(source, "chunk.js");

    assert_eq!(pairs.len(), 1);
    assert!(
        !pairs[0].1.contains("require.d("),
        "require.d should be normalized"
    );
}

#[test]
fn webpack5_chunk_with_window_base() {
    let source = r#"
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([
  [0],
  {
    10: function(module, exports, require) {
      "use strict";
      require.r(exports);
      exports.default = "hello";
    }
  }
]);
"#;

    let pairs = expect_unpack(source, "chunk.js");

    assert_eq!(pairs.len(), 1);
}