@generaltranslation/vue-extractor 0.0.0 → 0.1.0-iris.0

package/dist/internal/config/resolveVueCompilerOptions.js

@@ -1,36 +1,11 @@
+import { NUXT_CONFIG_FILES, VITE_CONFIG_EXTENSIONS, VITE_CONFIG_FILES } from "./configFiles.js";
 import fs from "node:fs";
 import path from "node:path";
 import { parse } from "@babel/parser";
 import traverseModule from "@babel/traverse";
-import { createDiagnosticMessage } from "generaltranslation/internal";
+import { createDiagnosticMessage, formatDiagnosticErrorDetails } from "generaltranslation/internal";
 //#region src/internal/config/resolveVueCompilerOptions.ts
 const traverse = traverseModule.default || traverseModule;
-const VITE_CONFIG_FILES = [
-	"vite.config.js",
-	"vite.config.mjs",
-	"vite.config.ts",
-	"vite.config.cjs",
-	"vite.config.mts",
-	"vite.config.cts"
-];
-const NUXT_CONFIG_FILES = [
-	"nuxt.config.js",
-	"nuxt.config.ts",
-	"nuxt.config.mjs",
-	"nuxt.config.cjs",
-	"nuxt.config.mts",
-	"nuxt.config.cts"
-];
-const CUSTOM_VITE_CONFIG_EXTENSIONS = new Set([
-	".js",
-	".jsx",
-	".mjs",
-	".cjs",
-	".ts",
-	".tsx",
-	".mts",
-	".cts"
-]);
 /**
 * Resolves hash-affecting Vue template compiler options without executing
 * project configuration files.
@@ -49,14 +24,14 @@ function resolveVueCompilerOptions(cwd, explicitOptions, resolverOptions = {}) {
 	readExplicitOptions(explicitOptions, state, errors);
 	if (resolverOptions.viteConfigPath !== void 0) {
 		const file = resolveCustomViteConfig(cwd, resolverOptions.viteConfigPath, errors);
-		if (file) readViteConfig(file, state, errors);
+		if (file) readViteConfig(file, state, errors, true);
 		return {
 			compilerOptions: state.options,
 			errors
 		};
 	}
-	const nuxtConfig = findFirstConfig(cwd, NUXT_CONFIG_FILES);
-	const viteConfig = findFirstConfig(cwd, VITE_CONFIG_FILES);
+	const nuxtConfig = findFirstConfig(cwd, NUXT_CONFIG_FILES, errors);
+	const viteConfig = findFirstConfig(cwd, VITE_CONFIG_FILES, errors);
 	if (nuxtConfig && viteConfig) {
 		errors.push(optionError("Found both Nuxt and Vite project config files", "For direct Vite builds, set files.gt.parsingFlags.viteConfigPath to the active Vite config. For Nuxt builds, remove or relocate the inactive Vite config so the compiler configuration is unambiguous"));
 		return {
@@ -65,23 +40,24 @@ function resolveVueCompilerOptions(cwd, explicitOptions, resolverOptions = {}) {
 		};
 	}
 	if (nuxtConfig) {
-		readNuxtConfig(nuxtConfig, state, errors);
+		readNuxtConfig(nuxtConfig, state, errors, resolverOptions.sourceDiscoveryIsExplicit ?? false);
 		return {
 			compilerOptions: state.options,
 			errors
 		};
 	}
-	if (viteConfig) readViteConfig(viteConfig, state, errors);
+	if (viteConfig) readViteConfig(viteConfig, state, errors, resolverOptions.sourceDiscoveryIsExplicit ?? false);
 	return {
 		compilerOptions: state.options,
 		errors
 	};
 }
 /** Selects the first config file in the framework's documented lookup order. */
-function findFirstConfig(cwd, filenames) {
+function findFirstConfig(cwd, filenames, errors) {
 	for (const filename of filenames) {
-		const file = path.resolve(cwd, filename);
-		if (fs.existsSync(file)) return file;
+		const resolution = inspectConfigFile(path.resolve(cwd), path.resolve(cwd, filename), false, errors);
+		if (resolution.kind === "file") return resolution.file;
+		if (resolution.kind === "invalid") return void 0;
 	}
 }
 /** Validates an explicit Vite config without searching or executing files. */
@@ -97,22 +73,44 @@ function resolveCustomViteConfig(cwd, configuredPath, errors) {
 		errors.push(optionError("Found a Vite config path outside the project source boundary", "Choose a Vite config file inside the project root and outside node_modules"));
 		return;
 	}
-	if (!CUSTOM_VITE_CONFIG_EXTENSIONS.has(path.extname(candidate).toLowerCase())) {
+	if (!VITE_CONFIG_EXTENSIONS.has(path.extname(candidate).toLowerCase())) {
 		errors.push(optionError("Found an unsupported Vite config file extension", "Use a JavaScript or TypeScript Vite config file"));
 		return;
 	}
-	if (!fs.existsSync(candidate) || !fs.statSync(candidate).isFile()) {
-		errors.push(optionError("Could not find the configured Vite config file", "Set files.gt.parsingFlags.viteConfigPath to an existing file inside the project root"));
-		return;
-	}
-	const realRoot = fs.realpathSync(root);
-	const realCandidate = fs.realpathSync(candidate);
-	const realRelative = path.relative(realRoot, realCandidate);
-	if (realRelative.startsWith(`..${path.sep}`) || realRelative === ".." || path.isAbsolute(realRelative) || realRelative.split(path.sep).includes("node_modules")) {
-		errors.push(optionError("Found a Vite config path outside the project source boundary", "Choose a Vite config file inside the project root and outside node_modules"));
-		return;
+	const resolution = inspectConfigFile(root, candidate, true, errors);
+	return resolution.kind === "file" ? resolution.file : void 0;
+}
+/** Validates one config candidate without letting filesystem races escape. */
+function inspectConfigFile(root, candidate, missingIsError, errors) {
+	let candidateWasFound = false;
+	try {
+		const stats = fs.statSync(candidate);
+		candidateWasFound = true;
+		if (!stats.isFile()) {
+			errors.push(configFileDiagnostic("Found a Vue project config path that is not a regular file", "Replace it with a readable JavaScript or TypeScript config file", candidate));
+			return { kind: "invalid" };
+		}
+		fs.accessSync(candidate, fs.constants.R_OK);
+		const realRoot = fs.realpathSync(root);
+		const realCandidate = fs.realpathSync(candidate);
+		const realRelative = path.relative(realRoot, realCandidate);
+		if (realRelative.startsWith(`..${path.sep}`) || realRelative === ".." || path.isAbsolute(realRelative) || realRelative.split(path.sep).includes("node_modules")) {
+			errors.push(optionError("Found a Vue project config path outside the project source boundary", "Choose a project config file inside the project root and outside node_modules"));
+			return { kind: "invalid" };
+		}
+		return {
+			kind: "file",
+			file: realCandidate
+		};
+	} catch (error) {
+		if (isMissingPathError(error) && !missingIsError && !candidateWasFound) return { kind: "missing" };
+		if (isMissingPathError(error) && missingIsError && !candidateWasFound) errors.push(configFileDiagnostic("Could not find the configured Vite config file", "Set files.gt.parsingFlags.viteConfigPath to an existing file inside the project root", candidate, error));
+		else errors.push(configFileDiagnostic("Could not read the Vue project config file", "Restore read access to the config file and try extraction again", candidate, error));
+		return { kind: "invalid" };
 	}
-	return realCandidate;
+}
+function isMissingPathError(error) {
+	return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
 }
 function readExplicitOptions(input, state, errors) {
 	if (input === void 0) return;
@@ -126,8 +124,8 @@ function readExplicitOptions(input, state, errors) {
 	if (input.delimiters !== void 0) if (!isDelimiterPair(input.delimiters)) errors.push(optionError("Found invalid Vue interpolation delimiters in gt.config.json", "Set delimiters to exactly two non-empty strings, such as [\"[[\", \"]]\"]"));
 	else mergeOption(state, "delimiters", input.delimiters, { file: "gt.config.json" }, errors);
 }
-function readViteConfig(file, state, errors) {
-	const ast = parseConfig(file, errors);
+function readViteConfig(file, state, errors, reportAllSyntaxErrors) {
+	const ast = parseConfig(file, errors, reportAllSyntaxErrors);
 	if (!ast) return;
 	const pluginBindings = /* @__PURE__ */ new Set();
 	const namespaceBindings = /* @__PURE__ */ new Set();
@@ -329,8 +327,8 @@ function rejectCustomVueCompiler(root, scope, file, errors) {
 	if (!compiler) return;
 	errors.push(locatedOptionError(file, compiler.node, "Found a custom Vue compiler instance in the Vite plugin", "Remove the compiler override so extraction and Vite both use the app's vue/compiler-sfc version"));
 }
-function readNuxtConfig(file, state, errors) {
-	const ast = parseConfig(file, errors);
+function readNuxtConfig(file, state, errors, sourceDiscoveryIsExplicit) {
+	const ast = parseConfig(file, errors, sourceDiscoveryIsExplicit);
 	if (!ast) return;
 	const defineNuxtConfigBindings = /* @__PURE__ */ new Set();
 	traverse(ast, { ImportDeclaration(importPath) {
@@ -359,7 +357,7 @@ function readNuxtConfig(file, state, errors) {
 		errors.push(locatedOptionError(file, extendsEntry.node, "Found Nuxt layer inheritance that could change Vue compiler options", "Run extraction from a Nuxt configuration without inherited layers until gt-vue can resolve the complete layer chain safely"));
 		return;
 	}
-	const unsupportedSourceLayout = findUnsupportedNuxtSourceLayout(configObject.value);
+	const unsupportedSourceLayout = sourceDiscoveryIsExplicit ? void 0 : findUnsupportedNuxtSourceLayout(configObject.value);
 	if (unsupportedSourceLayout) {
 		errors.push(locatedOptionError(file, unsupportedSourceLayout, "Found custom Nuxt source directories that default Vue discovery cannot scan safely", "Use Nuxt source directories covered by the default app, src, pages, layouts, plugins, and related globs until custom directory discovery is supported"));
 		return;
@@ -917,18 +915,29 @@ function resolveKnownConfigConsumer(input, scope, seen) {
 	}
 	return (node.type === "MemberExpression" || node.type === "OptionalMemberExpression") && isDefaultMember(node) && (getPluginVueRequireKind(node, "@vitejs/plugin-vue") === "default" || getPluginVueRequireKind(node, "@vitejs/plugin-vue-jsx") === "default");
 }
-function parseConfig(file, errors) {
-	const source = fs.readFileSync(file, "utf8");
+/**
+* Parses one project config without executing it. Automatic discovery keeps
+* ignoring malformed configs that contain no Vue-relevant setting, while an
+* explicit config or source scope reports every syntax error.
+*/
+function parseConfig(file, errors, reportAllSyntaxErrors) {
+	let source;
+	try {
+		source = fs.readFileSync(file, "utf8");
+	} catch (error) {
+		errors.push(configFileDiagnostic("Could not read the Vue project config file", "Restore the config file and its read permissions, then try extraction again", file, error));
+		return;
+	}
 	try {
 		return parse(source, {
 			sourceType: "unambiguous",
 			plugins: parserPlugins(file)
 		});
 	} catch (error) {
-		if (!/compilerOptions|whitespace|delimiters|@vitejs\/plugin-vue-jsx|babelPlugins|pragma/.test(source)) return;
+		if (!reportAllSyntaxErrors && !/compilerOptions|whitespace|delimiters|@vitejs\/plugin-vue-jsx|babelPlugins|pragma/.test(source)) return;
 		const syntaxError = error;
 		errors.push(withLocation(file, createDiagnosticMessage({
-			whatHappened: "Could not parse a project configuration containing Vue compiler options",
+			whatHappened: reportAllSyntaxErrors ? "Could not parse the Vue project config file" : "Could not parse a project configuration containing Vue compiler options",
 			details: syntaxError.message,
 			fix: "Use a statically analyzable Vite or Nuxt configuration, or configure files.gt.parsingFlags.vueCompilerOptions explicitly"
 		}), syntaxError.loc ? `${syntaxError.loc.line}:${syntaxError.loc.column + 1}` : void 0));
@@ -978,6 +987,15 @@ function optionError(whatHappened, fix) {
 		fix
 	});
 }
+/** Formats a filesystem-backed config diagnostic without leaking an exception. */
+function configFileDiagnostic(whatHappened, fix, file, error) {
+	const errorDetails = error === void 0 ? void 0 : formatDiagnosticErrorDetails(error);
+	return createDiagnosticMessage({
+		whatHappened,
+		fix,
+		details: [file, ...errorDetails === void 0 ? [] : [errorDetails]]
+	});
+}
 function withLocation(file, message, location) {
 	return `${file}${location ? ` (${location})` : ""}: ${message}`;
 }