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

package/dist/internal/project/moduleResolver.js

@@ -0,0 +1,325 @@
+import { readJavaScriptPackageManifest, resolveInstalledJavaScriptPackage } from "./manifest.js";
+import fs from "node:fs";
+import path from "node:path";
+import enhancedResolve from "enhanced-resolve";
+import { createMatchPath } from "tsconfig-paths";
+import { configLoader } from "tsconfig-paths/lib/config-loader.js";
+import { loadTsconfig, walkForTsConfig } from "tsconfig-paths/lib/tsconfig-loader.js";
+//#region src/internal/project/moduleResolver.ts
+const { ResolverFactory } = enhancedResolve;
+const SOURCE_EXTENSIONS = [
+	".mjs",
+	".js",
+	".mts",
+	".ts",
+	".jsx",
+	".tsx",
+	".json"
+];
+const SOURCE_EXTENSION_ALIASES = {
+	".cjs": [".cjs", ".cts"],
+	".js": [
+		".js",
+		".ts",
+		".tsx"
+	],
+	".jsx": [".jsx", ".tsx"],
+	".mjs": [".mjs", ".mts"]
+};
+const VITE_MAIN_FIELDS = [
+	"browser",
+	"module",
+	"jsnext:main",
+	"jsnext",
+	"main"
+];
+const COMMONJS_SOURCE_EXTENSIONS = new Set([".cjs", ".cts"]);
+const ESM_SYNTAX = /(?:[\s;]|^)(?:import[\s\w*,{}]*from|import\s*["'*{]|export\b\s*(?:[*{]|default|class|type|function|const|var|let|async function)|import\.meta\b)/m;
+/** Conditions used by the CLI when no project override is supplied. */
+const DEFAULT_RESOLUTION_CONDITIONS = [
+	"module",
+	"browser",
+	"development|production"
+];
+/** Loads one explicit config without honoring ambient ts-node overrides. */
+function loadExplicitTypeScriptConfig(configPath) {
+	const config = loadTsconfig(configPath);
+	if (!isUnknownRecord(config)) return invalidTypeScriptConfig("The config root must be an object");
+	const compilerOptions = config.compilerOptions;
+	if (compilerOptions !== void 0 && !isUnknownRecord(compilerOptions)) return invalidTypeScriptConfig("compilerOptions must be an object");
+	const baseUrl = compilerOptions?.baseUrl;
+	if (baseUrl !== void 0 && typeof baseUrl !== "string") return invalidTypeScriptConfig("compilerOptions.baseUrl must be a string");
+	const configuredPaths = compilerOptions?.paths;
+	if (configuredPaths !== void 0 && !isUnknownRecord(configuredPaths)) return invalidTypeScriptConfig("compilerOptions.paths must be an object");
+	const paths = {};
+	for (const [alias, targets] of Object.entries(configuredPaths ?? {})) {
+		if (!Array.isArray(targets) || !targets.every((target) => typeof target === "string")) return invalidTypeScriptConfig(`compilerOptions.paths.${alias} must be an array of strings`);
+		paths[alias] = targets;
+	}
+	return configLoader({
+		cwd: path.dirname(configPath),
+		tsConfigLoader: () => ({
+			tsConfigPath: configPath,
+			baseUrl,
+			paths
+		})
+	});
+}
+function invalidTypeScriptConfig(message) {
+	return {
+		resultType: "failed",
+		message
+	};
+}
+/** Creates a deterministic, source-first resolver scoped to one extraction. */
+function createProjectModuleResolver(conditionNames = DEFAULT_RESOLUTION_CONDITIONS, options = {}) {
+	const cache = /* @__PURE__ */ new Map();
+	const discoveredTsConfigs = /* @__PURE__ */ new Map();
+	const explicitTsConfig = options.tsconfigPath === void 0 ? void 0 : loadExplicitTypeScriptConfig(options.tsconfigPath);
+	return (specifier, importer) => {
+		const cacheKey = `${importer}::${specifier}`;
+		if (cache.has(cacheKey)) return cache.get(cacheKey);
+		const result = resolveProjectModule(specifier, importer, conditionNames, options, explicitTsConfig, discoveredTsConfigs);
+		cache.set(cacheKey, result);
+		return result;
+	};
+}
+/** Resolves local barrels, TypeScript paths, and package export maps. */
+function resolveProjectModule(specifier, importer, conditionNames, options, explicitTsConfig, discoveredTsConfigs) {
+	const basedir = path.dirname(importer);
+	const extensions = [...SOURCE_EXTENSIONS];
+	const isRequire = COMMONJS_SOURCE_EXTENSIONS.has(path.extname(importer).toLowerCase());
+	const mainFields = resolveViteMainFields(specifier, basedir, isRequire, options);
+	const resolvedConditions = resolveConditionsForImporter(conditionNames, isRequire);
+	const tsConfigResult = explicitTsConfig ?? loadNearestTypeScriptConfig(basedir, discoveredTsConfigs);
+	if (tsConfigResult.resultType === "success") {
+		const matchPath = createMatchPath(tsConfigResult.absoluteBaseUrl, tsConfigResult.paths, mainFields);
+		const directMatch = resolveExistingPath(matchPath(specifier, void 0, void 0, extensions), extensions);
+		if (directMatch) return directMatch;
+		const baseMatch = matchPath(specifier);
+		for (const extension of extensions) {
+			const explicitMatch = resolveExistingPath(matchPath(`${specifier}${extension}`), extensions);
+			if (explicitMatch) return explicitMatch;
+			const baseWithExtension = resolveExistingPath(baseMatch ? `${baseMatch}${extension}` : void 0, extensions);
+			if (baseWithExtension) return baseWithExtension;
+		}
+	}
+	try {
+		const result = ResolverFactory.createResolver({
+			useSyncFileSystemCalls: true,
+			fileSystem: fs,
+			extensions,
+			aliasFields: ["browser"],
+			conditionNames: resolvedConditions,
+			extensionAlias: SOURCE_EXTENSION_ALIASES,
+			exportsFields: ["exports"],
+			mainFields
+		}).resolveSync({}, basedir, specifier);
+		if (typeof result === "string") return result;
+	} catch {}
+	return resolvePackageExportSourceAlternative(specifier, basedir, resolvedConditions, options);
+}
+/** Discovers the nearest project file without honoring ts-node environment. */
+function loadNearestTypeScriptConfig(basedir, cache) {
+	const cached = cache.get(basedir);
+	if (cached) return cached;
+	const configPath = walkForTsConfig(basedir);
+	const result = configPath ? loadExplicitTypeScriptConfig(configPath) : loadConfigWithoutProject();
+	if (configPath && result.resultType === "failed") throw new Error(result.message);
+	cache.set(basedir, result);
+	return result;
+}
+function loadConfigWithoutProject() {
+	return {
+		resultType: "failed",
+		message: "Couldn't find tsconfig.json"
+	};
+}
+/** Adds the import kind and expands Vite's mode placeholder deterministically. */
+function resolveConditionsForImporter(conditionNames, isRequire) {
+	const modeCondition = conditionNames.includes("production") && !conditionNames.includes("development") ? "production" : "development";
+	const conditions = conditionNames.filter((condition) => condition !== "import" && condition !== "require").map((condition) => condition === "development|production" ? modeCondition : condition);
+	conditions.push(isRequire ? "require" : "import", "default");
+	return [...new Set(conditions)];
+}
+/** Mirrors Vite's browser-entry versus ESM-module compatibility heuristic. */
+function resolveViteMainFields(specifier, basedir, isRequire, options) {
+	if (isRequire) return [...VITE_MAIN_FIELDS];
+	const packageData = readImportedPackageData(specifier, basedir, options);
+	if (!packageData) return [...VITE_MAIN_FIELDS];
+	const { directory, manifest } = packageData;
+	const browserEntry = typeof manifest.browser === "string" ? manifest.browser : isUnknownRecord(manifest.browser) && typeof manifest.browser["."] === "string" ? manifest.browser["."] : void 0;
+	if (!browserEntry || typeof manifest.module !== "string" || manifest.module === browserEntry) return [...VITE_MAIN_FIELDS];
+	const browserEntryPath = path.resolve(directory, browserEntry);
+	const resolvedBrowserEntry = resolveExistingPath(browserEntryPath, SOURCE_EXTENSIONS) ?? resolveSourceOutputPath(browserEntryPath);
+	if (!resolvedBrowserEntry) return [...VITE_MAIN_FIELDS];
+	try {
+		if (ESM_SYNTAX.test(fs.readFileSync(resolvedBrowserEntry, "utf8"))) return [...VITE_MAIN_FIELDS];
+	} catch {
+		return [...VITE_MAIN_FIELDS];
+	}
+	return [
+		"module",
+		"browser",
+		"jsnext:main",
+		"jsnext",
+		"main"
+	];
+}
+/** Reads the package selected by Node's nearest-node_modules precedence. */
+function readImportedPackageData(specifier, basedir, options = {}) {
+	const packageName = readPackageName(specifier);
+	if (!packageName) return void 0;
+	const selfPackage = options.selfPackage;
+	if (selfPackage?.manifest.name === packageName && isWithinDirectory(selfPackage.directory, basedir)) return {
+		directory: selfPackage.directory,
+		manifest: selfPackage.manifest
+	};
+	const nearestPackage = readNearestPackageData(basedir);
+	if (nearestPackage?.manifest.name === packageName) return nearestPackage;
+	const installed = resolveInstalledJavaScriptPackage(basedir, packageName);
+	return installed ? {
+		directory: installed.directory,
+		manifest: installed.manifest
+	} : void 0;
+}
+/** Reads only the importer's nearest package scope for self-reference lookup. */
+function readNearestPackageData(basedir) {
+	let current = path.resolve(basedir);
+	while (true) {
+		const manifestPath = path.join(current, "package.json");
+		if (fs.existsSync(manifestPath)) {
+			const manifest = readJavaScriptPackageManifest(manifestPath);
+			return manifest ? {
+				directory: current,
+				manifest
+			} : void 0;
+		}
+		const parent = path.dirname(current);
+		if (parent === current) return void 0;
+		current = parent;
+	}
+}
+/**
+* Recovers TypeScript source behind a JavaScript package export target.
+*
+* This fallback interprets the package's export map instead of probing its
+* filesystem by subpath. That distinction preserves package encapsulation:
+* an unexported file remains unresolved even when it physically exists.
+*/
+function resolvePackageExportSourceAlternative(specifier, basedir, conditions, options) {
+	const packageName = readPackageName(specifier);
+	const packageData = readImportedPackageData(specifier, basedir, options);
+	if (!packageName || !packageData || packageData.manifest.exports === void 0) return;
+	const subpath = specifier === packageName ? "." : `.${specifier.slice(packageName.length)}`;
+	const target = resolveExportsTarget(packageData.manifest.exports, subpath, new Set(conditions));
+	if (!target || !target.startsWith("./")) return void 0;
+	const mappedTarget = applyPackageBrowserMap(target, packageData.manifest);
+	if (!mappedTarget || !mappedTarget.startsWith("./")) return void 0;
+	const candidate = path.resolve(packageData.directory, mappedTarget);
+	const relative = path.relative(packageData.directory, candidate);
+	if (relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) return;
+	return resolveSourceOutputPath(candidate);
+}
+function isWithinDirectory(directory, candidate) {
+	const relative = path.relative(path.resolve(directory), path.resolve(candidate));
+	return relative !== ".." && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative);
+}
+/** Resolves the exact or best-pattern subpath before evaluating conditions. */
+function resolveExportsTarget(exportsField, subpath, conditions) {
+	if (!isUnknownRecord(exportsField) || isConditionalExports(exportsField)) return subpath === "." ? resolveConditionalTarget(exportsField, conditions) : void 0;
+	if (Object.prototype.hasOwnProperty.call(exportsField, subpath)) return resolveConditionalTarget(exportsField[subpath], conditions);
+	const pattern = Object.keys(exportsField).filter((key) => key.startsWith("./") && key.includes("*")).map((key) => {
+		const star = key.indexOf("*");
+		const prefix = key.slice(0, star);
+		const suffix = key.slice(star + 1);
+		return subpath.startsWith(prefix) && subpath.endsWith(suffix) ? {
+			key,
+			match: subpath.slice(prefix.length, subpath.length - suffix.length),
+			prefixLength: prefix.length,
+			suffixLength: suffix.length
+		} : void 0;
+	}).filter((entry) => entry !== void 0).sort((left, right) => right.prefixLength - left.prefixLength || right.suffixLength - left.suffixLength || right.key.length - left.key.length)[0];
+	if (!pattern) return void 0;
+	return resolveConditionalTarget(exportsField[pattern.key], conditions)?.replaceAll("*", pattern.match);
+}
+/** Evaluates export conditions in declaration order, matching Node and Vite. */
+function resolveConditionalTarget(target, conditions) {
+	if (typeof target === "string") return target;
+	if (Array.isArray(target)) {
+		for (const candidate of target) {
+			const resolved = resolveConditionalTarget(candidate, conditions);
+			if (resolved) return resolved;
+		}
+		return;
+	}
+	if (!isUnknownRecord(target)) return void 0;
+	for (const [condition, candidate] of Object.entries(target)) {
+		if (condition !== "default" && !conditions.has(condition)) continue;
+		const resolved = resolveConditionalTarget(candidate, conditions);
+		if (resolved) return resolved;
+	}
+}
+function isConditionalExports(exportsField) {
+	return Object.keys(exportsField).every((key) => !key.startsWith("."));
+}
+/** Applies the object form of a package browser map to an export target. */
+function applyPackageBrowserMap(target, manifest) {
+	if (!isUnknownRecord(manifest.browser)) return target;
+	const normalizedTarget = path.posix.normalize(target);
+	for (const [key, mapped] of Object.entries(manifest.browser)) {
+		const normalizedKey = path.posix.normalize(key);
+		if (normalizedTarget !== normalizedKey && !equalWithoutSuffix(normalizedTarget, normalizedKey, ".js") && !equalWithoutSuffix(normalizedTarget, normalizedKey, "/index.js")) continue;
+		return typeof mapped === "string" ? mapped : void 0;
+	}
+	return target;
+}
+function equalWithoutSuffix(target, key, suffix) {
+	return key.endsWith(suffix) && key.slice(0, -suffix.length) === target;
+}
+/** Maps emitted JS-family file names to their source equivalents like Vite. */
+function resolveSourceOutputPath(candidate) {
+	if (fs.existsSync(candidate) && fs.statSync(candidate).isFile()) return candidate;
+	const extension = path.extname(candidate).toLowerCase();
+	const alternatives = SOURCE_EXTENSION_ALIASES[extension];
+	if (!alternatives) return void 0;
+	const stem = candidate.slice(0, -extension.length);
+	for (const alternative of alternatives.slice(1)) {
+		const source = `${stem}${alternative}`;
+		try {
+			if (fs.statSync(source).isFile()) return source;
+		} catch {}
+	}
+}
+function readPackageName(specifier) {
+	if (!specifier || specifier.startsWith(".") || specifier.startsWith("/") || specifier.startsWith("#")) return;
+	const segments = specifier.split("/");
+	if (specifier.startsWith("@")) return segments.length >= 2 ? `${segments[0]}/${segments[1]}` : void 0;
+	return segments[0];
+}
+function isUnknownRecord(value) {
+	return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function resolveExistingPath(filePath, extensions) {
+	if (!filePath) return void 0;
+	try {
+		if (fs.existsSync(filePath)) {
+			const stats = fs.statSync(filePath);
+			if (stats.isFile()) return filePath;
+			if (stats.isDirectory()) for (const extension of extensions) {
+				const indexPath = path.join(filePath, `index${extension}`);
+				if (fs.existsSync(indexPath) && fs.statSync(indexPath).isFile()) return indexPath;
+			}
+		}
+		for (const extension of extensions) {
+			const candidate = `${filePath}${extension}`;
+			if (fs.existsSync(candidate) && fs.statSync(candidate).isFile()) return candidate;
+		}
+	} catch {
+		return;
+	}
+}
+//#endregion
+export { DEFAULT_RESOLUTION_CONDITIONS, createProjectModuleResolver, loadExplicitTypeScriptConfig };
+
+//# sourceMappingURL=moduleResolver.js.map

package/dist/internal/project/moduleResolver.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"moduleResolver.js","names":[],"sources":["../../../src/internal/project/moduleResolver.ts"],"sourcesContent":["import fs from 'node:fs';\nimport path from 'node:path';\nimport enhancedResolve, { type FileSystem } from 'enhanced-resolve';\nimport { createMatchPath, type ConfigLoaderResult } from 'tsconfig-paths';\nimport { configLoader } from 'tsconfig-paths/lib/config-loader.js';\nimport {\n  loadTsconfig,\n  walkForTsConfig,\n} from 'tsconfig-paths/lib/tsconfig-loader.js';\nimport {\n  readJavaScriptPackageManifest,\n  resolveInstalledJavaScriptPackage,\n  type JavaScriptPackageManifest,\n} from './manifest.js';\n\nconst { ResolverFactory } = enhancedResolve;\n\nconst SOURCE_EXTENSIONS = [\n  '.mjs',\n  '.js',\n  '.mts',\n  '.ts',\n  '.jsx',\n  '.tsx',\n  '.json',\n] as const;\n\nconst SOURCE_EXTENSION_ALIASES = {\n  '.cjs': ['.cjs', '.cts'],\n  '.js': ['.js', '.ts', '.tsx'],\n  '.jsx': ['.jsx', '.tsx'],\n  '.mjs': ['.mjs', '.mts'],\n};\n\nconst VITE_MAIN_FIELDS = [\n  'browser',\n  'module',\n  'jsnext:main',\n  'jsnext',\n  'main',\n] as const;\n\nconst COMMONJS_SOURCE_EXTENSIONS = new Set(['.cjs', '.cts']);\n\n// Keep this in step with Vite's entry-point heuristic. A package may publish\n// a CommonJS browser build alongside an ESM `module` build; Vite deliberately\n// selects the module build for an ESM importer in that case.\nconst ESM_SYNTAX =\n  /(?:[\\s;]|^)(?:import[\\s\\w*,{}]*from|import\\s*[\"'*{]|export\\b\\s*(?:[*{]|default|class|type|function|const|var|let|async function)|import\\.meta\\b)/m;\n\n/** Conditions used by the CLI when no project override is supplied. */\nexport const DEFAULT_RESOLUTION_CONDITIONS = [\n  'module',\n  'browser',\n  'development|production',\n] as const;\n\ntype ProjectModuleResolverOptions = {\n  /** Package currently being inspected, for standards-compliant self imports. */\n  selfPackage?: {\n    directory: string;\n    manifest: JavaScriptPackageManifest;\n  };\n  /** Explicit tsconfig.json or jsconfig.json used for every importer. */\n  tsconfigPath?: string;\n};\n\n/** Loads one explicit config without honoring ambient ts-node overrides. */\nexport function loadExplicitTypeScriptConfig(\n  configPath: string\n): ConfigLoaderResult {\n  const config = loadTsconfig(configPath) as unknown;\n  if (!isUnknownRecord(config)) {\n    return invalidTypeScriptConfig('The config root must be an object');\n  }\n  const compilerOptions = config.compilerOptions;\n  if (compilerOptions !== undefined && !isUnknownRecord(compilerOptions)) {\n    return invalidTypeScriptConfig('compilerOptions must be an object');\n  }\n  const baseUrl = compilerOptions?.baseUrl;\n  if (baseUrl !== undefined && typeof baseUrl !== 'string') {\n    return invalidTypeScriptConfig('compilerOptions.baseUrl must be a string');\n  }\n  const configuredPaths = compilerOptions?.paths;\n  if (configuredPaths !== undefined && !isUnknownRecord(configuredPaths)) {\n    return invalidTypeScriptConfig('compilerOptions.paths must be an object');\n  }\n  const paths: Record<string, string[]> = {};\n  for (const [alias, targets] of Object.entries(configuredPaths ?? {})) {\n    if (\n      !Array.isArray(targets) ||\n      !targets.every((target) => typeof target === 'string')\n    ) {\n      return invalidTypeScriptConfig(\n        `compilerOptions.paths.${alias} must be an array of strings`\n      );\n    }\n    paths[alias] = targets;\n  }\n\n  return configLoader({\n    cwd: path.dirname(configPath),\n    tsConfigLoader: () => ({\n      tsConfigPath: configPath,\n      baseUrl,\n      paths,\n    }),\n  });\n}\n\nfunction invalidTypeScriptConfig(message: string): ConfigLoaderResult {\n  return { resultType: 'failed', message };\n}\n\n/** Creates a deterministic, source-first resolver scoped to one extraction. */\nexport function createProjectModuleResolver(\n  conditionNames: readonly string[] = DEFAULT_RESOLUTION_CONDITIONS,\n  options: ProjectModuleResolverOptions = {}\n): (specifier: string, importer: string) => string | undefined {\n  const cache = new Map<string, string | undefined>();\n  const discoveredTsConfigs = new Map<string, ConfigLoaderResult>();\n  const explicitTsConfig =\n    options.tsconfigPath === undefined\n      ? undefined\n      : loadExplicitTypeScriptConfig(options.tsconfigPath);\n  return (specifier, importer) => {\n    const cacheKey = `${importer}::${specifier}`;\n    if (cache.has(cacheKey)) return cache.get(cacheKey);\n    const result = resolveProjectModule(\n      specifier,\n      importer,\n      conditionNames,\n      options,\n      explicitTsConfig,\n      discoveredTsConfigs\n    );\n    cache.set(cacheKey, result);\n    return result;\n  };\n}\n\n/** Resolves local barrels, TypeScript paths, and package export maps. */\nfunction resolveProjectModule(\n  specifier: string,\n  importer: string,\n  conditionNames: readonly string[],\n  options: ProjectModuleResolverOptions,\n  explicitTsConfig: ConfigLoaderResult | undefined,\n  discoveredTsConfigs: Map<string, ConfigLoaderResult>\n): string | undefined {\n  const basedir = path.dirname(importer);\n  const extensions = [...SOURCE_EXTENSIONS];\n  const isRequire = COMMONJS_SOURCE_EXTENSIONS.has(\n    path.extname(importer).toLowerCase()\n  );\n  const mainFields = resolveViteMainFields(\n    specifier,\n    basedir,\n    isRequire,\n    options\n  );\n  const resolvedConditions = resolveConditionsForImporter(\n    conditionNames,\n    isRequire\n  );\n\n  const tsConfigResult =\n    explicitTsConfig ??\n    loadNearestTypeScriptConfig(basedir, discoveredTsConfigs);\n  if (tsConfigResult.resultType === 'success') {\n    const matchPath = createMatchPath(\n      tsConfigResult.absoluteBaseUrl,\n      tsConfigResult.paths,\n      mainFields\n    );\n    const directMatch = resolveExistingPath(\n      matchPath(specifier, undefined, undefined, extensions),\n      extensions\n    );\n    if (directMatch) return directMatch;\n\n    const baseMatch = matchPath(specifier);\n    for (const extension of extensions) {\n      const explicitMatch = resolveExistingPath(\n        matchPath(`${specifier}${extension}`),\n        extensions\n      );\n      if (explicitMatch) return explicitMatch;\n      const baseWithExtension = resolveExistingPath(\n        baseMatch ? `${baseMatch}${extension}` : undefined,\n        extensions\n      );\n      if (baseWithExtension) return baseWithExtension;\n    }\n  }\n\n  try {\n    const resolver = ResolverFactory.createResolver({\n      useSyncFileSystemCalls: true,\n      fileSystem: fs as unknown as FileSystem,\n      extensions,\n      aliasFields: ['browser'],\n      conditionNames: resolvedConditions,\n      extensionAlias: SOURCE_EXTENSION_ALIASES,\n      exportsFields: ['exports'],\n      mainFields,\n    });\n    const result = resolver.resolveSync({}, basedir, specifier);\n    if (typeof result === 'string') return result;\n  } catch {\n    // Resolution is intentionally final. Falling back to a resolver that\n    // ignores `exports` would expose package-private modules that Vite rejects.\n  }\n  return resolvePackageExportSourceAlternative(\n    specifier,\n    basedir,\n    resolvedConditions,\n    options\n  );\n}\n\n/** Discovers the nearest project file without honoring ts-node environment. */\nfunction loadNearestTypeScriptConfig(\n  basedir: string,\n  cache: Map<string, ConfigLoaderResult>\n): ConfigLoaderResult {\n  const cached = cache.get(basedir);\n  if (cached) return cached;\n  const configPath = walkForTsConfig(basedir);\n  const result = configPath\n    ? loadExplicitTypeScriptConfig(configPath)\n    : loadConfigWithoutProject();\n  if (configPath && result.resultType === 'failed') {\n    throw new Error(result.message);\n  }\n  cache.set(basedir, result);\n  return result;\n}\n\nfunction loadConfigWithoutProject(): ConfigLoaderResult {\n  return { resultType: 'failed', message: \"Couldn't find tsconfig.json\" };\n}\n\n/** Adds the import kind and expands Vite's mode placeholder deterministically. */\nfunction resolveConditionsForImporter(\n  conditionNames: readonly string[],\n  isRequire: boolean\n): string[] {\n  const useProduction =\n    conditionNames.includes('production') &&\n    !conditionNames.includes('development');\n  const modeCondition = useProduction ? 'production' : 'development';\n  const conditions = conditionNames\n    .filter((condition) => condition !== 'import' && condition !== 'require')\n    .map((condition) =>\n      condition === 'development|production' ? modeCondition : condition\n    );\n  conditions.push(isRequire ? 'require' : 'import', 'default');\n  return [...new Set(conditions)];\n}\n\n/** Mirrors Vite's browser-entry versus ESM-module compatibility heuristic. */\nfunction resolveViteMainFields(\n  specifier: string,\n  basedir: string,\n  isRequire: boolean,\n  options: ProjectModuleResolverOptions\n): string[] {\n  if (isRequire) return [...VITE_MAIN_FIELDS];\n  const packageData = readImportedPackageData(specifier, basedir, options);\n  if (!packageData) return [...VITE_MAIN_FIELDS];\n  const { directory, manifest } = packageData;\n  const browserEntry =\n    typeof manifest.browser === 'string'\n      ? manifest.browser\n      : isUnknownRecord(manifest.browser) &&\n          typeof manifest.browser['.'] === 'string'\n        ? manifest.browser['.']\n        : undefined;\n  if (\n    !browserEntry ||\n    typeof manifest.module !== 'string' ||\n    manifest.module === browserEntry\n  ) {\n    return [...VITE_MAIN_FIELDS];\n  }\n  const browserEntryPath = path.resolve(directory, browserEntry);\n  const resolvedBrowserEntry =\n    resolveExistingPath(browserEntryPath, SOURCE_EXTENSIONS) ??\n    resolveSourceOutputPath(browserEntryPath);\n  if (!resolvedBrowserEntry) return [...VITE_MAIN_FIELDS];\n  try {\n    if (ESM_SYNTAX.test(fs.readFileSync(resolvedBrowserEntry, 'utf8'))) {\n      return [...VITE_MAIN_FIELDS];\n    }\n  } catch {\n    return [...VITE_MAIN_FIELDS];\n  }\n  return ['module', 'browser', 'jsnext:main', 'jsnext', 'main'];\n}\n\ntype ImportedPackageData = {\n  directory: string;\n  manifest: Record<string, unknown>;\n};\n\n/** Reads the package selected by Node's nearest-node_modules precedence. */\nfunction readImportedPackageData(\n  specifier: string,\n  basedir: string,\n  options: ProjectModuleResolverOptions = {}\n): ImportedPackageData | undefined {\n  const packageName = readPackageName(specifier);\n  if (!packageName) return undefined;\n  const selfPackage = options.selfPackage;\n  if (\n    selfPackage?.manifest.name === packageName &&\n    isWithinDirectory(selfPackage.directory, basedir)\n  ) {\n    return {\n      directory: selfPackage.directory,\n      manifest: selfPackage.manifest as Record<string, unknown>,\n    };\n  }\n  const nearestPackage = readNearestPackageData(basedir);\n  if (nearestPackage?.manifest.name === packageName) return nearestPackage;\n  const installed = resolveInstalledJavaScriptPackage(basedir, packageName);\n  return installed\n    ? {\n        directory: installed.directory,\n        manifest: installed.manifest as Record<string, unknown>,\n      }\n    : undefined;\n}\n\n/** Reads only the importer's nearest package scope for self-reference lookup. */\nfunction readNearestPackageData(\n  basedir: string\n): ImportedPackageData | undefined {\n  let current = path.resolve(basedir);\n  while (true) {\n    const manifestPath = path.join(current, 'package.json');\n    if (fs.existsSync(manifestPath)) {\n      const manifest = readJavaScriptPackageManifest(manifestPath);\n      return manifest\n        ? { directory: current, manifest: manifest as Record<string, unknown> }\n        : undefined;\n    }\n    const parent = path.dirname(current);\n    if (parent === current) return undefined;\n    current = parent;\n  }\n}\n\n/**\n * Recovers TypeScript source behind a JavaScript package export target.\n *\n * This fallback interprets the package's export map instead of probing its\n * filesystem by subpath. That distinction preserves package encapsulation:\n * an unexported file remains unresolved even when it physically exists.\n */\nfunction resolvePackageExportSourceAlternative(\n  specifier: string,\n  basedir: string,\n  conditions: readonly string[],\n  options: ProjectModuleResolverOptions\n): string | undefined {\n  const packageName = readPackageName(specifier);\n  const packageData = readImportedPackageData(specifier, basedir, options);\n  if (\n    !packageName ||\n    !packageData ||\n    packageData.manifest.exports === undefined\n  ) {\n    return undefined;\n  }\n  const subpath =\n    specifier === packageName ? '.' : `.${specifier.slice(packageName.length)}`;\n  const target = resolveExportsTarget(\n    packageData.manifest.exports,\n    subpath,\n    new Set(conditions)\n  );\n  if (!target || !target.startsWith('./')) return undefined;\n  const mappedTarget = applyPackageBrowserMap(target, packageData.manifest);\n  if (!mappedTarget || !mappedTarget.startsWith('./')) return undefined;\n  const candidate = path.resolve(packageData.directory, mappedTarget);\n  const relative = path.relative(packageData.directory, candidate);\n  if (\n    relative === '..' ||\n    relative.startsWith(`..${path.sep}`) ||\n    path.isAbsolute(relative)\n  ) {\n    return undefined;\n  }\n  return resolveSourceOutputPath(candidate);\n}\n\nfunction isWithinDirectory(directory: string, candidate: string): boolean {\n  const relative = path.relative(\n    path.resolve(directory),\n    path.resolve(candidate)\n  );\n  return (\n    relative !== '..' &&\n    !relative.startsWith(`..${path.sep}`) &&\n    !path.isAbsolute(relative)\n  );\n}\n\n/** Resolves the exact or best-pattern subpath before evaluating conditions. */\nfunction resolveExportsTarget(\n  exportsField: unknown,\n  subpath: string,\n  conditions: ReadonlySet<string>\n): string | undefined {\n  if (!isUnknownRecord(exportsField) || isConditionalExports(exportsField)) {\n    return subpath === '.'\n      ? resolveConditionalTarget(exportsField, conditions)\n      : undefined;\n  }\n  if (Object.prototype.hasOwnProperty.call(exportsField, subpath)) {\n    return resolveConditionalTarget(exportsField[subpath], conditions);\n  }\n  const pattern = Object.keys(exportsField)\n    .filter((key) => key.startsWith('./') && key.includes('*'))\n    .map((key) => {\n      const star = key.indexOf('*');\n      const prefix = key.slice(0, star);\n      const suffix = key.slice(star + 1);\n      return subpath.startsWith(prefix) && subpath.endsWith(suffix)\n        ? {\n            key,\n            match: subpath.slice(prefix.length, subpath.length - suffix.length),\n            prefixLength: prefix.length,\n            suffixLength: suffix.length,\n          }\n        : undefined;\n    })\n    .filter((entry): entry is NonNullable<typeof entry> => entry !== undefined)\n    .sort(\n      (left, right) =>\n        right.prefixLength - left.prefixLength ||\n        right.suffixLength - left.suffixLength ||\n        right.key.length - left.key.length\n    )[0];\n  if (!pattern) return undefined;\n  const target = resolveConditionalTarget(\n    exportsField[pattern.key],\n    conditions\n  );\n  return target?.replaceAll('*', pattern.match);\n}\n\n/** Evaluates export conditions in declaration order, matching Node and Vite. */\nfunction resolveConditionalTarget(\n  target: unknown,\n  conditions: ReadonlySet<string>\n): string | undefined {\n  if (typeof target === 'string') return target;\n  if (Array.isArray(target)) {\n    for (const candidate of target) {\n      const resolved = resolveConditionalTarget(candidate, conditions);\n      if (resolved) return resolved;\n    }\n    return undefined;\n  }\n  if (!isUnknownRecord(target)) return undefined;\n  for (const [condition, candidate] of Object.entries(target)) {\n    if (condition !== 'default' && !conditions.has(condition)) continue;\n    const resolved = resolveConditionalTarget(candidate, conditions);\n    if (resolved) return resolved;\n  }\n  return undefined;\n}\n\nfunction isConditionalExports(exportsField: Record<string, unknown>): boolean {\n  return Object.keys(exportsField).every((key) => !key.startsWith('.'));\n}\n\n/** Applies the object form of a package browser map to an export target. */\nfunction applyPackageBrowserMap(\n  target: string,\n  manifest: Record<string, unknown>\n): string | undefined {\n  if (!isUnknownRecord(manifest.browser)) return target;\n  const normalizedTarget = path.posix.normalize(target);\n  for (const [key, mapped] of Object.entries(manifest.browser)) {\n    const normalizedKey = path.posix.normalize(key);\n    if (\n      normalizedTarget !== normalizedKey &&\n      !equalWithoutSuffix(normalizedTarget, normalizedKey, '.js') &&\n      !equalWithoutSuffix(normalizedTarget, normalizedKey, '/index.js')\n    ) {\n      continue;\n    }\n    return typeof mapped === 'string' ? mapped : undefined;\n  }\n  return target;\n}\n\nfunction equalWithoutSuffix(\n  target: string,\n  key: string,\n  suffix: string\n): boolean {\n  return key.endsWith(suffix) && key.slice(0, -suffix.length) === target;\n}\n\n/** Maps emitted JS-family file names to their source equivalents like Vite. */\nfunction resolveSourceOutputPath(candidate: string): string | undefined {\n  if (fs.existsSync(candidate) && fs.statSync(candidate).isFile()) {\n    return candidate;\n  }\n  const extension = path.extname(candidate).toLowerCase();\n  const alternatives =\n    SOURCE_EXTENSION_ALIASES[\n      extension as keyof typeof SOURCE_EXTENSION_ALIASES\n    ];\n  if (!alternatives) return undefined;\n  const stem = candidate.slice(0, -extension.length);\n  for (const alternative of alternatives.slice(1)) {\n    const source = `${stem}${alternative}`;\n    try {\n      if (fs.statSync(source).isFile()) return source;\n    } catch {\n      // Try the next source extension.\n    }\n  }\n  return undefined;\n}\n\nfunction readPackageName(specifier: string): string | undefined {\n  if (\n    !specifier ||\n    specifier.startsWith('.') ||\n    specifier.startsWith('/') ||\n    specifier.startsWith('#')\n  ) {\n    return undefined;\n  }\n  const segments = specifier.split('/');\n  if (specifier.startsWith('@')) {\n    return segments.length >= 2 ? `${segments[0]}/${segments[1]}` : undefined;\n  }\n  return segments[0];\n}\n\nfunction isUnknownRecord(value: unknown): value is Record<string, unknown> {\n  return Boolean(value && typeof value === 'object' && !Array.isArray(value));\n}\n\nfunction resolveExistingPath(\n  filePath: string | undefined,\n  extensions: readonly string[]\n): string | undefined {\n  if (!filePath) return undefined;\n  try {\n    if (fs.existsSync(filePath)) {\n      const stats = fs.statSync(filePath);\n      if (stats.isFile()) return filePath;\n      if (stats.isDirectory()) {\n        for (const extension of extensions) {\n          const indexPath = path.join(filePath, `index${extension}`);\n          if (fs.existsSync(indexPath) && fs.statSync(indexPath).isFile()) {\n            return indexPath;\n          }\n        }\n      }\n    }\n    for (const extension of extensions) {\n      const candidate = `${filePath}${extension}`;\n      if (fs.existsSync(candidate) && fs.statSync(candidate).isFile()) {\n        return candidate;\n      }\n    }\n  } catch {\n    return undefined;\n  }\n  return undefined;\n}\n"],"mappings":"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"}

package/dist/internal/project/scopes.d.ts

@@ -0,0 +1,31 @@
+import { type WorkspaceDiscoveryCache } from './workspaces.js';
+import { type JavaScriptPackageManifest } from './manifest.js';
+export { DEFAULT_VUE_SOURCE_PATTERNS } from './sourcePatterns.js';
+/** One package boundary whose sources share Vue build configuration. */
+export type VueSourceScope = {
+    directory: string;
+    includeByDefault: boolean;
+    relativeDirectory: string;
+};
+/** Project discovery result reused by detection and extraction. */
+export type VueProjectDiscovery = {
+    projectRoot: string;
+    rootOwnsVue: boolean;
+    rootManifest?: JavaScriptPackageManifest;
+    scopes: VueSourceScope[];
+};
+/**
+ * Discovers only packages that own gt-vue or consume a selected local wrapper.
+ *
+ * An aggregator root is not scanned merely because one child uses Vue. It is
+ * included only when it directly declares gt-vue or depends on a proven local
+ * wrapper. This is the boundary that prevents Vue support from broadening
+ * existing React source discovery.
+ */
+export declare function discoverVueProject(cwd: string, cache?: WorkspaceDiscoveryCache): VueProjectDiscovery;
+/** Canonicalizes existing roots so macOS path aliases share one ownership tree. */
+export declare function resolveProjectDirectory(directory: string): string;
+/** Returns safe project-root-relative default globs for selected Vue scopes. */
+export declare function readDefaultVueSourcePatterns(scopes: readonly VueSourceScope[]): string[];
+/** Selects the deepest declared Vue package containing a source file. */
+export declare function findVueSourceScope(file: string, scopes: readonly VueSourceScope[]): VueSourceScope | undefined;

package/dist/internal/project/scopes.js

@@ -0,0 +1,182 @@
+import { GT_VUE_PACKAGE, declaresAvailableJavaScriptDependency, declaresWorkspaceJavaScriptDependency, dependencyBindingAcceptsPackageVersion, parseLocalDependencyPath, parseNpmDependencyAlias, parseWorkspaceDependencyAlias, readJavaScriptPackageManifest, readPropagatingDependencyBindings, readWorkspaceDependencyBindings, readWorkspaceDependencyNames, resolveInstalledJavaScriptPackage } from "./manifest.js";
+import { DEFAULT_VUE_SOURCE_PATTERNS } from "./sourcePatterns.js";
+import { createConsumerUsageCache, packageConsumesPublicGT, packageExposesPublicGT } from "./consumerUsage.js";
+import { localDependencyGraphDeclaresVue } from "./detectVueProject.js";
+import { createWorkspaceDiscoveryCache, readDeclaredWorkspacePackages } from "./workspaces.js";
+import fs from "node:fs";
+import path from "node:path";
+import fg from "fast-glob";
+//#region src/internal/project/scopes.ts
+/**
+* Discovers only packages that own gt-vue or consume a selected local wrapper.
+*
+* An aggregator root is not scanned merely because one child uses Vue. It is
+* included only when it directly declares gt-vue or depends on a proven local
+* wrapper. This is the boundary that prevents Vue support from broadening
+* existing React source discovery.
+*/
+function discoverVueProject(cwd, cache = createWorkspaceDiscoveryCache()) {
+	const projectRoot = resolveProjectDirectory(cwd);
+	const rootManifest = readJavaScriptPackageManifest(path.join(projectRoot, "package.json"));
+	if (!rootManifest) return {
+		projectRoot,
+		rootOwnsVue: false,
+		scopes: []
+	};
+	const workspacePackages = readDeclaredWorkspacePackages(projectRoot, rootManifest, cache);
+	const consumerUsageCache = createConsumerUsageCache();
+	const workspaceSelection = selectVueWorkspacePackages(workspacePackages, rootManifest, projectRoot, consumerUsageCache);
+	const selectedWorkspacePackages = workspaceSelection.packages;
+	const rootDeclaresVue = declaresAvailableJavaScriptDependency(rootManifest, GT_VUE_PACKAGE, projectRoot);
+	const rootConsumesVueWrapper = consumesSelectedWorkspace({
+		directory: projectRoot,
+		manifest: rootManifest
+	}, selectedWorkspacePackages.filter(({ directory }) => workspaceSelection.propagatingDirectories.has(directory)), consumerUsageCache);
+	const rootConsumesLocalVueWrapper = localDependencyGraphDeclaresVue(rootManifest, projectRoot, consumerUsageCache);
+	const scopes = [];
+	const rootOwnsVue = rootDeclaresVue || rootConsumesVueWrapper || rootConsumesLocalVueWrapper;
+	if (rootOwnsVue) scopes.push({
+		directory: projectRoot,
+		includeByDefault: true,
+		relativeDirectory: ""
+	});
+	for (const { directory } of selectedWorkspacePackages) {
+		const relativeDirectory = toPosixPath(path.relative(projectRoot, directory));
+		if (!relativeDirectory || relativeDirectory === ".." || relativeDirectory.startsWith("../")) continue;
+		scopes.push({
+			directory,
+			includeByDefault: true,
+			relativeDirectory
+		});
+	}
+	return {
+		projectRoot,
+		rootManifest,
+		rootOwnsVue,
+		scopes
+	};
+}
+/** Canonicalizes existing roots so macOS path aliases share one ownership tree. */
+function resolveProjectDirectory(directory) {
+	try {
+		return fs.realpathSync(path.resolve(directory));
+	} catch {
+		return path.resolve(directory);
+	}
+}
+/** Returns safe project-root-relative default globs for selected Vue scopes. */
+function readDefaultVueSourcePatterns(scopes) {
+	const patterns = scopes.flatMap(({ includeByDefault, relativeDirectory }) => {
+		if (!includeByDefault) return [];
+		if (!relativeDirectory) return [...DEFAULT_VUE_SOURCE_PATTERNS];
+		const literalDirectory = fg.escapePath(relativeDirectory);
+		return DEFAULT_VUE_SOURCE_PATTERNS.map((pattern) => `${literalDirectory}/${pattern}`);
+	});
+	return [...new Set(patterns)];
+}
+/** Selects the deepest declared Vue package containing a source file. */
+function findVueSourceScope(file, scopes) {
+	return [...scopes].sort((left, right) => right.directory.length - left.directory.length).find(({ directory }) => isWithin(directory, file));
+}
+function selectVueWorkspacePackages(workspacePackages, rootManifest, projectRoot, consumerUsageCache) {
+	const selectedDirectories = /* @__PURE__ */ new Set();
+	const propagatingDirectories = /* @__PURE__ */ new Set();
+	const queuedPropagators = /* @__PURE__ */ new Set();
+	const pendingPackages = [];
+	const publicGTByDirectory = /* @__PURE__ */ new Map();
+	const publiclyExposesGT = ({ directory, manifest }) => {
+		const cached = publicGTByDirectory.get(directory);
+		if (cached !== void 0) return cached;
+		const exposesGT = packageExposesPublicGT(directory, manifest, consumerUsageCache);
+		publicGTByDirectory.set(directory, exposesGT);
+		return exposesGT;
+	};
+	const selectPackage = (selectedPackage, propagates) => {
+		selectedDirectories.add(selectedPackage.directory);
+		if (!propagates || queuedPropagators.has(selectedPackage.directory)) return;
+		propagatingDirectories.add(selectedPackage.directory);
+		queuedPropagators.add(selectedPackage.directory);
+		pendingPackages.push(selectedPackage);
+	};
+	if (declaresAvailableJavaScriptDependency(rootManifest, "gt-vue", projectRoot)) selectPackage({
+		directory: projectRoot,
+		manifest: rootManifest
+	}, publiclyExposesGT({
+		directory: projectRoot,
+		manifest: rootManifest
+	}));
+	for (const workspacePackage of workspacePackages) {
+		if (!declaresWorkspaceJavaScriptDependency(workspacePackage.manifest, "gt-vue", workspacePackage.directory)) continue;
+		selectPackage(workspacePackage, publiclyExposesGT(workspacePackage));
+	}
+	if (pendingPackages.length === 0) return {
+		packages: workspacePackages.filter(({ directory }) => selectedDirectories.has(directory)),
+		propagatingDirectories
+	};
+	const consumersByDependency = /* @__PURE__ */ new Map();
+	for (const workspacePackage of workspacePackages) for (const dependencyName of readWorkspaceDependencyNames(workspacePackage.manifest, workspacePackage.directory)) {
+		const consumers = consumersByDependency.get(dependencyName) ?? [];
+		consumers.push(workspacePackage);
+		consumersByDependency.set(dependencyName, consumers);
+	}
+	for (let index = 0; index < pendingPackages.length; index += 1) {
+		const selectedPackage = pendingPackages[index];
+		const selectedName = readPackageName(selectedPackage.manifest);
+		if (!selectedName) continue;
+		for (const consumer of consumersByDependency.get(selectedName) ?? []) {
+			if (propagatingDirectories.has(consumer.directory)) continue;
+			if (!consumesCompatibleWorkspace(consumer, selectedPackage, false, consumerUsageCache)) continue;
+			selectPackage(consumer, consumesCompatibleWorkspace(consumer, selectedPackage, true, consumerUsageCache) && publiclyExposesGT(consumer));
+		}
+	}
+	return {
+		packages: workspacePackages.filter(({ directory }) => selectedDirectories.has(directory)),
+		propagatingDirectories
+	};
+}
+function consumesSelectedWorkspace(consumer, selectedPackages, consumerUsageCache) {
+	return selectedPackages.some((selectedPackage) => consumesCompatibleWorkspace(consumer, selectedPackage, false, consumerUsageCache));
+}
+/** Checks that a compatible dependency edge is used by consumer source. */
+function consumesCompatibleWorkspace(consumer, selected, propagatingOnly, consumerUsageCache) {
+	const packageName = readPackageName(selected.manifest);
+	if (!packageName) return false;
+	return (propagatingOnly ? readPropagatingDependencyBindings(consumer.manifest, consumer.directory) : readWorkspaceDependencyBindings(consumer.manifest, consumer.directory)).some((binding) => dependencyBindingMatchesWorkspace(binding, packageName, selected, consumer.directory) && packageConsumesPublicGT(consumer.directory, binding.name, selected.directory, selected.manifest, consumerUsageCache));
+}
+function dependencyBindingMatchesWorkspace(binding, workspaceName, selected, consumerDirectory) {
+	const workspaceAlias = parseWorkspaceDependencyAlias(binding.specifier);
+	const npmAlias = parseNpmDependencyAlias(binding.specifier);
+	const catalogPackage = binding.specifier.startsWith("catalog:") ? resolveInstalledJavaScriptPackage(consumerDirectory, binding.name) : void 0;
+	const namesWorkspace = binding.name === workspaceName;
+	const aliasesWorkspace = workspaceAlias?.packageName === workspaceName || npmAlias?.packageName === workspaceName || catalogPackage?.manifest.name === workspaceName;
+	const localPath = parseLocalDependencyPath(binding.specifier);
+	if (localPath) return pathsIdentifySameDirectory(path.resolve(consumerDirectory, localPath), selected.directory);
+	if (!namesWorkspace && !aliasesWorkspace) return false;
+	if (!dependencyBindingAcceptsPackageVersion(binding, workspaceName, selected.manifest.version)) return false;
+	const installed = catalogPackage ?? resolveInstalledJavaScriptPackage(consumerDirectory, binding.name);
+	if (installed && pathsIdentifySameDirectory(installed.directory, selected.directory)) return true;
+	if (workspaceAlias?.packageName === workspaceName) return true;
+	if (namesWorkspace && binding.specifier.startsWith("workspace:")) return true;
+	return false;
+}
+function pathsIdentifySameDirectory(left, right) {
+	try {
+		return fs.realpathSync(left) === fs.realpathSync(right);
+	} catch {
+		return path.resolve(left) === path.resolve(right);
+	}
+}
+function readPackageName(manifest) {
+	return typeof manifest.name === "string" && manifest.name ? manifest.name : void 0;
+}
+function isWithin(directory, file) {
+	const relative = path.relative(path.resolve(directory), path.resolve(file));
+	return relative !== "" && relative !== ".." && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative);
+}
+function toPosixPath(filePath) {
+	return filePath.split(path.sep).join(path.posix.sep);
+}
+//#endregion
+export { DEFAULT_VUE_SOURCE_PATTERNS, discoverVueProject, findVueSourceScope, readDefaultVueSourcePatterns, resolveProjectDirectory };
+
+//# sourceMappingURL=scopes.js.map

package/dist/internal/project/scopes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scopes.js","names":[],"sources":["../../../src/internal/project/scopes.ts"],"sourcesContent":["import fs from 'node:fs';\nimport path from 'node:path';\nimport fg from 'fast-glob';\nimport {\n  createWorkspaceDiscoveryCache,\n  readDeclaredWorkspacePackages,\n  type DeclaredWorkspacePackage,\n  type WorkspaceDiscoveryCache,\n} from './workspaces.js';\nimport {\n  dependencyBindingAcceptsPackageVersion,\n  declaresAvailableJavaScriptDependency,\n  declaresWorkspaceJavaScriptDependency,\n  GT_VUE_PACKAGE,\n  parseLocalDependencyPath,\n  parseNpmDependencyAlias,\n  parseWorkspaceDependencyAlias,\n  readPropagatingDependencyBindings,\n  readWorkspaceDependencyBindings,\n  readWorkspaceDependencyNames,\n  readJavaScriptPackageManifest,\n  resolveInstalledJavaScriptPackage,\n  type JavaScriptDependencyBinding,\n  type JavaScriptPackageManifest,\n} from './manifest.js';\nimport { localDependencyGraphDeclaresVue } from './detectVueProject.js';\nimport {\n  createConsumerUsageCache,\n  packageConsumesPublicGT,\n  packageExposesPublicGT,\n  type ConsumerUsageCache,\n} from './consumerUsage.js';\nimport { DEFAULT_VUE_SOURCE_PATTERNS } from './sourcePatterns.js';\n\nexport { DEFAULT_VUE_SOURCE_PATTERNS } from './sourcePatterns.js';\n\n/** One package boundary whose sources share Vue build configuration. */\nexport type VueSourceScope = {\n  directory: string;\n  includeByDefault: boolean;\n  relativeDirectory: string;\n};\n\n/** Project discovery result reused by detection and extraction. */\nexport type VueProjectDiscovery = {\n  projectRoot: string;\n  rootOwnsVue: boolean;\n  rootManifest?: JavaScriptPackageManifest;\n  scopes: VueSourceScope[];\n};\n\n/**\n * Discovers only packages that own gt-vue or consume a selected local wrapper.\n *\n * An aggregator root is not scanned merely because one child uses Vue. It is\n * included only when it directly declares gt-vue or depends on a proven local\n * wrapper. This is the boundary that prevents Vue support from broadening\n * existing React source discovery.\n */\nexport function discoverVueProject(\n  cwd: string,\n  cache: WorkspaceDiscoveryCache = createWorkspaceDiscoveryCache()\n): VueProjectDiscovery {\n  const projectRoot = resolveProjectDirectory(cwd);\n  const rootManifest = readJavaScriptPackageManifest(\n    path.join(projectRoot, 'package.json')\n  );\n  if (!rootManifest) {\n    return { projectRoot, rootOwnsVue: false, scopes: [] };\n  }\n\n  const workspacePackages = readDeclaredWorkspacePackages(\n    projectRoot,\n    rootManifest,\n    cache\n  );\n  const consumerUsageCache = createConsumerUsageCache();\n  const workspaceSelection = selectVueWorkspacePackages(\n    workspacePackages,\n    rootManifest,\n    projectRoot,\n    consumerUsageCache\n  );\n  const selectedWorkspacePackages = workspaceSelection.packages;\n  const rootDeclaresVue = declaresAvailableJavaScriptDependency(\n    rootManifest,\n    GT_VUE_PACKAGE,\n    projectRoot\n  );\n  const rootConsumesVueWrapper = consumesSelectedWorkspace(\n    { directory: projectRoot, manifest: rootManifest },\n    selectedWorkspacePackages.filter(({ directory }) =>\n      workspaceSelection.propagatingDirectories.has(directory)\n    ),\n    consumerUsageCache\n  );\n  const rootConsumesLocalVueWrapper = localDependencyGraphDeclaresVue(\n    rootManifest,\n    projectRoot,\n    consumerUsageCache\n  );\n  const scopes: VueSourceScope[] = [];\n\n  const rootOwnsVue =\n    rootDeclaresVue || rootConsumesVueWrapper || rootConsumesLocalVueWrapper;\n  if (rootOwnsVue) {\n    scopes.push({\n      directory: projectRoot,\n      includeByDefault: true,\n      relativeDirectory: '',\n    });\n  }\n  for (const { directory } of selectedWorkspacePackages) {\n    const relativeDirectory = toPosixPath(\n      path.relative(projectRoot, directory)\n    );\n    if (\n      !relativeDirectory ||\n      relativeDirectory === '..' ||\n      relativeDirectory.startsWith('../')\n    ) {\n      continue;\n    }\n    scopes.push({\n      directory,\n      includeByDefault: true,\n      relativeDirectory,\n    });\n  }\n\n  return { projectRoot, rootManifest, rootOwnsVue, scopes };\n}\n\n/** Canonicalizes existing roots so macOS path aliases share one ownership tree. */\nexport function resolveProjectDirectory(directory: string): string {\n  try {\n    return fs.realpathSync(path.resolve(directory));\n  } catch {\n    return path.resolve(directory);\n  }\n}\n\n/** Returns safe project-root-relative default globs for selected Vue scopes. */\nexport function readDefaultVueSourcePatterns(\n  scopes: readonly VueSourceScope[]\n): string[] {\n  const patterns = scopes.flatMap(({ includeByDefault, relativeDirectory }) => {\n    if (!includeByDefault) return [];\n    if (!relativeDirectory) return [...DEFAULT_VUE_SOURCE_PATTERNS];\n    const literalDirectory = fg.escapePath(relativeDirectory);\n    return DEFAULT_VUE_SOURCE_PATTERNS.map(\n      (pattern) => `${literalDirectory}/${pattern}`\n    );\n  });\n  return [...new Set(patterns)];\n}\n\n/** Selects the deepest declared Vue package containing a source file. */\nexport function findVueSourceScope(\n  file: string,\n  scopes: readonly VueSourceScope[]\n): VueSourceScope | undefined {\n  return [...scopes]\n    .sort((left, right) => right.directory.length - left.directory.length)\n    .find(({ directory }) => isWithin(directory, file));\n}\n\nfunction selectVueWorkspacePackages(\n  workspacePackages: readonly DeclaredWorkspacePackage[],\n  rootManifest: JavaScriptPackageManifest,\n  projectRoot: string,\n  consumerUsageCache: ConsumerUsageCache\n): {\n  packages: DeclaredWorkspacePackage[];\n  propagatingDirectories: Set<string>;\n} {\n  const selectedDirectories = new Set<string>();\n  const propagatingDirectories = new Set<string>();\n  const queuedPropagators = new Set<string>();\n  const pendingPackages: DeclaredWorkspacePackage[] = [];\n  const publicGTByDirectory = new Map<string, boolean>();\n  const publiclyExposesGT = ({\n    directory,\n    manifest,\n  }: DeclaredWorkspacePackage): boolean => {\n    const cached = publicGTByDirectory.get(directory);\n    if (cached !== undefined) return cached;\n    const exposesGT = packageExposesPublicGT(\n      directory,\n      manifest,\n      consumerUsageCache\n    );\n    publicGTByDirectory.set(directory, exposesGT);\n    return exposesGT;\n  };\n  const selectPackage = (\n    selectedPackage: DeclaredWorkspacePackage,\n    propagates: boolean\n  ) => {\n    selectedDirectories.add(selectedPackage.directory);\n    if (!propagates || queuedPropagators.has(selectedPackage.directory)) {\n      return;\n    }\n    propagatingDirectories.add(selectedPackage.directory);\n    queuedPropagators.add(selectedPackage.directory);\n    pendingPackages.push(selectedPackage);\n  };\n  if (\n    declaresAvailableJavaScriptDependency(\n      rootManifest,\n      GT_VUE_PACKAGE,\n      projectRoot\n    )\n  ) {\n    selectPackage(\n      { directory: projectRoot, manifest: rootManifest },\n      publiclyExposesGT({ directory: projectRoot, manifest: rootManifest })\n    );\n  }\n  for (const workspacePackage of workspacePackages) {\n    if (\n      !declaresWorkspaceJavaScriptDependency(\n        workspacePackage.manifest,\n        GT_VUE_PACKAGE,\n        workspacePackage.directory\n      )\n    ) {\n      continue;\n    }\n    selectPackage(workspacePackage, publiclyExposesGT(workspacePackage));\n  }\n\n  // A pure non-Vue workspace has no ownership seed to propagate. Avoid\n  // walking every dependency edge after the manifest scan has already proved\n  // that no package directly owns gt-vue.\n  if (pendingPackages.length === 0) {\n    return {\n      packages: workspacePackages.filter(({ directory }) =>\n        selectedDirectories.has(directory)\n      ),\n      propagatingDirectories,\n    };\n  }\n\n  const consumersByDependency = new Map<string, DeclaredWorkspacePackage[]>();\n  for (const workspacePackage of workspacePackages) {\n    for (const dependencyName of readWorkspaceDependencyNames(\n      workspacePackage.manifest,\n      workspacePackage.directory\n    )) {\n      const consumers = consumersByDependency.get(dependencyName) ?? [];\n      consumers.push(workspacePackage);\n      consumersByDependency.set(dependencyName, consumers);\n    }\n  }\n\n  for (let index = 0; index < pendingPackages.length; index += 1) {\n    const selectedPackage = pendingPackages[index]!;\n    const selectedName = readPackageName(selectedPackage.manifest);\n    if (!selectedName) continue;\n    for (const consumer of consumersByDependency.get(selectedName) ?? []) {\n      if (propagatingDirectories.has(consumer.directory)) continue;\n      if (\n        !consumesCompatibleWorkspace(\n          consumer,\n          selectedPackage,\n          false,\n          consumerUsageCache\n        )\n      ) {\n        continue;\n      }\n      selectPackage(\n        consumer,\n        consumesCompatibleWorkspace(\n          consumer,\n          selectedPackage,\n          true,\n          consumerUsageCache\n        ) && publiclyExposesGT(consumer)\n      );\n    }\n  }\n\n  return {\n    packages: workspacePackages.filter(({ directory }) =>\n      selectedDirectories.has(directory)\n    ),\n    propagatingDirectories,\n  };\n}\n\nfunction consumesSelectedWorkspace(\n  consumer: DeclaredWorkspacePackage,\n  selectedPackages: readonly DeclaredWorkspacePackage[],\n  consumerUsageCache: ConsumerUsageCache\n): boolean {\n  return selectedPackages.some((selectedPackage) =>\n    consumesCompatibleWorkspace(\n      consumer,\n      selectedPackage,\n      false,\n      consumerUsageCache\n    )\n  );\n}\n\n/** Checks that a compatible dependency edge is used by consumer source. */\nfunction consumesCompatibleWorkspace(\n  consumer: DeclaredWorkspacePackage,\n  selected: DeclaredWorkspacePackage,\n  propagatingOnly: boolean,\n  consumerUsageCache: ConsumerUsageCache\n): boolean {\n  const packageName = readPackageName(selected.manifest);\n  if (!packageName) return false;\n  const bindings = propagatingOnly\n    ? readPropagatingDependencyBindings(consumer.manifest, consumer.directory)\n    : readWorkspaceDependencyBindings(consumer.manifest, consumer.directory);\n  return bindings.some(\n    (binding) =>\n      dependencyBindingMatchesWorkspace(\n        binding,\n        packageName,\n        selected,\n        consumer.directory\n      ) &&\n      packageConsumesPublicGT(\n        consumer.directory,\n        binding.name,\n        selected.directory,\n        selected.manifest,\n        consumerUsageCache\n      )\n  );\n}\n\nfunction dependencyBindingMatchesWorkspace(\n  binding: JavaScriptDependencyBinding,\n  workspaceName: string,\n  selected: DeclaredWorkspacePackage,\n  consumerDirectory: string\n): boolean {\n  const workspaceAlias = parseWorkspaceDependencyAlias(binding.specifier);\n  const npmAlias = parseNpmDependencyAlias(binding.specifier);\n  const catalogPackage = binding.specifier.startsWith('catalog:')\n    ? resolveInstalledJavaScriptPackage(consumerDirectory, binding.name)\n    : undefined;\n  const namesWorkspace = binding.name === workspaceName;\n  const aliasesWorkspace =\n    workspaceAlias?.packageName === workspaceName ||\n    npmAlias?.packageName === workspaceName ||\n    catalogPackage?.manifest.name === workspaceName;\n  const localPath = parseLocalDependencyPath(binding.specifier);\n\n  if (localPath) {\n    return pathsIdentifySameDirectory(\n      path.resolve(consumerDirectory, localPath),\n      selected.directory\n    );\n  }\n  if (!namesWorkspace && !aliasesWorkspace) return false;\n  if (\n    !dependencyBindingAcceptsPackageVersion(\n      binding,\n      workspaceName,\n      selected.manifest.version\n    )\n  ) {\n    return false;\n  }\n\n  const installed =\n    catalogPackage ??\n    resolveInstalledJavaScriptPackage(consumerDirectory, binding.name);\n  if (\n    installed &&\n    pathsIdentifySameDirectory(installed.directory, selected.directory)\n  ) {\n    return true;\n  }\n\n  if (workspaceAlias?.packageName === workspaceName) {\n    return true;\n  }\n  if (namesWorkspace && binding.specifier.startsWith('workspace:')) {\n    return true;\n  }\n  // Bare semver, catalogs, and npm aliases may resolve to a registry package.\n  // They select a local wrapper only when the installed binding proves it.\n  return false;\n}\n\nfunction pathsIdentifySameDirectory(left: string, right: string): boolean {\n  try {\n    return fs.realpathSync(left) === fs.realpathSync(right);\n  } catch {\n    return path.resolve(left) === path.resolve(right);\n  }\n}\n\nfunction readPackageName(\n  manifest: JavaScriptPackageManifest\n): string | undefined {\n  return typeof manifest.name === 'string' && manifest.name\n    ? manifest.name\n    : undefined;\n}\n\nfunction isWithin(directory: string, file: string): boolean {\n  const relative = path.relative(path.resolve(directory), path.resolve(file));\n  return (\n    relative !== '' &&\n    relative !== '..' &&\n    !relative.startsWith(`..${path.sep}`) &&\n    !path.isAbsolute(relative)\n  );\n}\n\nfunction toPosixPath(filePath: string): string {\n  return filePath.split(path.sep).join(path.posix.sep);\n}\n"],"mappings":"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"}

package/dist/internal/project/sourcePatterns.d.ts

@@ -0,0 +1,4 @@
+/** Conventional source directories searched by default for Vue applications. */
+export declare const DEFAULT_VUE_SOURCE_DIRECTORIES: readonly ["src", "app", "pages", "components", "composables", "layers", "layouts", "middleware", "modules", "plugins", "server", "shared", "stores", "utils", "views"];
+/** Default Vue source patterns, including conventional Vue and Nuxt folders. */
+export declare const DEFAULT_VUE_SOURCE_PATTERNS: readonly ["*.vue", "src/**/*.{vue,js,jsx,mjs,cjs,ts,tsx,mts,cts}", "app/**/*.{vue,js,jsx,mjs,cjs,ts,tsx,mts,cts}", "pages/**/*.{vue,js,jsx,mjs,cjs,ts,tsx,mts,cts}", "components/**/*.{vue,js,jsx,mjs,cjs,ts,tsx,mts,cts}", "{composables,layers,layouts,middleware,modules,plugins,server,shared,stores,utils,views}/**/*.{vue,js,jsx,mjs,cjs,ts,tsx,mts,cts}"];