@01.works/visual-review 0.1.0

package/dist/source-instrumentation-transform-BwKYKlp0.js

@@ -0,0 +1,119 @@
+import { n as VISUAL_REVIEW_SOURCE_INDEX_ATTRIBUTE, o as visualReviewSourceMarker, r as VISUAL_REVIEW_SOURCE_MARKER_ATTRIBUTE, t as VISUAL_REVIEW_SOURCE_COORDINATE_ATTRIBUTE } from "./source-index-BdWeiNHZ.js";
+import { createHmac } from "node:crypto";
+import path, { win32 } from "node:path";
+import { parse } from "@babel/parser";
+import MagicString from "magic-string";
+//#region src/source-instrumentation-transform.ts
+const SOURCE_MODULE = /\.(?:[cm]?[jt]sx?)$/iu;
+const SKIPPED_PATH_SEGMENT = /(?:^|\/)(?:node_modules|\.next|dist|build)(?:\/|$)/u;
+const MARKER_SALT = /^[0-9a-f]{64}$/u;
+/**
+* Adds opaque, build-local markers to intrinsic JSX nodes. Repository paths
+* are used only to derive a digest and never enter the transformed browser
+* source. The final generated coordinates are emitted separately by the
+* framework adapter after bundling.
+*/
+function instrumentVisualReviewSource(source, options) {
+	assertMarkerSalt(options.markerSalt);
+	const sourcePath = normalizedProjectSourcePath(options.projectRoot, options.id);
+	if (!sourcePath) return null;
+	const ast = parse(source, {
+		errorRecovery: false,
+		plugins: parserPlugins(sourcePath),
+		sourceFilename: sourcePath,
+		sourceType: "unambiguous"
+	});
+	const edits = new MagicString(source);
+	let markerCount = 0;
+	const candidates = [];
+	visitAst(ast, (node) => {
+		if (node.type !== "JSXOpeningElement" || !isIntrinsicJsxName(node.name) || hasVisualReviewMarker(node.attributes) || typeof node.start !== "number" || typeof node.end !== "number" || !node.loc) return;
+		const nameEnd = intrinsicJsxNameEnd(node.name);
+		if (nameEnd === null || nameEnd <= node.start || nameEnd > node.end) return;
+		candidates.push({
+			column0: node.loc.start.column,
+			end: node.end,
+			line1: node.loc.start.line,
+			nameEnd,
+			selfClosing: node.selfClosing === true,
+			start: node.start
+		});
+	});
+	for (const candidate of candidates) {
+		const line1 = candidate.line1;
+		const column1 = candidate.column0 + 1;
+		const digest = createHmac("sha256", Buffer.from(options.markerSalt, "hex")).update(`${sourcePath}\0${line1}\0${column1}`).digest("hex").slice(0, 32);
+		const marker = visualReviewSourceMarker(digest);
+		const coordinate = `vrc1_${digest}`;
+		const closingWidth = candidate.selfClosing ? 2 : 1;
+		const insertionPoint = candidate.end - closingWidth;
+		const metadata = ` ${VISUAL_REVIEW_SOURCE_MARKER_ATTRIBUTE}="${marker}" ${VISUAL_REVIEW_SOURCE_INDEX_ATTRIBUTE}="${options.indexUrl}"`;
+		edits.overwrite(candidate.start, candidate.nameEnd, `${source.slice(candidate.start, candidate.nameEnd)} ${VISUAL_REVIEW_SOURCE_COORDINATE_ATTRIBUTE}="${coordinate}"`);
+		edits.appendLeft(insertionPoint, metadata);
+		markerCount += 1;
+	}
+	if (markerCount === 0) return null;
+	return {
+		code: edits.toString(),
+		map: edits.generateMap({
+			hires: true,
+			includeContent: true,
+			source: sourcePath
+		}),
+		markerCount
+	};
+}
+function assertMarkerSalt(value) {
+	if (!MARKER_SALT.test(value)) throw new Error("Visual Review source marker salt must be a lowercase 32-byte hex secret");
+}
+/**
+* Reports whether a module is first-party project source. Bundler rules already
+* try to exclude dependencies, but Next 15's Turbopack does not honour the
+* `foreign` condition, so the loader enforces the same boundary itself.
+*/
+function isVisualReviewProjectSource(projectRoot, id) {
+	return normalizedProjectSourcePath(projectRoot, id) !== null;
+}
+function normalizedProjectSourcePath(projectRoot, id) {
+	const cleanId = id.replace(/[?#].*$/u, "");
+	if (!SOURCE_MODULE.test(cleanId) || cleanId.endsWith(".d.ts")) return null;
+	const pathApi = /^[a-z]:[\\/]/iu.test(projectRoot) || /^[a-z]:[\\/]/iu.test(cleanId) ? win32 : path;
+	const root = pathApi.resolve(projectRoot);
+	const absolute = pathApi.resolve(cleanId);
+	const candidate = pathApi.relative(root, absolute);
+	if (!candidate || candidate === ".." || candidate.startsWith(`..${pathApi.sep}`) || pathApi.isAbsolute(candidate)) return null;
+	const normalized = candidate.split(pathApi.sep).join("/");
+	return SKIPPED_PATH_SEGMENT.test(normalized) ? null : normalized;
+}
+function parserPlugins(sourcePath) {
+	const plugins = ["jsx", "importAttributes"];
+	if (/\.(?:[cm]?tsx?)$/iu.test(sourcePath)) plugins.push("typescript");
+	return plugins;
+}
+function isIntrinsicJsxName(name) {
+	if (!name || typeof name === "string" || name.type !== "JSXIdentifier") return false;
+	const value = typeof name.name === "string" ? name.name : "";
+	return Boolean(value) && value[0] === value[0]?.toLowerCase();
+}
+function intrinsicJsxNameEnd(name) {
+	if (!isIntrinsicJsxName(name)) return null;
+	const candidate = name;
+	return typeof candidate.end === "number" ? candidate.end : null;
+}
+function hasVisualReviewMarker(attributes) {
+	return attributes?.some((attribute) => attribute.type === "JSXAttribute" && typeof attribute.name !== "string" && attribute.name?.type === "JSXIdentifier" && (attribute.name.name === "data-visual-review-source" || attribute.name.name === "data-visual-review-source-coordinate" || attribute.name.name === "data-visual-review-source-index" || attribute.name.name === "data-review-source")) ?? false;
+}
+function visitAst(node, visitor) {
+	visitor(node);
+	for (const [key, value] of Object.entries(node)) {
+		if (key === "loc" || key === "start" || key === "end") continue;
+		if (Array.isArray(value)) {
+			for (const child of value) if (isAstNode(child)) visitAst(child, visitor);
+		} else if (isAstNode(value)) visitAst(value, visitor);
+	}
+}
+function isAstNode(value) {
+	return Boolean(value) && typeof value === "object" && typeof value.type === "string";
+}
+//#endregion
+export { isVisualReviewProjectSource as n, instrumentVisualReviewSource as t };

package/dist/source-loader.js

@@ -0,0 +1,127 @@
+import { n as isVisualReviewProjectSource, t as instrumentVisualReviewSource } from "./source-instrumentation-transform-BwKYKlp0.js";
+import { readFileSync } from "node:fs";
+import { transformSync } from "@babel/core";
+import transformReactJsx from "@babel/plugin-transform-react-jsx";
+import transformTypeScript from "@babel/plugin-transform-typescript";
+//#region src/source-loader.ts
+const MARKER_SALT = /^[0-9a-f]{64}$/u;
+const saltCache = /* @__PURE__ */ new Map();
+/**
+* Reads a build-local marker salt. Next serializes loader options into
+* `required-server-files.json` and into Turbopack edge chunks, so the adapter
+* publishes only this path and keeps the secret in an owner-only file.
+*/
+function readMarkerSaltFile(saltPath) {
+	const cached = saltCache.get(saltPath);
+	if (cached !== void 0) return cached;
+	let contents;
+	try {
+		contents = readFileSync(saltPath, "utf8").trim();
+	} catch {
+		throw new Error("Visual Review source loader could not read the marker salt");
+	}
+	if (!MARKER_SALT.test(contents)) throw new Error("Visual Review source loader marker salt is invalid");
+	saltCache.set(saltPath, contents);
+	return contents;
+}
+function visualReviewSourceLoader(source, inputMap) {
+	const done = this.async();
+	try {
+		const options = parseOptions(this.getOptions?.());
+		const projectRoot = options.projectRoot ?? this.rootContext;
+		if (!isVisualReviewProjectSource(projectRoot, this.resourcePath)) {
+			done(null, source, inputMap);
+			return;
+		}
+		const transformed = instrumentVisualReviewSource(source, {
+			id: this.resourcePath,
+			indexUrl: options.indexUrl,
+			markerSalt: options.markerSalt,
+			projectRoot
+		});
+		const code = transformed?.code ?? source;
+		const map = transformed?.map ?? inputMap;
+		if (options.compile) {
+			const compiled = compileForTurbopack(code, map, this.resourcePath, transformed !== null);
+			done(null, compiled.code, compiled.map);
+			return;
+		}
+		if (!transformed) {
+			done(null, source, inputMap);
+			return;
+		}
+		done(null, transformed.code, transformed.map);
+	} catch (cause) {
+		done(cause instanceof Error ? cause : new Error(String(cause)));
+	}
+}
+function compileForTurbopack(source, inputMap, filename, instrumented) {
+	const isTypeScript = /\.(?:[cm]?tsx?)$/iu.test(filename);
+	const isTsx = /\.(?:[cm]?tsx)$/iu.test(filename);
+	const result = transformSync(source, {
+		babelrc: false,
+		comments: true,
+		compact: false,
+		configFile: false,
+		filename,
+		inputSourceMap: normalizeTurbopackInputMap(inputMap, filename, instrumented),
+		plugins: [...isTypeScript ? [[transformTypeScript, {
+			allExtensions: true,
+			allowDeclareFields: true,
+			isTSX: isTsx
+		}]] : [], [transformReactJsx, { runtime: "automatic" }]],
+		retainLines: true,
+		sourceMaps: true,
+		sourceType: "unambiguous"
+	});
+	if (typeof result?.code !== "string") throw new Error("Visual Review source loader could not compile the module");
+	return {
+		code: result.code,
+		map: result.map
+	};
+}
+function normalizeTurbopackInputMap(value, filename, instrumented) {
+	const normalized = normalizeInputMap(value);
+	if (!normalized || !instrumented) return normalized;
+	if (!Array.isArray(normalized.sources) || normalized.sources.length !== 1) throw new Error("Visual Review source loader produced an invalid source map");
+	const resourceFilename = filename.replaceAll("\\", "/").split("/").at(-1);
+	if (!resourceFilename || resourceFilename === "." || resourceFilename === "..") throw new Error("Visual Review source loader resource path is invalid");
+	return {
+		...normalized,
+		sourceRoot: "",
+		sources: [resourceFilename]
+	};
+}
+function normalizeInputMap(value) {
+	if (!value) return void 0;
+	if (typeof value === "string") return parsedSourceMap(value);
+	if (typeof value === "object" && "toString" in value) {
+		const serialized = String(value);
+		if (serialized.startsWith("{")) return parsedSourceMap(serialized);
+	}
+	return isRecord(value) ? value : void 0;
+}
+function parsedSourceMap(value) {
+	const parsed = JSON.parse(value);
+	if (!isRecord(parsed)) throw new Error("Visual Review source loader received an invalid source map");
+	return parsed;
+}
+function isRecord(value) {
+	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function parseOptions(value) {
+	if (!value || typeof value !== "object") throw new Error("Visual Review source loader options are missing");
+	const options = value;
+	if (typeof options.indexUrl !== "string" || !options.indexUrl.startsWith("/") || options.indexUrl.startsWith("//") || options.indexUrl.includes("\\")) throw new Error("Visual Review source loader index URL is invalid");
+	if (options.projectRoot !== void 0 && typeof options.projectRoot !== "string") throw new Error("Visual Review source loader project root is invalid");
+	const markerSalt = typeof options.saltPath === "string" ? readMarkerSaltFile(options.saltPath) : options.markerSalt;
+	if (typeof markerSalt !== "string" || !MARKER_SALT.test(markerSalt)) throw new Error("Visual Review source loader marker salt is invalid");
+	return {
+		...options.compile === true ? { compile: true } : {},
+		indexUrl: options.indexUrl,
+		markerSalt,
+		...typeof options.projectRoot === "string" ? { projectRoot: options.projectRoot } : {}
+	};
+}
+//#endregion
+export { visualReviewSourceLoader as default, normalizeTurbopackInputMap };