@prosopo/config 3.4.1 → 3.4.3

package/src/vite/configs.test.ts

@@ -1,235 +0,0 @@
-// 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 type { Rollup } from "vite";
-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";
-
-const resolveOptions: Rollup.ResolveIdExtraOptions = {
-	isEntry: false,
-	kind: "import-statement",
-};
-
-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();
-		// Vitest's coverage type is a discriminated union on `provider`; the
-		// custom-provider variant doesn't declare `include`/`exclude` even
-		// though they're valid at runtime for every provider. Cast to the v8
-		// variant (which does declare them) for assertion purposes only.
-		const coverage = config.test?.coverage as
-			| { include?: unknown; exclude?: unknown }
-			| undefined;
-		expect(coverage?.include).toContain("src/**/*.ts");
-		expect(coverage?.exclude).toContain("src/**/*.test.ts");
-	});
-
-	it("falls back to repo-wide globs when there is no src directory", () => {
-		asRepoRoot();
-		const config = ViteTestConfig();
-		const coverage = config.test?.coverage as
-			| { include?: unknown; exclude?: unknown }
-			| undefined;
-		expect(coverage?.include).toEqual([
-			"packages/*/src/**",
-			"captcha/packages/*/src/**",
-		]);
-		expect(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, resolveOptions)).toBe(
-			NATIVE_POLARS,
-		);
-		expect(plugin.resolveId("zod", undefined, resolveOptions)).toBeNull();
-		expect(
-			plugin.resolveId("nodejs-polars/bin/other.js", undefined, resolveOptions),
-		).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

@@ -1,30 +0,0 @@
-// 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.
-export { default as VitePluginCloseAndCopy } from "./vite-plugin-close-and-copy.js";
-export { default as VitePluginExternalizeObfuscatorDeadCode } from "./vite-plugin-externalize-obfuscator-deadcode.js";
-export { default as ViteTestConfig } from "./vite.test.config.js";
-export { default as ViteThreadsTestConfig } from "./vite.threads.test.config.js";
-export { default as VitePluginSourceMapExclude } from "./vite-plugin-sourcemap-exclude.js";
-export { default as ViteFrontendConfig } from "./vite.frontend.config.js";
-export { default as ViteBackendConfig } from "./vite.backend.config.js";
-export { default as VitePluginFixAbsoluteImports } from "./vite-plugin-fix-absolute-imports.js";
-export { default as ViteCommonJSConfig } from "./vite.commonjs.config.js";
-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";
-export { copyAssetsPlugin } from "./CopyAssetsPlugin.js";
-export type { CopyAssetEntry } from "./CopyAssetsPlugin.js";
-export { nodejsPolarsNativeFilePlugin } from "./NodejsPolarsNativeFilePlugin.js";

package/src/vite/modifyExportsFiles.test.ts

@@ -1,56 +0,0 @@
-// 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);
-	});
-});

package/src/vite/plugins.test.ts

@@ -1,365 +0,0 @@
-// 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 type { Rollup } from "vite";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { tsNoCheckPlugin } from "./TsNoCheckPlugin.js";
-import VitePluginCopy from "./vite-plugin-copy.js";
-import VitePluginExternalizeObfuscatorDeadCode from "./vite-plugin-externalize-obfuscator-deadcode.js";
-import VitePluginFixAbsoluteImports from "./vite-plugin-fix-absolute-imports.js";
-import {
-	flatten,
-	unflatten,
-} from "./vite-plugin-remove-unused-translations.js";
-import VitePluginSourcemapExclude from "./vite-plugin-sourcemap-exclude.js";
-
-/**
- * Vite plugin hooks are declared as `hook | { handler }` objects, so they are
- * pulled out through a narrowing helper rather than being called directly.
- */
-const handlerOf = <T>(hook: T | { handler: T } | undefined): T => {
-	if (!hook) {
-		throw new Error("plugin does not define the hook");
-	}
-	return typeof hook === "function" ? hook : (hook as { handler: T }).handler;
-};
-
-describe("VitePluginSourcemapExclude", () => {
-	const transformOf = (opts?: { excludeNodeModules?: boolean }) => {
-		const plugin = VitePluginSourcemapExclude(opts);
-		return handlerOf(plugin.transform) as (
-			code: string,
-			id: string,
-		) => { code: string; map: { mappings: string } } | undefined;
-	};
-
-	it("is named so it can be found in a plugin list", () => {
-		expect(VitePluginSourcemapExclude().name).toBe("sourcemap-exclude");
-	});
-
-	it("blanks the sourcemap for node_modules when asked", () => {
-		// The whole point is to stop Vite holding megabytes of vendor
-		// sourcemaps in memory.
-		const result = transformOf({ excludeNodeModules: true })(
-			"code",
-			"/repo/node_modules/zod/index.js",
-		);
-		expect(result).toEqual({ code: "code", map: { mappings: "" } });
-	});
-
-	it("leaves first-party code alone", () => {
-		expect(
-			transformOf({ excludeNodeModules: true })("code", "/repo/src/index.ts"),
-		).toBeUndefined();
-	});
-
-	it("does nothing without the option, or with no options at all", () => {
-		expect(
-			transformOf({})("code", "/repo/node_modules/zod/index.js"),
-		).toBeUndefined();
-		expect(
-			transformOf()("code", "/repo/node_modules/zod/index.js"),
-		).toBeUndefined();
-		expect(
-			transformOf({ excludeNodeModules: false })(
-				"code",
-				"/repo/node_modules/zod/index.js",
-			),
-		).toBeUndefined();
-	});
-
-	it("matches node_modules anywhere in the id, including nested copies", () => {
-		expect(
-			transformOf({ excludeNodeModules: true })(
-				"code",
-				"/repo/node_modules/a/node_modules/b/index.js",
-			),
-		).toBeDefined();
-	});
-});
-
-describe("VitePluginFixAbsoluteImports", () => {
-	const transform = handlerOf(VitePluginFixAbsoluteImports().transform) as (
-		code: string,
-		id: string,
-	) => { code: string };
-
-	it("runs after other plugins have emitted their imports", () => {
-		const plugin = VitePluginFixAbsoluteImports();
-		expect(plugin.name).toBe("fix-absolute-imports");
-		expect(plugin.enforce).toBe("post");
-	});
-
-	it("rewrites a deep builtin import back to the bare specifier", () => {
-		// `from "node:fs/promises/index.js"` is not resolvable at runtime;
-		// the bare builtin is.
-		expect(transform('import x from "fs/promises/index.js";', "id").code).toBe(
-			'import x from "fs";',
-		);
-	});
-
-	it("rewrites every occurrence in a file", () => {
-		const code = 'from "path/posix/x.js";\nfrom "path/win32/y.js";';
-		expect(transform(code, "id").code).toBe('from "path";\nfrom "path";');
-	});
-
-	it("leaves a bare builtin import untouched", () => {
-		const code = 'import fs from "fs";';
-		expect(transform(code, "id").code).toBe(code);
-	});
-
-	it("leaves third-party deep imports untouched", () => {
-		const code = 'import x from "zod/lib/index.js";';
-		expect(transform(code, "id").code).toBe(code);
-	});
-
-	it("returns empty code unchanged", () => {
-		expect(transform("", "id").code).toBe("");
-	});
-});
-
-describe("tsNoCheckPlugin", () => {
-	const outputOptions = {} as Rollup.NormalizedOutputOptions;
-
-	it("prefixes every emitted chunk with a ts-nocheck pragma", () => {
-		// Consumers typecheck the bundled output; without this the generated
-		// code fails their build.
-		const bundle = {
-			"index.js": {
-				type: "chunk",
-				code: "export const a = 1;",
-			} as Rollup.OutputChunk,
-			"other.js": {
-				type: "chunk",
-				code: "export const b = 2;",
-			} as Rollup.OutputChunk,
-		};
-		tsNoCheckPlugin().generateBundle(
-			outputOptions,
-			bundle as Rollup.OutputBundle,
-		);
-
-		expect(bundle["index.js"].code).toBe("// @ts-nocheck\nexport const a = 1;");
-		expect(bundle["other.js"].code).toBe("// @ts-nocheck\nexport const b = 2;");
-	});
-
-	it("leaves assets and empty chunks alone", () => {
-		const bundle = {
-			"style.css": { type: "asset", source: "body{}" } as Rollup.OutputAsset,
-			"empty.js": { type: "chunk", code: "" } as Rollup.OutputChunk,
-		};
-		tsNoCheckPlugin().generateBundle(
-			outputOptions,
-			bundle as Rollup.OutputBundle,
-		);
-
-		expect(bundle["style.css"]).toEqual({ type: "asset", source: "body{}" });
-		expect(bundle["empty.js"].code).toBe("");
-	});
-
-	it("handles an empty bundle", () => {
-		expect(() =>
-			tsNoCheckPlugin().generateBundle(outputOptions, {}),
-		).not.toThrow();
-	});
-
-	it("is named", () => {
-		expect(tsNoCheckPlugin().name).toBe("vite-plugin-ts-nocheck");
-	});
-});
-
-describe("VitePluginExternalizeObfuscatorDeadCode", () => {
-	const resolveId = handlerOf(
-		VitePluginExternalizeObfuscatorDeadCode().resolveId,
-	) as (source: string) => { id: string; external: boolean } | null;
-
-	it("runs before resolution so rolldown never sees the specifier", () => {
-		const plugin = VitePluginExternalizeObfuscatorDeadCode();
-		expect(plugin.name).toBe("externalize-obfuscator-deadcode");
-		expect(plugin.enforce).toBe("pre");
-	});
-
-	it("externalises each known dead-code specifier", () => {
-		// Rolldown treats an unresolved import as a hard error, so missing one
-		// of these breaks the obfuscated build outright.
-		for (const source of [
-			"../../package",
-			"../redacted.js",
-			"../utils/isStandaloneExecutable",
-			"./resolve-local-redacted-path",
-			"@redacted/components/package",
-			"@redacted/enterprise-plugin",
-			"@redacted/enterprise-plugin/package",
-		]) {
-			expect(resolveId(source), source).toEqual({ id: source, external: true });
-		}
-	});
-
-	it("defers every other specifier to the normal resolver", () => {
-		for (const source of [
-			"zod",
-			"./real-module.js",
-			"",
-			"../../package.json",
-		]) {
-			expect(resolveId(source), source).toBeNull();
-		}
-	});
-
-	it("matches exactly, not by prefix", () => {
-		expect(resolveId("@redacted/enterprise-plugin/extra")).toBeNull();
-	});
-});
-
-describe("VitePluginCopy", () => {
-	let root: string;
-	let cwd: string;
-
-	beforeEach(() => {
-		root = fs.mkdtempSync(path.join(os.tmpdir(), "prosopo-copy-test-"));
-		cwd = process.cwd();
-		process.chdir(root);
-		fs.mkdirSync(path.join(root, "src", "nested"), { recursive: true });
-		fs.writeFileSync(path.join(root, "src", "a.txt"), "a");
-		fs.writeFileSync(path.join(root, "src", "b.md"), "b");
-		fs.writeFileSync(path.join(root, "src", "nested", "c.txt"), "c");
-	});
-
-	afterEach(() => {
-		process.chdir(cwd);
-		fs.rmSync(root, { recursive: true, force: true });
-	});
-
-	const run = async (options: Parameters<typeof VitePluginCopy>[0]) => {
-		const plugin = VitePluginCopy(options);
-		const closeBundle = handlerOf(plugin.closeBundle) as () => Promise<void>;
-		await closeBundle();
-	};
-
-	it("copies matching files and creates the destination tree", async () => {
-		await run({ srcDir: "src", destDir: "dist", include: ["**/*.txt"] });
-
-		expect(fs.readFileSync(path.join(root, "dist", "a.txt"), "utf8")).toBe("a");
-		expect(
-			fs.readFileSync(path.join(root, "dist", "nested", "c.txt"), "utf8"),
-		).toBe("c");
-		expect(fs.existsSync(path.join(root, "dist", "b.md"))).toBe(false);
-	});
-
-	it("honours the exclude globs", async () => {
-		await run({
-			srcDir: "src",
-			destDir: "dist",
-			include: ["**/*.txt"],
-			exclude: ["nested/**"],
-		});
-
-		expect(fs.existsSync(path.join(root, "dist", "a.txt"))).toBe(true);
-		expect(fs.existsSync(path.join(root, "dist", "nested"))).toBe(false);
-	});
-
-	it("copies nothing, and says so, when no include glob is given", async () => {
-		// Copying the whole tree by default would silently ship sources.
-		const info = vi.spyOn(console, "info").mockImplementation(() => undefined);
-		await run({ srcDir: "src", destDir: "dist" });
-
-		expect(fs.existsSync(path.join(root, "dist"))).toBe(false);
-		expect(info).toHaveBeenCalledWith(
-			"[copy-plugin] No include globs specified, nothing to copy.",
-		);
-		info.mockRestore();
-	});
-
-	it("treats an empty include list as no include list", async () => {
-		await run({ srcDir: "src", destDir: "dist", include: [] });
-		expect(fs.existsSync(path.join(root, "dist"))).toBe(false);
-	});
-
-	it("succeeds when nothing matches", async () => {
-		await run({ srcDir: "src", destDir: "dist", include: ["**/*.nope"] });
-		expect(fs.existsSync(path.join(root, "dist"))).toBe(false);
-	});
-
-	it("overwrites an existing destination file", async () => {
-		fs.mkdirSync(path.join(root, "dist"), { recursive: true });
-		fs.writeFileSync(path.join(root, "dist", "a.txt"), "stale");
-		await run({ srcDir: "src", destDir: "dist", include: ["a.txt"] });
-		expect(fs.readFileSync(path.join(root, "dist", "a.txt"), "utf8")).toBe("a");
-	});
-
-	it("is named", () => {
-		expect(VitePluginCopy({ srcDir: "s", destDir: "d" }).name).toBe(
-			"copy-plugin",
-		);
-	});
-});
-
-describe("translation flatten/unflatten", () => {
-	it("flattens nested objects to dotted keys", () => {
-		expect(flatten({ a: { b: { c: "x" } }, d: "y" })).toEqual({
-			"a.b.c": "x",
-			d: "y",
-		});
-	});
-
-	it("returns an empty object for an empty input", () => {
-		expect(flatten({})).toEqual({});
-	});
-
-	it("applies a prefix", () => {
-		expect(flatten({ a: "x" }, "p.")).toEqual({ "p.a": "x" });
-	});
-
-	it("treats arrays as objects, keying by index", () => {
-		expect(flatten({ a: ["x", "y"] })).toEqual({ "a.0": "x", "a.1": "y" });
-	});
-
-	it("round trips a nested object", () => {
-		const original = { a: { b: "x" }, c: "y" };
-		expect(unflatten(flatten(original))).toEqual(original);
-	});
-
-	it("rebuilds arrays when the next key is numeric", () => {
-		// Locale files contain arrays of strings; turning them into objects
-		// keyed "0", "1" would change the shape the app reads at runtime.
-		expect(unflatten({ "a.0": "x", "a.1": "y" })).toEqual({ a: ["x", "y"] });
-	});
-
-	it("keeps object keys that merely look like words", () => {
-		expect(unflatten({ "a.b": "x" })).toEqual({ a: { b: "x" } });
-	});
-
-	it("merges sibling keys under one parent", () => {
-		expect(unflatten({ "a.b": "x", "a.c": "y" })).toEqual({
-			a: { b: "x", c: "y" },
-		});
-	});
-
-	it("handles a top-level key with no dots", () => {
-		expect(unflatten({ a: "x" })).toEqual({ a: "x" });
-	});
-
-	it("returns an empty object for an empty input", () => {
-		expect(unflatten({})).toEqual({});
-	});
-
-	it("preserves non-string leaf values", () => {
-		expect(unflatten({ "a.b": 1, "a.c": true })).toEqual({
-			a: { b: 1, c: true },
-		});
-	});
-});