Luigit
repositories / pi-ext

pi-ext

bugabingas pi extensions

owned by admin

scripts/build/bundle.test.ts

Raw
import { spawnSync } from "node:child_process";
import {
	mkdirSync,
	mkdtempSync,
	readFileSync,
	rmSync,
	writeFileSync,
} from "node:fs";
import { tmpdir } from "node:os";
import { dirname, join } from "node:path";
import { pathToFileURL } from "node:url";
import { expect, it } from "vitest";
import { literalString, parseModule, walkEs } from "../lib/esast.ts";
import {
	bundleBrowserEntries,
	bundleExtension,
	bundleNodeEntries,
} from "./bundle.ts";
import { readBuildSpec } from "./spec.ts";

it.each(
	["extension", "node", "browser"].flatMap((kind) =>
		[false, true].map((release) => ({ kind, release })),
	),
)(
	"keeps lazy dependencies out of the static graph ($kind, release: $release)",
	async ({ kind, release }) => {
		const root = mkdtempSync(join(tmpdir(), "pi-sdk-probe-bundle-"));
		try {
			const source = join(root, "source");
			const output = join(root, "output");
			mkdirSync(source);
			writeFileSync(
				join(source, "package.json"),
				JSON.stringify({ name: "lazy-fixture", type: "module" }),
			);
			writeFileSync(
				join(source, "index.ts"),
				[
					'import { state } from "./eager.ts";',
					"export const eager = state;",
					'export const loadEager = () => import("./eager.ts");',
					'export const loadHeavy = () => import("./heavy.ts");',
				].join("\n"),
			);
			writeFileSync(
				join(source, "eager.ts"),
				"export const state = { value: 1 }; export function mutate() { state.value++; }\n",
			);
			writeFileSync(
				join(source, "heavy.ts"),
				'import payload from "./payload.cjs"; globalThis.heavyLoads = (globalThis.heavyLoads ?? 0) + 1; export default payload;\n',
			);
			writeFileSync(
				join(source, "payload.cjs"),
				'module.exports = { marker: "LAZY_PAYLOAD_MARKER" };\n',
			);
			const spec = readBuildSpec(source);
			let entry = join(output, "index.ts");
			if (kind === "extension") {
				await bundleExtension(spec, output, { release });
			} else if (kind === "node") {
				await bundleNodeEntries(
					{ ...spec, nodeEntries: spec.entries },
					output,
					{ release },
				);
				entry = join(output, "index.js");
			} else {
				await bundleBrowserEntries(
					{ ...spec, browserEntries: spec.entries },
					output,
					{ release },
				);
				entry = join(output, "browser", "index.js");
			}
			const visited = new Set<string>();
			const pending = [entry];
			while (pending.length) {
				const file = pending.pop()!;
				if (visited.has(file)) continue;
				visited.add(file);
				const code = readFileSync(file, "utf8");
				expect(code, file).not.toContain("LAZY_PAYLOAD_MARKER");
				walkEs(parseModule(file, code), (node) => {
					if (
						node.type !== "ImportDeclaration" &&
						node.type !== "ExportNamedDeclaration" &&
						node.type !== "ExportAllDeclaration"
					)
						return;
					const specifier = literalString(
						node["source"] as Parameters<typeof literalString>[0],
					);
					if (specifier?.startsWith("."))
						pending.push(join(dirname(file), specifier));
				});
			}
			const child = spawnSync(
				process.execPath,
				[
					"--input-type=module",
					"-e",
					`import assert from "node:assert/strict";
const entry = await import(${JSON.stringify(pathToFileURL(entry).href)});
assert.equal(globalThis.heavyLoads, undefined);
const eager = await entry.loadEager();
assert.equal(eager.state, entry.eager);
eager.mutate();
assert.equal(entry.eager.value, 2);
const heavy = await entry.loadHeavy();
assert.equal(heavy.default.marker, "LAZY_PAYLOAD_MARKER");
assert.equal(globalThis.heavyLoads, 1);
assert.equal(await entry.loadHeavy(), heavy);
assert.equal(globalThis.heavyLoads, 1);`,
				],
				{ encoding: "utf8", timeout: 10_000 },
			);
			expect(child.error, child.stderr).toBeUndefined();
			expect(child.status, child.stderr).toBe(0);
		} finally {
			rmSync(root, { recursive: true, force: true });
		}
	},
);