@prosopo/config 3.3.6 → 3.3.8

package/src/vite/bundleConfigs.test.ts

@@ -0,0 +1,405 @@
+// Copyright 2021-2026 Prosopo (UK) Ltd.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import fs from "node:fs";
+import { builtinModules } from "node:module";
+import os from "node:os";
+import path from "node:path";
+import type { Rollup, UserConfig } from "vite";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { nodejsPolarsNativeFilePlugin } from "./NodejsPolarsNativeFilePlugin.js";
+import VitePluginCloseAndCopy from "./vite-plugin-close-and-copy.js";
+import ViteCommonJSConfig from "./vite.commonjs.config.js";
+import ViteEsmConfig from "./vite.esm.config.js";
+
+let root: string;
+let cwd: string;
+
+beforeEach(() => {
+	root = fs.mkdtempSync(path.join(os.tmpdir(), "prosopo-bundle-config-test-"));
+	cwd = process.cwd();
+});
+
+afterEach(() => {
+	process.chdir(cwd);
+	fs.rmSync(root, { recursive: true, force: true });
+});
+
+/** A tsconfig with no references, so no npm lookups are needed. */
+const leafTsConfig = (): string => {
+	const dir = path.join(root, "pkg");
+	fs.mkdirSync(dir, { recursive: true });
+	fs.writeFileSync(
+		path.join(dir, "package.json"),
+		JSON.stringify({ name: "@prosopo/pkg" }),
+	);
+	const tsConfigPath = path.join(dir, "tsconfig.json");
+	fs.writeFileSync(tsConfigPath, JSON.stringify({ references: [] }));
+	return tsConfigPath;
+};
+
+// Hand-rolled rather than `.flat(Infinity)`: a non-literal depth makes tsc
+// expand FlatArray until it gives up with TS2589.
+const flattenDeep = (value: unknown): unknown[] =>
+	Array.isArray(value) ? value.flatMap(flattenDeep) : [value];
+
+const pluginNames = (config: UserConfig): string[] =>
+	flattenDeep(config.plugins ?? []).map((plugin) => {
+		if (plugin && typeof plugin === "object" && "name" in plugin) {
+			return String(plugin.name);
+		}
+		return "";
+	});
+
+/**
+ * Drive the `generateBundle` hook of the inline import.meta.url plugin over a
+ * fake bundle. Only that one plugin defines the hook.
+ */
+type FakeBundle = Record<string, { type: string; code?: string }>;
+
+const generateBundle = async (
+	config: UserConfig,
+	bundle: FakeBundle,
+): Promise<void> => {
+	for (const plugin of flattenDeep(config.plugins ?? [])) {
+		if (
+			!plugin ||
+			typeof plugin !== "object" ||
+			!("generateBundle" in plugin)
+		) {
+			continue;
+		}
+		const hook = plugin.generateBundle;
+		if (typeof hook === "function") {
+			await callHook(
+				hook as (options: object, bundle: FakeBundle) => unknown,
+				{},
+				bundle,
+			);
+		}
+	}
+};
+
+const externals = (config: UserConfig): string[] => {
+	const external = config.build?.rollupOptions?.external;
+	if (!Array.isArray(external)) {
+		throw new Error("expected an array of externals");
+	}
+	return external.map(String);
+};
+
+describe("ViteEsmConfig", () => {
+	it("emits a single esm library targeting the runtime node version", async () => {
+		const config = await ViteEsmConfig("my-lib", leafTsConfig());
+		expect(config.build?.lib).toMatchObject({
+			name: "my-lib",
+			formats: ["es"],
+			entry: "src/index.ts",
+		});
+		expect(config.build?.target).toBe("node24");
+		expect(config.build?.outDir).toBe("dist");
+	});
+
+	it("accepts an explicit entry, including a multi-entry map", async () => {
+		const tsConfigPath = leafTsConfig();
+		await expect(
+			ViteEsmConfig("my-lib", tsConfigPath, "src/other.ts"),
+		).resolves.toMatchObject({ build: { lib: { entry: "src/other.ts" } } });
+		await expect(
+			ViteEsmConfig("my-lib", tsConfigPath, { a: "src/a.ts", b: "src/b.ts" }),
+		).resolves.toMatchObject({
+			build: { lib: { entry: { a: "src/a.ts", b: "src/b.ts" } } },
+		});
+	});
+
+	it("externalises every node builtin under both bare and node: specifiers", async () => {
+		const list = externals(await ViteEsmConfig("my-lib", leafTsConfig()));
+		for (const builtin of builtinModules) {
+			expect(list).toContain(builtin);
+			expect(list).toContain(`node:${builtin}`);
+		}
+	});
+
+	it("externalises the webpack toolchain, which vite must not bundle", async () => {
+		const list = externals(await ViteEsmConfig("my-lib", leafTsConfig()));
+		expect(list).toContain("webpack");
+		expect(list).toContain("html-webpack-plugin");
+		expect(list).toContain("babel-loader");
+	});
+
+	it("uses the same external list for ssr and for rollup", async () => {
+		const config = await ViteEsmConfig("my-lib", leafTsConfig());
+		expect(config.ssr?.external).toEqual(externals(config));
+	});
+
+	it("pulls package names out of the referenced projects", async () => {
+		const dep = path.join(root, "dep");
+		fs.mkdirSync(dep, { recursive: true });
+		fs.writeFileSync(
+			path.join(dep, "package.json"),
+			JSON.stringify({ name: "@prosopo/dep" }),
+		);
+		fs.writeFileSync(
+			path.join(dep, "tsconfig.json"),
+			JSON.stringify({ references: [] }),
+		);
+		const tsConfigPath = leafTsConfig();
+		fs.writeFileSync(
+			tsConfigPath,
+			JSON.stringify({ references: [{ path: "../dep" }] }),
+		);
+
+		expect(externals(await ViteEsmConfig("my-lib", tsConfigPath))).toContain(
+			"@prosopo/dep",
+		);
+	});
+
+	it("disables treeshaking and keeps the output directory intact", async () => {
+		// Packages emit esm and cjs into the same tree from two separate runs,
+		// so emptying the out dir would delete the sibling build.
+		const config = await ViteEsmConfig("my-lib", leafTsConfig());
+		expect(config.build?.rollupOptions?.treeshake).toBe(false);
+		expect(config.build?.emptyOutDir).toBe(false);
+	});
+
+	it("suppresses the CJS require polyfill so browsers can load the output", async () => {
+		const config = await ViteEsmConfig("my-lib", leafTsConfig());
+		const output = config.build?.rollupOptions?.output;
+		expect(output).toMatchObject({ polyfillRequire: false });
+	});
+
+	it("registers the copy and tsconfig-paths plugins", async () => {
+		const names = pluginNames(await ViteEsmConfig("my-lib", leafTsConfig()));
+		expect(names).toContain("close-plugin");
+		expect(names).toContain("vite-tsconfig-paths");
+	});
+
+	it("uses the automatic jsx runtime", async () => {
+		const config = await ViteEsmConfig("my-lib", leafTsConfig());
+		expect(config.esbuild).toMatchObject({ jsx: "automatic" });
+	});
+
+	it("rejects a tsconfig path that does not exist", async () => {
+		await expect(
+			ViteEsmConfig("my-lib", path.join(root, "missing.json")),
+		).rejects.toBeDefined();
+	});
+});
+
+describe("ViteCommonJSConfig", () => {
+	it("emits cjs into its own subdirectory so it cannot clash with the esm build", async () => {
+		const config = await ViteCommonJSConfig("my-lib", leafTsConfig());
+		expect(config.build?.lib).toMatchObject({
+			name: "my-lib",
+			formats: ["cjs"],
+		});
+		expect(config.build?.outDir).toBe("dist/cjs");
+	});
+
+	it("does not externalise the webpack toolchain, unlike the esm config", async () => {
+		const tsConfigPath = leafTsConfig();
+		expect(
+			externals(await ViteCommonJSConfig("my-lib", tsConfigPath)),
+		).not.toContain("html-webpack-plugin");
+		expect(externals(await ViteEsmConfig("my-lib", tsConfigPath))).toContain(
+			"html-webpack-plugin",
+		);
+	});
+
+	it("rewrites import.meta.url in every emitted chunk, since cjs has none", async () => {
+		const bundle: Record<string, { type: string; code?: string }> = {
+			"a.js": { type: "chunk", code: "const a = import.meta.url;" },
+			"b.js": { type: "chunk", code: "const b = import.meta.url + 1;" },
+		};
+		await generateBundle(
+			await ViteCommonJSConfig("my-lib", leafTsConfig()),
+			bundle,
+		);
+
+		expect(bundle["a.js"]?.code).toBe(
+			"const a = require('url').pathToFileURL(__filename).href;",
+		);
+		expect(bundle["b.js"]?.code).toBe(
+			"const b = require('url').pathToFileURL(__filename).href + 1;",
+		);
+	});
+
+	it("leaves assets and empty chunks alone", async () => {
+		// An asset has no `code` property at all, so touching it would throw.
+		const bundle: Record<string, { type: string; code?: string }> = {
+			"style.css": { type: "asset" },
+			"empty.js": { type: "chunk", code: "" },
+		};
+		await expect(
+			generateBundle(
+				await ViteCommonJSConfig("my-lib", leafTsConfig()),
+				bundle,
+			),
+		).resolves.toBeUndefined();
+		expect(bundle["empty.js"]?.code).toBe("");
+	});
+
+	it("honours an explicit entry", async () => {
+		await expect(
+			ViteCommonJSConfig("my-lib", leafTsConfig(), "src/cli.ts"),
+		).resolves.toMatchObject({ build: { lib: { entry: "src/cli.ts" } } });
+	});
+});
+
+describe("nodejsPolarsNativeFilePlugin", () => {
+	it("claims a native file by basename, wherever it is imported from", () => {
+		const plugin = nodejsPolarsNativeFilePlugin(["/abs/polars.node"], "dist");
+		expect(plugin.resolveId("./polars.node", "/src/a.ts", {})).toBe(
+			"./polars.node",
+		);
+		expect(plugin.resolveId("./other.node", "/src/a.ts", {})).toBeNull();
+	});
+
+	it("replaces the module with a createRequire shim", () => {
+		const plugin = nodejsPolarsNativeFilePlugin(["polars.node"], "dist");
+		const transformed = plugin.transform("ignored", "/abs/polars.node");
+		expect(transformed).toContain("createRequire");
+		expect(transformed).toContain("'./polars.node'");
+		expect(transformed).toContain("export default content");
+	});
+
+	it("leaves every other module untouched", () => {
+		const plugin = nodejsPolarsNativeFilePlugin(["polars.node"], "dist");
+		expect(plugin.transform("const a = 1;", "/src/index.ts")).toBe(
+			"const a = 1;",
+		);
+	});
+
+	it("loads a native file as empty so the bundler never parses it as js", () => {
+		const plugin = nodejsPolarsNativeFilePlugin(["polars.node"], "dist");
+		expect(plugin.load("/abs/polars.node")).toBe("");
+		expect(plugin.load("/src/index.ts")).toBeNull();
+	});
+
+	it("copies the native files into the output directory verbatim", () => {
+		const src = path.join(root, "polars.node");
+		const outDir = path.join(root, "nested", "dist");
+		const bytes = Buffer.from([0, 1, 2, 255]);
+		fs.writeFileSync(src, bytes);
+
+		nodejsPolarsNativeFilePlugin([src], outDir).generateBundle({}, {});
+
+		expect(fs.readFileSync(path.join(outDir, "polars.node"))).toEqual(bytes);
+	});
+
+	it("throws when a declared native file is missing", () => {
+		// A silent skip would produce a bundle that dies at runtime with an
+		// unhelpful "cannot find module" instead of failing the build.
+		const plugin = nodejsPolarsNativeFilePlugin(
+			[path.join(root, "absent.node")],
+			path.join(root, "dist"),
+		);
+		expect(() => plugin.generateBundle({}, {})).toThrow();
+	});
+
+	it("does nothing at all when there are no native files", () => {
+		const plugin = nodejsPolarsNativeFilePlugin([], "dist");
+		expect(plugin.resolveId("anything", undefined, {})).toBeNull();
+		expect(plugin.load("anything")).toBeNull();
+		expect(() => plugin.generateBundle({}, {})).not.toThrow();
+	});
+});
+
+describe("VitePluginCloseAndCopy", () => {
+	it("is a no-op at close time when no copy options are given", () => {
+		const plugin = VitePluginCloseAndCopy();
+		expect(plugin.name).toBe("close-plugin");
+		expect(() => callHook(plugin.closeBundle)).not.toThrow();
+	});
+
+	it("clears the js already in the destination, then copies the bundle over", () => {
+		process.chdir(root);
+		fs.mkdirSync(path.join(root, "src"));
+		fs.writeFileSync(path.join(root, "src", "new.js"), "new");
+		fs.mkdirSync(path.join(root, "dest"));
+		fs.writeFileSync(path.join(root, "dest", "stale.js"), "stale");
+		fs.writeFileSync(path.join(root, "dest", "keep.css"), "keep");
+
+		const plugin = VitePluginCloseAndCopy({
+			srcDir: "src",
+			destDir: ["dest"],
+		});
+		callHook(plugin.closeBundle);
+
+		expect(fs.readdirSync(path.join(root, "dest")).sort()).toEqual([
+			"keep.css",
+			"new.js",
+		]);
+	});
+
+	it("copies into every destination", () => {
+		process.chdir(root);
+		fs.mkdirSync(path.join(root, "src"));
+		fs.writeFileSync(path.join(root, "src", "a.js"), "a");
+		fs.mkdirSync(path.join(root, "one"));
+		fs.mkdirSync(path.join(root, "two"));
+
+		callHook(
+			VitePluginCloseAndCopy({ srcDir: "src", destDir: ["one", "two"] })
+				.closeBundle,
+		);
+
+		expect(fs.existsSync(path.join(root, "one", "a.js"))).toBe(true);
+		expect(fs.existsSync(path.join(root, "two", "a.js"))).toBe(true);
+	});
+
+	it("throws when a destination does not exist", () => {
+		process.chdir(root);
+		expect(() =>
+			callHook(
+				VitePluginCloseAndCopy({ srcDir: "src", destDir: ["absent"] })
+					.closeBundle,
+			),
+		).toThrow();
+	});
+
+	it("logs the build error it is handed rather than swallowing it", () => {
+		const plugin = VitePluginCloseAndCopy();
+		expect(() =>
+			callHook(plugin.buildEnd, new Error("bundle blew up")),
+		).not.toThrow();
+	});
+
+	it("announces the start of the build", () => {
+		expect(() =>
+			callHook(
+				VitePluginCloseAndCopy().buildStart,
+				{} as Rollup.NormalizedInputOptions,
+			),
+		).not.toThrow();
+	});
+});
+
+/**
+ * Vite plugin hooks may be a bare function or an object with a `handler`.
+ * Neither of these hooks touches the rollup plugin context, so they are safe
+ * to call unbound.
+ */
+type Hook<A extends unknown[]> =
+	| ((...args: A) => unknown)
+	| { handler: (...args: A) => unknown }
+	| undefined;
+
+const callHook = <A extends unknown[]>(hook: Hook<A>, ...args: A): unknown => {
+	if (!hook) {
+		throw new Error("plugin does not define the hook");
+	}
+	const handler = typeof hook === "function" ? hook : hook.handler;
+	return handler(...args);
+};

package/src/vite/configs.test.ts

@@ -0,0 +1,217 @@
+// Copyright 2021-2026 Prosopo (UK) Ltd.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { nodejsPolarsDirnamePlugin } from "./NodejsPolarsDirnamePlugin.js";
+import ViteTestConfig from "./vite.test.config.js";
+import ViteThreadsTestConfig from "./vite.threads.test.config.js";
+
+const NATIVE_POLARS = "/repo/node_modules/nodejs-polars/bin/native-polars.js";
+
+let root: string;
+let cwd: string;
+let originalTestType: string | undefined;
+
+beforeEach(() => {
+	root = fs.mkdtempSync(path.join(os.tmpdir(), "prosopo-vite-config-test-"));
+	cwd = process.cwd();
+	originalTestType = process.env.TEST_TYPE;
+	process.env.TEST_TYPE = undefined;
+	// biome-ignore lint/performance/noDelete: the config reads presence, not value
+	delete process.env.TEST_TYPE;
+});
+
+afterEach(() => {
+	process.chdir(cwd);
+	if (originalTestType === undefined) {
+		// biome-ignore lint/performance/noDelete: restore absence, not ""
+		delete process.env.TEST_TYPE;
+	} else {
+		process.env.TEST_TYPE = originalTestType;
+	}
+	fs.rmSync(root, { recursive: true, force: true });
+});
+
+/** Make `root` look like a package (package.json + src) and chdir into it. */
+const asPackage = (): void => {
+	fs.writeFileSync(path.join(root, "package.json"), "{}");
+	fs.mkdirSync(path.join(root, "src"));
+	process.chdir(root);
+};
+
+/** Make `root` look like a repo root (no src dir) and chdir into it. */
+const asRepoRoot = (): void => {
+	fs.writeFileSync(path.join(root, "package.json"), "{}");
+	process.chdir(root);
+};
+
+describe("ViteTestConfig", () => {
+	it("enables coverage and typechecking by default", () => {
+		asPackage();
+		const config = ViteTestConfig();
+		expect(config.test?.coverage?.enabled).toBe(true);
+		expect(config.test?.typecheck?.enabled).toBe(true);
+		expect(config.test?.watch).toBe(false);
+	});
+
+	it("runs in forks, isolated, because low-level crypto needs it", () => {
+		asPackage();
+		const config = ViteTestConfig();
+		expect(config.test?.pool).toBe("forks");
+		expect(config.test?.isolate).toBe(true);
+	});
+
+	it("includes tests with no declared type when no filter is set", () => {
+		asPackage();
+		expect(config_include(ViteTestConfig())).toBe(
+			"src/**/*@(|).@(test|spec).@(mts|cts|mjs|cjs|js|ts|tsx|jsx)",
+		);
+	});
+
+	it("filters on a single declared test type", () => {
+		asPackage();
+		process.env.TEST_TYPE = "unit";
+		expect(config_include(ViteTestConfig())).toContain("@(.unit)");
+	});
+
+	it("filters on several test types", () => {
+		asPackage();
+		process.env.TEST_TYPE = "unit,integration";
+		expect(config_include(ViteTestConfig())).toContain("@(.unit|.integration)");
+	});
+
+	it("trims whitespace around the test type list", () => {
+		asPackage();
+		process.env.TEST_TYPE = "  unit  ";
+		expect(config_include(ViteTestConfig())).toContain("@(.unit)");
+	});
+
+	it("ignores an empty test type, keeping the default glob", () => {
+		asPackage();
+		process.env.TEST_TYPE = "";
+		expect(config_include(ViteTestConfig())).toContain("@(|)");
+	});
+
+	it("scopes coverage to the local src when run from a package", () => {
+		// Workspaces outside `packages/` were reporting 0/0 coverage because
+		// the repo-root globs only match `packages/*/src/**`.
+		asPackage();
+		const config = ViteTestConfig();
+		expect(config.test?.coverage?.include).toContain("src/**/*.ts");
+		expect(config.test?.coverage?.exclude).toContain("src/**/*.test.ts");
+	});
+
+	it("falls back to repo-wide globs when there is no src directory", () => {
+		asRepoRoot();
+		const config = ViteTestConfig();
+		expect(config.test?.coverage?.include).toEqual([
+			"packages/*/src/**",
+			"captcha/packages/*/src/**",
+		]);
+		expect(config.test?.coverage?.exclude).toContain("**/node_modules/**");
+	});
+
+	it("adds the tsconfig-paths plugin only when given a tsconfig", () => {
+		asPackage();
+		const withoutPaths = ViteTestConfig().plugins ?? [];
+		const tsConfigPath = path.join(root, "tsconfig.json");
+		fs.writeFileSync(tsConfigPath, "{}");
+		const withPaths = ViteTestConfig(tsConfigPath).plugins ?? [];
+		expect(withPaths.length).toBe(withoutPaths.length + 1);
+	});
+
+	it("always excludes node_modules and dist from the test run", () => {
+		asPackage();
+		expect(ViteTestConfig().test?.exclude).toEqual([
+			"**/node_modules/**",
+			"**/dist/**",
+		]);
+	});
+
+	it("disables sourcemaps and minification, which only cost time here", () => {
+		asPackage();
+		const config = ViteTestConfig();
+		expect(config.build?.minify).toBe(false);
+		expect(config.build?.sourcemap).toBe(false);
+	});
+});
+
+describe("ViteThreadsTestConfig", () => {
+	it("differs from the forks config only in its pool", () => {
+		asPackage();
+		expect(ViteThreadsTestConfig().test?.pool).toBe("threads");
+		expect(ViteTestConfig().test?.pool).toBe("forks");
+	});
+
+	it("keeps coverage and typechecking on", () => {
+		asPackage();
+		const config = ViteThreadsTestConfig();
+		expect(config.test?.coverage?.enabled).toBe(true);
+		expect(config.test?.typecheck?.enabled).toBe(true);
+	});
+});
+
+describe("nodejsPolarsDirnamePlugin", () => {
+	const plugin = nodejsPolarsDirnamePlugin();
+
+	it("claims only the native polars entry point", () => {
+		expect(plugin.resolveId(NATIVE_POLARS, undefined, {})).toBe(NATIVE_POLARS);
+		expect(plugin.resolveId("zod", undefined, {})).toBeNull();
+		expect(
+			plugin.resolveId("nodejs-polars/bin/other.js", undefined, {}),
+		).toBeNull();
+	});
+
+	it("rewrites __dirname to a path derived from import.meta.url", () => {
+		// The bundled output is a single ESM file, where `__dirname` does not
+		// exist; polars uses it to locate its native binary.
+		const code = "const a = __dirname; const b = __dirname;";
+		const transformed = plugin.transform(code, NATIVE_POLARS);
+		expect(transformed).not.toContain("__dirname");
+		expect(transformed).toContain("import.meta.url");
+		expect(transformed.match(/import\.meta\.url/g)).toHaveLength(2);
+	});
+
+	it("leaves every other module untouched", () => {
+		const code = "const a = __dirname;";
+		expect(plugin.transform(code, "/repo/src/index.ts")).toBe(code);
+	});
+
+	it("is named", () => {
+		expect(plugin.name).toBe("nodejs-polars-dirname-plugin");
+	});
+});
+
+/** The include glob is stored as a single-element array. */
+const config_include = (config: ReturnType<typeof ViteTestConfig>): string => {
+	const include = config.test?.include;
+	if (!include || !include[0]) {
+		throw new Error("config has no test include glob");
+	}
+	return include[0];
+};
+
+describe("coverage excludes", () => {
+	it("drops type-test files, which are compiled but never executed", () => {
+		// `src/**/*.d.ts` does not match `*.test-d.ts`, so without this every
+		// package reported its type tests as 0%-covered source.
+		asPackage();
+		const exclude = ViteTestConfig().test?.coverage?.exclude ?? [];
+		expect(exclude).toContain("src/**/*.test-d.ts");
+		expect(exclude).toContain("src/**/*.test-d.tsx");
+	});
+});

package/src/vite/index.ts

@@ -24,3 +24,4 @@ export { default as ViteEsmConfig } from "./vite.esm.config.js";
 export { default as VitePluginRemoveUnusedTranslations } from "./vite-plugin-remove-unused-translations.js";
 export * from "./TsNoCheckPlugin.js";
 export { default as VitePluginCopy } from "./vite-plugin-copy.js";
+export { default as VitePluginModifyExportsFiles } from "./vite-plugin-modify-exports-files.js";

package/src/vite/modifyExportsFiles.test.ts

@@ -0,0 +1,56 @@
+// Copyright 2021-2026 Prosopo (UK) Ltd.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import { describe, expect, test } from "vitest";
+import { emptyExportsFiles } from "./vite-plugin-modify-exports-files.js";
+
+describe("emptyExportsFiles", () => {
+	test("empties an assignment and keeps the code around it", () => {
+		expect(
+			emptyExportsFiles('a();\nexports2.FILES = ["a.js", "b.js"];\nb();'),
+		).toBe("a();\nexports2.FILES = [];\n\nb();");
+	});
+
+	test("empties every assignment, not just the first", () => {
+		const out = emptyExportsFiles(
+			'exports2.FILES = ["a"];exports2.FILES = ["b"];',
+		);
+		expect(out).toBe("exports2.FILES = [];\nexports2.FILES = [];\n");
+	});
+
+	test("spans newlines, as a formatted listing does", () => {
+		expect(emptyExportsFiles('exports2.FILES = [\n\t"a.js"\n];')).toBe(
+			"exports2.FILES = [];\n",
+		);
+	});
+
+	test("leaves code with no assignment untouched", () => {
+		expect(emptyExportsFiles("const FILES = [];")).toBe("const FILES = [];");
+	});
+
+	test("leaves an unterminated assignment alone rather than truncating", () => {
+		// Cutting to the end of the chunk here would delete real code.
+		const code = 'exports2.FILES = ["a.js"';
+		expect(emptyExportsFiles(code)).toBe(code);
+	});
+
+	test("stays linear on many unterminated assignments", () => {
+		// The regex this replaced backtracked quadratically on exactly this
+		// shape, which is what CodeQL flagged.
+		const code = "exports2.FILES = [".repeat(20000);
+		const started = performance.now();
+		expect(emptyExportsFiles(code)).toBe(code);
+		expect(performance.now() - started).toBeLessThan(1000);
+	});
+});