scripts/repro/swc-minifier-matrix/matrix.mjs
GitHub#!/usr/bin/env node
import {
runMatrix, batchRunner, ensureNodeTool,
} from "../lib/runner.mjs";
import { mangleValidator } from "../lib/compare.mjs";
import { join } from "node:path";
import { writeFileSync } from "node:fs";
import { spawnSync } from "node:child_process";
const profiles = [
{
name: "sequences",
options: {
compress: { defaults: false, sequences: true },
mangle: false,
},
},
{
name: "booleans",
options: {
compress: { defaults: false, booleans: true },
mangle: false,
},
},
{
name: "evaluate",
options: {
compress: { defaults: false, evaluate: true },
mangle: false,
},
},
{
name: "inline-iife",
options: {
compress: { defaults: false, inline: 3, reduce_vars: true, reduce_funcs: true },
mangle: false,
},
},
{
name: "mangle",
options: {
compress: false,
mangle: { toplevel: true },
},
},
{
name: "all",
options: {
compress: true,
mangle: true,
},
},
];
const snippets = [
{
name: "sequence-before-if",
bucket: "sequences",
source: `
function run(y) {
x = 5;
if (y) z();
}
run(input);
`,
expectedAny: [
["x = 5;", "if (y)"],
["x = 5;", "if (input_1)"],
["x = 5;", "if (input)"],
],
},
{
name: "sequence-before-return",
bucket: "sequences",
source: `
function run() {
side();
return value;
}
console.log(run());
`,
expected: ["side();", "return value;"],
skipProfiles: ["all"],
},
{
name: "sequence-before-for",
bucket: "sequences",
source: `
function run() {
setup();
for (; i < n; i++) work(i);
}
run();
`,
expected: ["setup();", "for(; i < n; i++)"],
},
{
name: "sequence-before-throw",
bucket: "sequences",
source: `
function run() {
log();
throw error;
}
try {
run();
} catch (caught) {
handle(caught);
}
`,
expected: ["log();", "throw error;"],
},
{
name: "boolean-literals",
bucket: "booleans",
source: `
const yes = true;
const no = false;
console.log(yes, no);
`,
expected: ["true", "false"],
},
{
name: "negated-condition",
bucket: "booleans",
source: `
function run(flag) {
if (!flag) disabled();
}
run(input);
`,
expectedAny: [["if (!flag)"], ["if (!input)"]],
},
{
name: "boolean-return",
bucket: "booleans",
source: `
function run(flag) {
return flag ? true : false;
}
console.log(run(input));
`,
expectedAny: [["return !!flag;"], ["!!input"]],
},
{
name: "double-negation",
bucket: "booleans",
source: `
const out = !!value;
console.log(out);
`,
expected: ["!!value"],
},
{
name: "undefined-infinity",
bucket: "evaluate",
source: `
const missing = undefined;
const forever = Infinity;
console.log(missing, forever);
`,
expected: ["undefined", "Infinity"],
},
{
name: "numeric-fold",
bucket: "evaluate",
source: `
const total = 1 + 2 * 3;
console.log(total);
`,
expectedAny: [["const total = 7;"], ["console.log(7)"]],
},
{
name: "string-constant-access",
bucket: "evaluate",
source: `
const letter = "abc".charAt(1);
console.log(letter);
`,
expected: ["const letter = \"b\";"],
informational: true,
},
{
name: "array-constant-access",
bucket: "evaluate",
source: `
const item = [1, 2, 3][1];
console.log(item);
`,
expectedAny: [["const item = 2;"], ["console.log(2)"]],
informational: true,
},
{
name: "arrow-iife-arg",
bucket: "inline-iife",
source: `
const out = ((value) => value + 1)(input);
console.log(out);
`,
expected: ["input + 1"],
informational: true,
},
{
name: "function-iife-arg",
bucket: "inline-iife",
source: `
const out = (function (value) {
return value + 1;
})(input);
console.log(out);
`,
expected: ["input + 1"],
informational: true,
},
{
name: "iife-for-of-target",
bucket: "mangle",
source: `
(function (a) {
for (a of items) use(a);
})(0);
`,
expected: ["let ", "for ("],
rejected: ["const "],
skipProfiles: ["all"],
},
{
name: "single-use-temp-alias",
bucket: "inline-iife",
source: `
function run(input) {
const alias = input.value;
return alias;
}
console.log(run(input));
`,
expectedAny: [["return input1.value;"], ["input.value"]],
},
{
name: "callback-wrapper",
bucket: "inline-iife",
source: `
const wrapped = function (value) {
return handler(value);
};
wrapped(input);
`,
expected: ["handler(input)"],
informational: true,
},
{
name: "react-hook-tuple",
bucket: "mangle",
source: `
import { useState } from "react";
export function Counter() {
const [count, setCount] = useState(0);
return setCount(count + 1);
}
`,
expected: ["useState", "setT"],
},
{
name: "member-init-name",
bucket: "mangle",
source: `
const logger = services.logger;
logger.info("ready");
`,
expected: ["logger.info"],
},
{
name: "symbol-for-name",
bucket: "mangle",
source: `
const token = Symbol.for("wakaru.token");
console.log(token);
`,
expected: ["token"],
},
{
name: "component-value-position",
bucket: "mangle",
source: `
const UserCard = registry.UserCard;
export const view = UserCard(props);
`,
expected: ["UserCard"],
},
];
// SWC minifier batch
function swcMinifyBatch(sources, options) {
const toolDir = ensureNodeTool("swc", ["@swc/core@1"]);
const helper = join(toolDir, "swc-minify-batch.cjs");
writeFileSync(
helper,
`
const fs = require("node:fs");
const swc = require("@swc/core");
const options = JSON.parse(process.env.SWC_MINIFY_OPTIONS);
const sources = JSON.parse(fs.readFileSync(0, "utf8"));
const results = sources.map(source => {
try {
return { code: swc.minifySync(source, {
...options,
format: { ascii_only: true, comments: false },
module: true,
}).code };
} catch (e) { return { error: e.message }; }
});
process.stdout.write(JSON.stringify(results));
`,
);
const result = spawnSync("node", [helper], {
cwd: toolDir,
input: JSON.stringify(sources),
encoding: "utf8",
maxBuffer: 1024 * 1024 * 50,
env: { ...process.env, SWC_MINIFY_OPTIONS: JSON.stringify(options) },
});
if (result.error) throw result.error;
if (result.status !== 0) throw new Error(`swc batch exited ${result.status}: ${result.stderr}`);
const outputs = JSON.parse(result.stdout);
const map = new Map();
for (let i = 0; i < sources.length; i++) {
map.set(sources[i], outputs[i].error ? new Error(outputs[i].error) : outputs[i].code);
}
return map;
}
const allSources = snippets.map((s) => s.source);
// Build per-profile batch runners (lazily cached)
const profileRunners = new Map();
for (const profile of profiles) {
profileRunners.set(profile.name, batchRunner(() => swcMinifyBatch(allSources, profile.options)));
}
function profilesFor(snippet) {
const skip = new Set(snippet.skipProfiles ?? []);
const bucketProfiles = profiles.filter((p) => p.name === snippet.bucket);
const allProfile = profiles.find((p) => p.name === "all");
return [...bucketProfiles, allProfile].filter(Boolean).filter((p) => !skip.has(p.name));
}
// Assign per-snippet transformers via extraTransformers
for (const snippet of snippets) {
snippet.extraTransformers = profilesFor(snippet).map((profile) => ({
name: profile.name,
run: profileRunners.get(profile.name),
}));
}
runMatrix({
name: "swc-minifier",
snippets,
transformers: [],
...mangleValidator(),
});