scripts/repro/amd-umd-unpack-matrix/matrix.mjs

GitHub
#!/usr/bin/env node

import { mkdtempSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from "node:fs";
import { tmpdir } from "node:os";
import { basename, join, relative, resolve } from "node:path";
import { spawnSync } from "node:child_process";
import { fileURLToPath } from "node:url";

import { ensureNodeTool } from "../lib/runner.mjs";

const repoRoot = resolve(fileURLToPath(new URL("../../..", import.meta.url)));

const cases = [
  {
    name: "requirejs-optimizer-named-defines",
    tool: "requirejs",
    build: buildRequireJsOptimizer,
    expectedFiles: ["utils/math.js", "app/main.js"],
    expectedNeedles: [
      { file: "app/main.js", text: 'import math from "../utils/math.js";' },
      { file: "app/main.js", text: "console.log(math.add(1, 2));" },
    ],
    rejectedNeedles: [
      { file: "app/main.js", text: "define(" },
      { file: "utils/math.js", text: "define(" },
    ],
  },
  {
    name: "rollup-amd-named-define",
    tool: "rollup",
    build: (dir) => buildRollup(dir, "amd"),
    expectedFiles: ["math-lib.js"],
    expectedNeedles: [
      { file: "math-lib.js", text: "function add(a, b)" },
      { file: "math-lib.js", text: "console.log(add(1, 2));" },
    ],
    rejectedNeedles: [{ file: "math-lib.js", text: "define(" }],
  },
  {
    name: "rollup-amd-anonymous-external",
    tool: "rollup",
    build: buildRollupAnonymousExternal,
    expectedFiles: ["module.js"],
    expectedNeedles: [
      { file: "module.js", text: 'from "math-lib"' },
      { file: "module.js", text: "console.log(total);" },
    ],
    rejectedNeedles: [{ file: "module.js", text: "define(" }],
  },
  {
    name: "rollup-umd-wrapper",
    tool: "rollup",
    build: (dir) => buildRollup(dir, "umd"),
    expectedFiles: ["module.js"],
    expectedNeedles: [
      { file: "module.js", text: "function add(a, b)" },
      { file: "module.js", text: "console.log(add(1, 2));" },
    ],
    rejectedNeedles: [{ file: "module.js", text: "factory" }],
  },
];

const showDetails = process.argv.includes("--details");
const tmpRoot = mkdtempSync(join(tmpdir(), "wakaru-amd-umd-unpack-"));
const failures = [];

try {
  console.log("# AMD and UMD unpack reproduction matrix");
  console.log(`# wakaru: ${wakaruDescription()}`);
  console.log("");
  console.log("| case | tool | unpacked | recovered | notes |");
  console.log("|---|---|---:|---:|---|");

  for (const testCase of cases) {
    const caseDir = join(tmpRoot, testCase.name);
    mkdirSync(caseDir, { recursive: true });

    try {
      const input = testCase.build(caseDir);
      const outputDir = join(caseDir, "out");
      runWakaruUnpack(input, outputDir);
      const modules = collectModules(outputDir);
      const result = checkCase(testCase, modules);
      if (!result.recovered) {
        failures.push({ testCase, input: readFileSync(input, "utf8"), modules, notes: result.notes });
      }
      console.log(
        `| ${testCase.name} | ${testCase.tool} | ${modules.length} | ${
          result.recovered ? "yes" : "no"
        } | ${escapeCell(result.notes)} |`,
      );
    } catch (error) {
      failures.push({ testCase, error });
      console.log(`| ${testCase.name} | ${testCase.tool} | 0 | no | ${escapeCell(error.message)} |`);
    }
  }

  if (showDetails && failures.length > 0) {
    console.log("");
    console.log("## Failure Details");
    for (const failure of failures) {
      console.log("");
      console.log(`### ${failure.testCase.name}`);
      if (failure.error) {
        console.log(failure.error.stack ?? failure.error.message);
        continue;
      }
      console.log("");
      console.log("Input:");
      console.log("```js");
      console.log(failure.input.trim());
      console.log("```");
      for (const [name, code] of failure.modules) {
        console.log("");
        console.log(`Output ${name}:`);
        console.log("```js");
        console.log(code.trim());
        console.log("```");
      }
    }
  }
} finally {
  rmSync(tmpRoot, { recursive: true, force: true });
}

if (failures.length > 0) {
  process.exit(1);
}

function buildRequireJsOptimizer(dir) {
  const toolDir = ensureNodeTool("requirejs-2.3", ["requirejs@2.3.7"]);
  const sourceRoot = join(dir, "src");
  mkdirSync(join(sourceRoot, "utils"), { recursive: true });
  mkdirSync(join(sourceRoot, "app"), { recursive: true });
  writeFileSync(
    join(sourceRoot, "utils", "math.js"),
    `
define(function() {
  function add(a, b) {
    return a + b;
  }
  return { add: add };
});
`,
  );
  writeFileSync(
    join(sourceRoot, "app", "main.js"),
    `
define(["utils/math"], function(math) {
  console.log(math.add(1, 2));
});
`,
  );

  const out = join(dir, "requirejs-bundle.js");
  runChecked("node", [
    join(toolDir, "node_modules", "requirejs", "bin", "r.js"),
    "-o",
    `baseUrl=${sourceRoot}`,
    "name=app/main",
    `out=${out}`,
    "optimize=none",
    "skipModuleInsertion=true",
    "wrap=false",
  ]);
  return out;
}

function buildRollup(dir, format) {
  const toolDir = ensureNodeTool("rollup-4", ["rollup@4"]);
  const sourceRoot = join(dir, "src");
  mkdirSync(sourceRoot, { recursive: true });
  writeFileSync(
    join(sourceRoot, "main.js"),
    `
function add(a, b) {
  return a + b;
}

console.log(add(1, 2));
export { add };
`,
  );

  const out = join(dir, `rollup-${format}.js`);
  runChecked("node", [
    join(toolDir, "node_modules", "rollup", "dist", "bin", "rollup"),
    join(sourceRoot, "main.js"),
    "--format",
    format,
    "--name",
    "MathLib",
    "--amd.id",
    "math-lib",
    "--file",
    out,
    "--silent",
  ]);
  return out;
}

function buildRollupAnonymousExternal(dir) {
  const toolDir = ensureNodeTool("rollup-4", ["rollup@4"]);
  const sourceRoot = join(dir, "src");
  mkdirSync(sourceRoot, { recursive: true });
  writeFileSync(
    join(sourceRoot, "main.js"),
    `
import { add } from "math-lib";

const total = add(1, 2);
console.log(total);
export { total };
`,
  );

  const out = join(dir, "rollup-amd-anonymous-external.js");
  runChecked("node", [
    join(toolDir, "node_modules", "rollup", "dist", "bin", "rollup"),
    join(sourceRoot, "main.js"),
    "--format",
    "amd",
    "--external",
    "math-lib",
    "--file",
    out,
    "--silent",
  ]);
  return out;
}

function runWakaruUnpack(input, outputDir) {
  const configured = process.env.WAKARU;
  if (configured) {
    runChecked(configured, [input, "--unpack", "-o", outputDir]);
    return;
  }

  const debugBinary = join(repoRoot, "target", "debug", process.platform === "win32" ? "wakaru.exe" : "wakaru");
  try {
    runChecked(debugBinary, [input, "--unpack", "-o", outputDir]);
  } catch {
    runChecked("cargo", ["run", "-q", "-p", "wakaru-cli", "--", input, "--unpack", "-o", outputDir], {
      cwd: repoRoot,
    });
  }
}

function collectModules(outputDir) {
  const files = [];
  collectJsFiles(outputDir, outputDir, files);
  return files.sort(([left], [right]) => left.localeCompare(right));
}

function collectJsFiles(root, dir, files) {
  for (const entry of readdirSync(dir, { withFileTypes: true })) {
    const full = join(dir, entry.name);
    if (entry.isDirectory()) {
      collectJsFiles(root, full, files);
    } else if (entry.isFile() && entry.name.endsWith(".js")) {
      files.push([relative(root, full).replaceAll("\\", "/"), readFileSync(full, "utf8")]);
    }
  }
}

function checkCase(testCase, modules) {
  const names = modules.map(([name]) => name);
  const missingFiles = testCase.expectedFiles.filter((name) => !names.includes(name));
  const extraFiles = names.filter((name) => !testCase.expectedFiles.includes(name));
  const missingNeedles = testCase.expectedNeedles.filter(({ file, text }) => !moduleCode(modules, file).includes(text));
  const leakedNeedles = testCase.rejectedNeedles.filter(({ file, text }) => moduleCode(modules, file).includes(text));

  const notes = [];
  if (missingFiles.length > 0) notes.push(`missing files ${missingFiles.join(", ")}`);
  if (extraFiles.length > 0) notes.push(`extra files ${extraFiles.join(", ")}`);
  if (missingNeedles.length > 0) {
    notes.push(`missing ${missingNeedles.map(({ file, text }) => `${file}: ${text}`).join("; ")}`);
  }
  if (leakedNeedles.length > 0) {
    notes.push(`leaked ${leakedNeedles.map(({ file, text }) => `${file}: ${text}`).join("; ")}`);
  }
  return { recovered: notes.length === 0, notes: notes.length === 0 ? "expected modules recovered" : notes.join("; ") };
}

function moduleCode(modules, filename) {
  return modules.find(([name]) => name === filename)?.[1] ?? "";
}

function wakaruDescription() {
  if (process.env.WAKARU) {
    return process.env.WAKARU;
  }
  return join(repoRoot, "target", "debug", process.platform === "win32" ? "wakaru.exe" : "wakaru");
}

function runChecked(command, args, options = {}) {
  const result = spawnSync(command, args, {
    cwd: options.cwd ?? repoRoot,
    encoding: "utf8",
    maxBuffer: 1024 * 1024 * 20,
    shell: options.shell ?? false,
    env: { ...process.env, ...(options.env ?? {}) },
  });
  if (result.error) throw result.error;
  if (result.status !== 0) {
    const detail = [result.stderr.trim(), result.stdout.trim()].filter(Boolean).join(" ");
    throw new Error(`${basename(command)} exited ${result.status}: ${detail}`);
  }
  return result.stdout;
}

function escapeCell(value) {
  return value.replaceAll("|", "\\|").replaceAll("\n", " ");
}