ccqa-tools 1.37.0

package/dist/coverage/next.js

@@ -0,0 +1,100 @@
+import { createRequire } from "node:module";
+import { resolve } from "node:path";
+//#region src/coverage/wire.ts
+/**
+* Enables the instrumentation. Unset means the register hook is never loaded
+* and the application pays nothing at all.
+*
+* `1` / `true` turns it on and leaves attribution to the incoming carrier.
+* Any other value is itself a `<runId>.<specId>` and becomes the ambient spec
+* for the process — the only way to attribute an entry point that has no
+* inbound request to read, such as a worker started per spec.
+*/
+const ENV_NAME = "CCQA_COVERAGE";
+const SPEC_ID = /^[A-Za-z0-9._\-/]{1,200}$/;
+/**
+* Accepts a carrier value only if it looks like an id we wrote.
+*
+* The cookie is client-controlled, so this is the first of two gates: the
+* second is the hub refusing runs it never started.
+*/
+function parseSpecId(raw) {
+	if (!raw) return void 0;
+	const value = raw.trim();
+	if (!SPEC_ID.test(value)) return void 0;
+	if (value === "1" || value === "true") return void 0;
+	return value;
+}
+//#endregion
+//#region src/coverage/runtime-env.ts
+function readConfig(env = process.env) {
+	const raw = env[ENV_NAME];
+	const include = (env["CCQA_COVERAGE_INCLUDE"] ?? "src").split(",").map((entry) => entry.trim()).filter((entry) => entry.length > 0);
+	return {
+		enabled: raw !== void 0 && raw !== "" && raw !== "0" && raw !== "false",
+		ambientSpecId: parseSpecId(raw),
+		root: env["CCQA_COVERAGE_ROOT"] ?? process.cwd(),
+		include,
+		debug: env["CCQA_COVERAGE_DEBUG"] === "1" || env["CCQA_COVERAGE_DEBUG"] === "true"
+	};
+}
+/**
+* Diagnostics go to stderr and nowhere else. A `--import` preload is inherited
+* by every child node process, and writing to stdout corrupts whatever the host
+* was parsing there — enough to make a framework's own toolchain fail to start.
+*/
+function debugLog(config, message) {
+	if (!config.debug) return;
+	process.stderr.write(`[ccqa-tools] ${message}\n`);
+}
+//#endregion
+//#region src/coverage/next/index.ts
+/**
+* Next.js integration.
+*
+* Next bundles its server code, so the load hooks in
+* `ccqa-tools/coverage/register` never see the application's own modules — only the
+* bundle. The instrumentation therefore has to happen at build time, while the
+* context that attributes it still comes from the register hook wrapping
+* `node:http`. Both halves are required:
+*
+*   // next.config.ts
+*   export default withCoverage({ ...yourConfig })
+*
+*   NODE_OPTIONS='--import ccqa-tools/coverage/register' CCQA_COVERAGE=1 next start
+*
+* Only server bundles are instrumented. Instrumenting the client would ship
+* `__ccqaCoverage` calls to browsers, where the front-end side of ccqa's
+* coverage already reads V8's own counters and needs nothing injected.
+*/
+const require = createRequire(import.meta.url);
+/** Wraps a Next config, preserving any `webpack` hook it already has. */
+function withCoverage(config, options = {}) {
+	if (!(options.enabled ?? process.env["CCQA_COVERAGE"] !== void 0)) return config;
+	const root = resolve(options.root ?? readConfig().root);
+	const include = (options.include ?? ["src"]).map((dir) => resolve(root, dir));
+	const previous = config.webpack;
+	return {
+		...config,
+		webpack(webpackConfig, context) {
+			const next = previous ? previous(webpackConfig, context) : webpackConfig;
+			if (!context.isServer) return next;
+			next.module ??= {};
+			next.module.rules ??= [];
+			next.module.rules.push({
+				enforce: "post",
+				test: /\.(?:[cm]?js|jsx|tsx?)$/,
+				include,
+				exclude: /[\\/]node_modules[\\/]/,
+				use: [{
+					loader: require.resolve("./next-loader.cjs"),
+					options: { root }
+				}]
+			});
+			debugLog(readConfig(), `instrumenting server bundles under ${include.join(", ")}`);
+			return next;
+		}
+	};
+}
+//#endregion
+export { withCoverage };