scripts/repro/vue-render-matrix/matrix.mjs
GitHub#!/usr/bin/env node
import {
runMatrix, batchRunner, withTerserVariants, ensureNodeTool,
} from "../lib/runner.mjs";
import { prewarmNormalize, structurallyEqual } from "../lib/compare.mjs";
import { VUE_SFC_COMPILE_PROFILES } from "../lib/vue-sfc-compiler.mjs";
import {
linkedEventHandlerProgram,
setupDirectiveBinding,
} from "../lib/vue-sfc-compare.mjs";
import { createRequire } from "node:module";
import { dirname, join } from "node:path";
import { spawnSync } from "node:child_process";
import { writeFileSync } from "node:fs";
import { fileURLToPath, pathToFileURL } from "node:url";
const VUE_COMPILER_VERSION = "3.5.35";
const BABEL_PARSER_VERSION = "7.29.7";
const vueToolDir = ensureNodeTool(
`vue-sfc-${VUE_COMPILER_VERSION}`,
[
`@vue/compiler-sfc@${VUE_COMPILER_VERSION}`,
`@babel/parser@${BABEL_PARSER_VERSION}`,
],
);
const vueToolRequire = createRequire(join(vueToolDir, "package.json"));
const vueCompareOptions = {
compiler: vueToolRequire("@vue/compiler-sfc"),
babelParser: vueToolRequire("@babel/parser"),
};
const snippets = [
{
name: "static-element",
source: `
<template>
<section class="card">Hello Vue</section>
</template>
`,
expected: ["<template>", "<section class=\"card\">Hello Vue</section>"],
},
{
name: "text-interpolation",
source: `
<script>
export default {
props: {
msg: String
}
}
</script>
<template>
<div>{{ msg }}</div>
</template>
`,
expected: ["<template>", "<div>{{ msg }}</div>"],
},
{
name: "script-setup-event-and-class",
source: `
<script setup>
const props = defineProps({
active: Boolean,
count: Number
})
const emit = defineEmits(["increment"])
function increment() {
emit("increment")
}
</script>
<template>
<button class="counter" :class="{ active: props.active }" @click="increment">
{{ props.count }}
</button>
</template>
`,
expectedAny: [
[
"<script setup>",
"const props = defineProps(",
"defineEmits(",
":class=\"{ active: props.active }\"",
"{{ props.count }}",
],
[
"<script setup>",
"const props = defineProps(",
"defineEmits(",
":class=\"{ active }\"",
"{{ count }}",
],
],
},
{
name: "conditional-branches",
source: `
<script setup>
defineProps({
status: String,
error: String
})
</script>
<template>
<p v-if="status === 'loading'">Loading</p>
<p v-else-if="status === 'error'">{{ error }}</p>
<p v-else>Ready</p>
</template>
`,
expected: ["v-if=\"status === 'loading'\"", "v-else-if=\"status === 'error'\"", "v-else"],
},
{
name: "list-render",
source: `
<script setup>
defineProps({
items: Array
})
</script>
<template>
<ul>
<li v-for="item in items" :key="item.id">{{ item.name }}</li>
</ul>
</template>
`,
expected: ["v-for=\"item in items\"", ":key=\"item.id\"", "{{ item.name }}"],
},
{
name: "component-and-slot",
source: `
<script setup>
import PanelHeader from "./PanelHeader.vue"
defineProps({
title: String
})
</script>
<template>
<article>
<PanelHeader :title="title" />
<slot name="body">Empty</slot>
</article>
</template>
`,
expected: [
"<script setup>",
"import PanelHeader from \"./PanelHeader.vue\";",
"<PanelHeader :title=\"title\" />",
"<slot name=\"body\">Empty</slot>",
],
},
{
name: "scoped-slots-with-destructuring",
source: `
<script setup>
import DataList from "./DataList.vue"
defineProps({ items: Array })
function select(item) {
return item.id
}
</script>
<template>
<DataList :items="items">
<template #default="{ item, index }">
<button :data-index="index" @click="select(item)">{{ item.name }}</button>
</template>
<template #empty>No items</template>
</DataList>
</template>
`,
expected: [
"v-slot:default=\"{ item, index }\"",
":data-index=\"index\"",
"@click=\"select(item)\"",
"{{ item.name }}",
"v-slot:empty",
],
},
{
name: "model-and-directive",
source: `
<script setup>
const value = defineModel()
const visible = true
</script>
<template>
<input v-model="value" v-show="visible" />
</template>
`,
expected: ["<script setup>"],
},
];
const allSources = snippets.map((s) => s.source);
function vueSfcBatch(sources, profile) {
const helper = join(vueToolDir, "vue-sfc-batch.mjs");
const compilerHelper = pathToFileURL(
join(dirname(fileURLToPath(import.meta.url)), "..", "lib", "vue-sfc-compiler.mjs"),
).href;
writeFileSync(
helper,
`
import fs from "node:fs";
import { parse, compileScript, compileTemplate } from "@vue/compiler-sfc";
import { compileVueSfc } from ${JSON.stringify(compilerHelper)};
const profile = JSON.parse(process.env.MATRIX_VUE_PROFILE);
const sources = JSON.parse(fs.readFileSync(0, "utf8"));
const results = sources.map((source, index) => {
const filename = "Component" + index + ".vue";
const id = "data-v-wakaru-" + index.toString(36);
try {
return {
code: compileVueSfc({
source,
filename,
compiler: { parse, compileScript, compileTemplate },
profile,
id,
}),
};
} catch (error) {
return { error: error.message };
}
});
process.stdout.write(JSON.stringify(results));
`,
);
const result = spawnSync("node", [helper], {
cwd: vueToolDir,
input: JSON.stringify(sources),
encoding: "utf8",
maxBuffer: 1024 * 1024 * 50,
env: { ...process.env, MATRIX_VUE_PROFILE: JSON.stringify(profile) },
});
if (result.error) throw result.error;
if (result.status !== 0) {
const detail = [result.stderr.trim(), result.stdout.trim()].filter(Boolean).join(" ");
throw new Error(`vue compiler batch exited ${result.status}: ${detail}`);
}
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 transformers = VUE_SFC_COMPILE_PROFILES.flatMap((profile) =>
withTerserVariants(
`vue-${VUE_COMPILER_VERSION}-${profile.name}`,
allSources,
batchRunner(() => vueSfcBatch(allSources, profile)),
),
);
function linkedScopedSlotPrograms(snippet, recovered) {
if (snippet.name !== "scoped-slots-with-destructuring") return null;
const sourceProgram = linkedEventHandlerProgram(snippet.source, vueCompareOptions);
const recoveredProgram = linkedEventHandlerProgram(recovered, vueCompareOptions);
if (!sourceProgram || !recoveredProgram) return null;
return { sourceProgram, recoveredProgram };
}
runMatrix({
name: "vue-render",
snippets,
transformers,
wakaruArgs: ["--vue-sfc"],
validateRecovered({ snippet, shape, recovered }) {
if (snippet.name === "script-setup-event-and-class") {
const clickBinding = setupDirectiveBinding(recovered, {
...vueCompareOptions,
directiveName: "on",
argument: "click",
});
if (!clickBinding) {
return {
recovered: false,
notes: "click handler is not a plain script-setup binding",
};
}
}
if (shape.tools.some((tool) => tool.includes("mangle"))) {
const linked = linkedScopedSlotPrograms(snippet, recovered);
const eventNeedle = linked && `@click="${linked.sourceProgram.expression}"`;
const otherSyntaxPresent = linked && snippet.expected
.filter((needle) => needle !== eventNeedle)
.every((needle) => recovered.includes(needle));
if (
linked
&& otherSyntaxPresent
&& structurallyEqual(linked.sourceProgram.program, linked.recoveredProgram.program)
) {
return {
recovered: true,
notes: "linked slot handler is structurally equivalent (mangle-insensitive)",
};
}
}
if (snippet.name === "model-and-directive") {
const modelBinding = setupDirectiveBinding(recovered, {
...vueCompareOptions,
directiveName: "model",
});
if (!modelBinding || !["useModel", "defineModel"].includes(modelBinding.initializer)) {
return {
recovered: false,
notes: "v-model is not linked to a recovered useModel/defineModel binding",
};
}
const showBinding = setupDirectiveBinding(recovered, {
...vueCompareOptions,
directiveName: "show",
});
if (!showBinding && !recovered.includes('v-show="true"')) {
return {
recovered: false,
notes: "v-show is neither a plain script-setup binding nor folded true",
};
}
}
},
async prewarm(rows) {
const codes = [];
for (const { snippet, shape, recovered } of rows) {
if (recovered == null || !shape.tools.some((tool) => tool.includes("mangle"))) continue;
const linked = linkedScopedSlotPrograms(snippet, recovered);
if (linked) codes.push(linked.sourceProgram.program, linked.recoveredProgram.program);
}
await prewarmNormalize(codes, { rename: true });
},
});