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

package/dist/internal/project/workspaces.js

@@ -0,0 +1,326 @@
+import fs from "node:fs";
+import path from "node:path";
+import fg from "fast-glob";
+import { parse } from "yaml";
+//#region src/internal/project/workspaces.ts
+const ASYNC_WORKSPACE_READ_CONCURRENCY = 64;
+/** Creates an isolated workspace cache for one detection or extraction call. */
+function createWorkspaceDiscoveryCache() {
+	return /* @__PURE__ */ new Map();
+}
+/**
+* Reads declared workspace packages without following paths outside the root.
+*
+* A valid `pnpm-workspace.yaml` is authoritative over `package.json` because
+* pnpm uses that file to include and exclude packages. Malformed workspace
+* metadata is treated as no optional workspaces; it never hides a known root
+* application or causes extraction to traverse the filesystem recursively.
+*/
+function readDeclaredWorkspacePackages(cwd, rootManifest, cache) {
+	const cacheKey = path.resolve(cwd);
+	const manifestWorkspaces = JSON.stringify(rootManifest.workspaces ?? null);
+	const cached = cache.get(cacheKey);
+	if (cached?.manifestWorkspaces === manifestWorkspaces) return cached.packages;
+	const patterns = getPnpmWorkspacePatterns(cwd) ?? getPackageJsonWorkspacePatterns(rootManifest);
+	const manifestPatterns = [...new Set(patterns.map(toManifestPattern))].filter((pattern) => pattern !== null);
+	if (!manifestPatterns.some((pattern) => !pattern.startsWith("!"))) return cacheWorkspacePackages(cache, cacheKey, manifestWorkspaces, []);
+	const realRoot = readRealPath(cwd);
+	if (!realRoot) return cacheWorkspacePackages(cache, cacheKey, manifestWorkspaces, []);
+	const shallowPackagePaths = readShallowWorkspaceManifestPaths(cwd, realRoot, manifestPatterns);
+	const packagePaths = shallowPackagePaths ?? readWorkspaceManifestPathsWithGlob(cwd, manifestPatterns);
+	if (!packagePaths) return cacheWorkspacePackages(cache, cacheKey, manifestWorkspaces, []);
+	packagePaths.sort(comparePaths);
+	const rootPackagePath = path.resolve(cwd, "package.json");
+	return cacheWorkspacePackages(cache, cacheKey, manifestWorkspaces, packagePaths.flatMap((packagePath) => {
+		const absolutePath = path.resolve(packagePath);
+		if (absolutePath === rootPackagePath || !isWithinRoot(cwd, absolutePath) || absolutePath.split(path.sep).includes("node_modules")) return [];
+		const manifestPath = shallowPackagePaths ? absolutePath : readValidatedManifestPath(realRoot, absolutePath);
+		if (!manifestPath) return [];
+		const manifest = readWorkspacePackageManifest(manifestPath);
+		return manifest ? [{
+			directory: path.dirname(absolutePath),
+			manifest
+		}] : [];
+	}));
+}
+/**
+* Reads declared workspace packages without blocking on every manifest.
+*
+* The returned packages and cache entry are identical to the synchronous
+* implementation. Project inspection can populate this cache concurrently
+* with a host framework's existing extraction, then reuse the established
+* synchronous ownership logic without traversing the workspace twice.
+*/
+async function readDeclaredWorkspacePackagesAsync(cwd, rootManifest, cache) {
+	const cacheKey = path.resolve(cwd);
+	const manifestWorkspaces = JSON.stringify(rootManifest.workspaces ?? null);
+	const cached = cache.get(cacheKey);
+	if (cached?.manifestWorkspaces === manifestWorkspaces) return cached.packages;
+	const patterns = await getPnpmWorkspacePatternsAsync(cwd) ?? getPackageJsonWorkspacePatterns(rootManifest);
+	const manifestPatterns = [...new Set(patterns.map(toManifestPattern))].filter((pattern) => pattern !== null);
+	if (!manifestPatterns.some((pattern) => !pattern.startsWith("!"))) return cacheWorkspacePackages(cache, cacheKey, manifestWorkspaces, []);
+	const realRoot = await readRealPathAsync(cwd);
+	if (!realRoot) return cacheWorkspacePackages(cache, cacheKey, manifestWorkspaces, []);
+	const shallowPackagePaths = await readShallowWorkspaceManifestPathsAsync(cwd, realRoot, manifestPatterns);
+	let packagePaths;
+	if (shallowPackagePaths) packagePaths = shallowPackagePaths;
+	else try {
+		packagePaths = await fg([...manifestPatterns], workspaceGlobOptions(cwd));
+	} catch {
+		packagePaths = void 0;
+	}
+	if (!packagePaths) return cacheWorkspacePackages(cache, cacheKey, manifestWorkspaces, []);
+	packagePaths.sort(comparePaths);
+	const rootPackagePath = path.resolve(cwd, "package.json");
+	return cacheWorkspacePackages(cache, cacheKey, manifestWorkspaces, (await mapWithConcurrency(packagePaths, ASYNC_WORKSPACE_READ_CONCURRENCY, async (packagePath) => {
+		const absolutePath = path.resolve(packagePath);
+		if (absolutePath === rootPackagePath || !isWithinRoot(cwd, absolutePath) || absolutePath.split(path.sep).includes("node_modules")) return;
+		const manifestPath = shallowPackagePaths ? absolutePath : await readValidatedManifestPathAsync(realRoot, absolutePath);
+		if (!manifestPath) return void 0;
+		const manifest = await readJavaScriptPackageManifestAsync(manifestPath);
+		return manifest ? {
+			directory: path.dirname(absolutePath),
+			manifest
+		} : void 0;
+	})).filter((workspacePackage) => workspacePackage !== void 0));
+}
+/**
+* Finds workspace manifests, optimizing only the common shallow-positive form.
+*
+* A pattern such as `packages/<child>/package.json` can be resolved with one
+* directory read instead of traversing every child directory. All negative,
+* nested, or otherwise dynamic patterns keep fast-glob's existing behavior.
+*/
+function readShallowWorkspaceManifestPaths(cwd, realRoot, manifestPatterns) {
+	const shallowBases = readShallowPositiveBases(manifestPatterns);
+	if (!shallowBases) return void 0;
+	try {
+		const paths = shallowBases.flatMap((base) => {
+			const baseDirectory = path.resolve(cwd, base);
+			if (!isSafeShallowBase(realRoot, readRealPath(baseDirectory))) return [];
+			try {
+				return fs.readdirSync(baseDirectory, { withFileTypes: true }).filter(isVisibleDirectoryEntry).map((entry) => path.join(baseDirectory, entry.name, "package.json"));
+			} catch {
+				return [];
+			}
+		});
+		return [...new Set(paths)];
+	} catch {
+		return;
+	}
+}
+/** Asynchronous counterpart to {@link readShallowWorkspaceManifestPaths}. */
+async function readShallowWorkspaceManifestPathsAsync(cwd, realRoot, manifestPatterns) {
+	const shallowBases = readShallowPositiveBases(manifestPatterns);
+	if (!shallowBases) return void 0;
+	try {
+		const paths = (await Promise.all(shallowBases.map(async (base) => {
+			const baseDirectory = path.resolve(cwd, base);
+			if (!isSafeShallowBase(realRoot, await readRealPathAsync(baseDirectory))) return {
+				baseDirectory,
+				entries: []
+			};
+			try {
+				return {
+					baseDirectory,
+					entries: await fs.promises.readdir(baseDirectory, { withFileTypes: true })
+				};
+			} catch {
+				return {
+					baseDirectory,
+					entries: []
+				};
+			}
+		}))).flatMap(({ baseDirectory, entries }) => entries.filter(isVisibleDirectoryEntry).map((entry) => path.join(baseDirectory, entry.name, "package.json")));
+		return [...new Set(paths)];
+	} catch {
+		return;
+	}
+}
+/** Uses fast-glob for workspace layouts outside the bounded shallow form. */
+function readWorkspaceManifestPathsWithGlob(cwd, manifestPatterns) {
+	try {
+		return fg.sync([...manifestPatterns], workspaceGlobOptions(cwd));
+	} catch {
+		return;
+	}
+}
+/** Shared options preserve the historical fast-glob matching semantics. */
+function workspaceGlobOptions(cwd) {
+	return {
+		absolute: true,
+		cwd,
+		followSymbolicLinks: false,
+		ignore: ["**/node_modules/**"],
+		onlyFiles: true,
+		unique: true
+	};
+}
+/**
+* Reads literal bases from patterns shaped like `<base>/<child>/package.json`.
+* Hidden child directories are intentionally excluded to match fast-glob's
+* default `dot: false` behavior.
+*/
+function readShallowPositiveBases(manifestPatterns) {
+	const bases = [];
+	for (const pattern of manifestPatterns) {
+		if (pattern.startsWith("!")) return void 0;
+		const segments = pattern.split("/");
+		if (segments.length < 2 || segments.at(-1) !== "package.json" || segments.at(-2) !== "*") return;
+		const base = segments.slice(0, -2).join("/") || ".";
+		if (fg.isDynamicPattern(base)) return void 0;
+		bases.push(base);
+	}
+	return [...new Set(bases)];
+}
+/** Matches only visible physical directories, excluding symlinked workspaces. */
+function isVisibleDirectoryEntry(entry) {
+	return !entry.name.startsWith(".") && entry.isDirectory();
+}
+/** Validates one physical shallow base before skipping per-manifest realpath. */
+function isSafeShallowBase(realRoot, realBase) {
+	if (!realBase || !isWithinOrEqualRoot(realRoot, realBase)) return false;
+	return !path.relative(realRoot, realBase).split(path.sep).includes("node_modules");
+}
+function cacheWorkspacePackages(cache, cacheKey, manifestWorkspaces, packages) {
+	cache.set(cacheKey, {
+		manifestWorkspaces,
+		packages
+	});
+	return packages;
+}
+function getPackageJsonWorkspacePatterns(manifest) {
+	if (Array.isArray(manifest.workspaces)) return manifest.workspaces.filter((pattern) => typeof pattern === "string");
+	if (manifest.workspaces && typeof manifest.workspaces === "object" && Array.isArray(manifest.workspaces.packages)) return manifest.workspaces.packages.filter((pattern) => typeof pattern === "string");
+	return [];
+}
+function getPnpmWorkspacePatterns(cwd) {
+	const workspacePath = path.join(cwd, "pnpm-workspace.yaml");
+	if (!fs.existsSync(workspacePath)) return void 0;
+	try {
+		const parsed = parse(fs.readFileSync(workspacePath, "utf8"));
+		if (parsed == null) return [];
+		if (!isRecord(parsed)) return [];
+		if (parsed.packages == null) return [];
+		if (!Array.isArray(parsed.packages)) return [];
+		return parsed.packages.filter((pattern) => typeof pattern === "string");
+	} catch {
+		return [];
+	}
+}
+async function getPnpmWorkspacePatternsAsync(cwd) {
+	const workspacePath = path.join(cwd, "pnpm-workspace.yaml");
+	if (!fs.existsSync(workspacePath)) return void 0;
+	try {
+		const parsed = parse(await fs.promises.readFile(workspacePath, "utf8"));
+		if (parsed == null) return [];
+		if (!isRecord(parsed)) return [];
+		if (parsed.packages == null) return [];
+		if (!Array.isArray(parsed.packages)) return [];
+		return parsed.packages.filter((pattern) => typeof pattern === "string");
+	} catch {
+		return [];
+	}
+}
+function toManifestPattern(pattern) {
+	const trimmed = pattern.trim();
+	const negated = trimmed.startsWith("!");
+	const rawPattern = negated ? trimmed.slice(1) : trimmed;
+	if (!rawPattern) return null;
+	const normalized = path.posix.normalize(rawPattern.replaceAll("\\", "/"));
+	if (path.posix.isAbsolute(normalized) || path.win32.isAbsolute(normalized) || /^[A-Za-z]:/.test(normalized) || containsParentTraversal(normalized) || normalized === ".." || normalized.startsWith("../")) return null;
+	const withoutTrailingSlash = normalized.replace(/\/+$/, "");
+	const manifestPattern = withoutTrailingSlash.endsWith("/package.json") ? withoutTrailingSlash : `${withoutTrailingSlash}/package.json`;
+	return negated ? `!${manifestPattern}` : manifestPattern;
+}
+/** Rejects parent segments, including those hidden in glob alternatives. */
+function containsParentTraversal(pattern) {
+	return /(^|[/{,(|])\.\.(?=$|[/},)|])/.test(pattern);
+}
+function readRealPath(filePath) {
+	try {
+		return fs.realpathSync(filePath);
+	} catch {
+		return;
+	}
+}
+async function readRealPathAsync(filePath) {
+	try {
+		return await fs.promises.realpath(filePath);
+	} catch {
+		return;
+	}
+}
+/** Preserves the historical physical containment check for glob fallbacks. */
+function readValidatedManifestPath(realRoot, packagePath) {
+	const realPackagePath = readRealPath(packagePath);
+	return realPackagePath && isWithinRoot(realRoot, realPackagePath) && !realPackagePath.split(path.sep).includes("node_modules") ? realPackagePath : void 0;
+}
+/** Asynchronous counterpart to {@link readValidatedManifestPath}. */
+async function readValidatedManifestPathAsync(realRoot, packagePath) {
+	const realPackagePath = await readRealPathAsync(packagePath);
+	return realPackagePath && isWithinRoot(realRoot, realPackagePath) && !realPackagePath.split(path.sep).includes("node_modules") ? realPackagePath : void 0;
+}
+async function readJavaScriptPackageManifestAsync(packagePath) {
+	let file;
+	try {
+		if (!(await fs.promises.lstat(packagePath)).isFile()) return void 0;
+		file = await fs.promises.open(packagePath, workspaceManifestOpenFlags());
+		const parsed = JSON.parse(await file.readFile("utf8"));
+		return isRecord(parsed) ? parsed : void 0;
+	} catch {
+		return;
+	} finally {
+		await file?.close();
+	}
+}
+/** Reads a workspace manifest without following a manifest-file symlink. */
+function readWorkspacePackageManifest(packagePath) {
+	let descriptor;
+	try {
+		if (!fs.lstatSync(packagePath).isFile()) return void 0;
+		descriptor = fs.openSync(packagePath, workspaceManifestOpenFlags());
+		const parsed = JSON.parse(fs.readFileSync(descriptor, "utf8"));
+		return isRecord(parsed) ? parsed : void 0;
+	} catch {
+		return;
+	} finally {
+		if (descriptor !== void 0) fs.closeSync(descriptor);
+	}
+}
+/** Prevents a shallow workspace candidate from redirecting its manifest. */
+function workspaceManifestOpenFlags() {
+	return fs.constants.O_RDONLY | (fs.constants.O_NOFOLLOW ?? 0);
+}
+/** Maps filesystem work concurrently without exhausting file descriptors. */
+async function mapWithConcurrency(values, concurrency, mapper) {
+	const results = Array.from({ length: values.length });
+	let nextIndex = 0;
+	const worker = async () => {
+		while (nextIndex < values.length) {
+			const index = nextIndex;
+			nextIndex += 1;
+			results[index] = await mapper(values[index]);
+		}
+	};
+	await Promise.all(Array.from({ length: Math.min(concurrency, values.length) }, () => worker()));
+	return results;
+}
+function isWithinRoot(root, candidate) {
+	const relativePath = path.relative(path.resolve(root), candidate);
+	return relativePath !== "" && relativePath !== ".." && !relativePath.startsWith(`..${path.sep}`) && !path.isAbsolute(relativePath);
+}
+/** Checks physical containment while allowing the project root itself. */
+function isWithinOrEqualRoot(root, candidate) {
+	return path.resolve(root) === path.resolve(candidate) || isWithinRoot(root, candidate);
+}
+function isRecord(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function comparePaths(left, right) {
+	return left < right ? -1 : left > right ? 1 : 0;
+}
+//#endregion
+export { createWorkspaceDiscoveryCache, readDeclaredWorkspacePackages, readDeclaredWorkspacePackagesAsync };
+
+//# sourceMappingURL=workspaces.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"workspaces.js","names":["parseYaml"],"sources":["../../../src/internal/project/workspaces.ts"],"sourcesContent":["import fs from 'node:fs';\nimport path from 'node:path';\nimport fg from 'fast-glob';\nimport { parse as parseYaml } from 'yaml';\nimport type { JavaScriptPackageManifest } from './manifest.js';\n\nconst ASYNC_WORKSPACE_READ_CONCURRENCY = 64;\n\n/** A validated workspace package and its parsed manifest. */\nexport type DeclaredWorkspacePackage = {\n  directory: string;\n  manifest: JavaScriptPackageManifest;\n};\n\n/** Per-extraction cache that avoids traversing the same workspace repeatedly. */\nexport type WorkspaceDiscoveryCache = Map<\n  string,\n  { manifestWorkspaces: string; packages: DeclaredWorkspacePackage[] }\n>;\n\n/** Creates an isolated workspace cache for one detection or extraction call. */\nexport function createWorkspaceDiscoveryCache(): WorkspaceDiscoveryCache {\n  return new Map();\n}\n\n/**\n * Reads declared workspace packages without following paths outside the root.\n *\n * A valid `pnpm-workspace.yaml` is authoritative over `package.json` because\n * pnpm uses that file to include and exclude packages. Malformed workspace\n * metadata is treated as no optional workspaces; it never hides a known root\n * application or causes extraction to traverse the filesystem recursively.\n */\nexport function readDeclaredWorkspacePackages(\n  cwd: string,\n  rootManifest: JavaScriptPackageManifest,\n  cache: WorkspaceDiscoveryCache\n): DeclaredWorkspacePackage[] {\n  const cacheKey = path.resolve(cwd);\n  const manifestWorkspaces = JSON.stringify(rootManifest.workspaces ?? null);\n  const cached = cache.get(cacheKey);\n  if (cached?.manifestWorkspaces === manifestWorkspaces) {\n    return cached.packages;\n  }\n\n  const pnpmPatterns = getPnpmWorkspacePatterns(cwd);\n  const patterns =\n    pnpmPatterns ?? getPackageJsonWorkspacePatterns(rootManifest);\n  const manifestPatterns = [...new Set(patterns.map(toManifestPattern))].filter(\n    (pattern): pattern is string => pattern !== null\n  );\n  if (!manifestPatterns.some((pattern) => !pattern.startsWith('!'))) {\n    return cacheWorkspacePackages(cache, cacheKey, manifestWorkspaces, []);\n  }\n\n  const realRoot = readRealPath(cwd);\n  if (!realRoot) {\n    return cacheWorkspacePackages(cache, cacheKey, manifestWorkspaces, []);\n  }\n\n  const shallowPackagePaths = readShallowWorkspaceManifestPaths(\n    cwd,\n    realRoot,\n    manifestPatterns\n  );\n  const packagePaths =\n    shallowPackagePaths ??\n    readWorkspaceManifestPathsWithGlob(cwd, manifestPatterns);\n  if (!packagePaths) {\n    return cacheWorkspacePackages(cache, cacheKey, manifestWorkspaces, []);\n  }\n  packagePaths.sort(comparePaths);\n\n  const rootPackagePath = path.resolve(cwd, 'package.json');\n  const packages = packagePaths.flatMap((packagePath) => {\n    const absolutePath = path.resolve(packagePath);\n    if (\n      absolutePath === rootPackagePath ||\n      !isWithinRoot(cwd, absolutePath) ||\n      absolutePath.split(path.sep).includes('node_modules')\n    ) {\n      return [];\n    }\n\n    const manifestPath = shallowPackagePaths\n      ? absolutePath\n      : readValidatedManifestPath(realRoot, absolutePath);\n    if (!manifestPath) return [];\n    const manifest = readWorkspacePackageManifest(manifestPath);\n    return manifest\n      ? [{ directory: path.dirname(absolutePath), manifest }]\n      : [];\n  });\n  return cacheWorkspacePackages(cache, cacheKey, manifestWorkspaces, packages);\n}\n\n/**\n * Reads declared workspace packages without blocking on every manifest.\n *\n * The returned packages and cache entry are identical to the synchronous\n * implementation. Project inspection can populate this cache concurrently\n * with a host framework's existing extraction, then reuse the established\n * synchronous ownership logic without traversing the workspace twice.\n */\nexport async function readDeclaredWorkspacePackagesAsync(\n  cwd: string,\n  rootManifest: JavaScriptPackageManifest,\n  cache: WorkspaceDiscoveryCache\n): Promise<DeclaredWorkspacePackage[]> {\n  const cacheKey = path.resolve(cwd);\n  const manifestWorkspaces = JSON.stringify(rootManifest.workspaces ?? null);\n  const cached = cache.get(cacheKey);\n  if (cached?.manifestWorkspaces === manifestWorkspaces) {\n    return cached.packages;\n  }\n\n  const pnpmPatterns = await getPnpmWorkspacePatternsAsync(cwd);\n  const patterns =\n    pnpmPatterns ?? getPackageJsonWorkspacePatterns(rootManifest);\n  const manifestPatterns = [...new Set(patterns.map(toManifestPattern))].filter(\n    (pattern): pattern is string => pattern !== null\n  );\n  if (!manifestPatterns.some((pattern) => !pattern.startsWith('!'))) {\n    return cacheWorkspacePackages(cache, cacheKey, manifestWorkspaces, []);\n  }\n\n  const realRoot = await readRealPathAsync(cwd);\n  if (!realRoot) {\n    return cacheWorkspacePackages(cache, cacheKey, manifestWorkspaces, []);\n  }\n\n  const shallowPackagePaths = await readShallowWorkspaceManifestPathsAsync(\n    cwd,\n    realRoot,\n    manifestPatterns\n  );\n  let packagePaths: string[] | undefined;\n  if (shallowPackagePaths) {\n    packagePaths = shallowPackagePaths;\n  } else {\n    try {\n      packagePaths = await fg([...manifestPatterns], workspaceGlobOptions(cwd));\n    } catch {\n      packagePaths = undefined;\n    }\n  }\n  if (!packagePaths) {\n    return cacheWorkspacePackages(cache, cacheKey, manifestWorkspaces, []);\n  }\n  packagePaths.sort(comparePaths);\n\n  const rootPackagePath = path.resolve(cwd, 'package.json');\n  const packageResults = await mapWithConcurrency(\n    packagePaths,\n    ASYNC_WORKSPACE_READ_CONCURRENCY,\n    async (packagePath) => {\n      const absolutePath = path.resolve(packagePath);\n      if (\n        absolutePath === rootPackagePath ||\n        !isWithinRoot(cwd, absolutePath) ||\n        absolutePath.split(path.sep).includes('node_modules')\n      ) {\n        return undefined;\n      }\n\n      const manifestPath = shallowPackagePaths\n        ? absolutePath\n        : await readValidatedManifestPathAsync(realRoot, absolutePath);\n      if (!manifestPath) return undefined;\n      const manifest = await readJavaScriptPackageManifestAsync(manifestPath);\n      return manifest\n        ? { directory: path.dirname(absolutePath), manifest }\n        : undefined;\n    }\n  );\n  const packages = packageResults.filter(\n    (workspacePackage): workspacePackage is DeclaredWorkspacePackage =>\n      workspacePackage !== undefined\n  );\n  return cacheWorkspacePackages(cache, cacheKey, manifestWorkspaces, packages);\n}\n\n/**\n * Finds workspace manifests, optimizing only the common shallow-positive form.\n *\n * A pattern such as `packages/<child>/package.json` can be resolved with one\n * directory read instead of traversing every child directory. All negative,\n * nested, or otherwise dynamic patterns keep fast-glob's existing behavior.\n */\nfunction readShallowWorkspaceManifestPaths(\n  cwd: string,\n  realRoot: string,\n  manifestPatterns: readonly string[]\n): string[] | undefined {\n  const shallowBases = readShallowPositiveBases(manifestPatterns);\n  if (!shallowBases) return undefined;\n\n  try {\n    const paths = shallowBases.flatMap((base) => {\n      const baseDirectory = path.resolve(cwd, base);\n      if (!isSafeShallowBase(realRoot, readRealPath(baseDirectory))) return [];\n      try {\n        return fs\n          .readdirSync(baseDirectory, { withFileTypes: true })\n          .filter(isVisibleDirectoryEntry)\n          .map((entry) => path.join(baseDirectory, entry.name, 'package.json'));\n      } catch {\n        return [];\n      }\n    });\n    return [...new Set(paths)];\n  } catch {\n    return undefined;\n  }\n}\n\n/** Asynchronous counterpart to {@link readShallowWorkspaceManifestPaths}. */\nasync function readShallowWorkspaceManifestPathsAsync(\n  cwd: string,\n  realRoot: string,\n  manifestPatterns: readonly string[]\n): Promise<string[] | undefined> {\n  const shallowBases = readShallowPositiveBases(manifestPatterns);\n  if (!shallowBases) return undefined;\n\n  try {\n    const entriesByBase = await Promise.all(\n      shallowBases.map(async (base) => {\n        const baseDirectory = path.resolve(cwd, base);\n        const realBase = await readRealPathAsync(baseDirectory);\n        if (!isSafeShallowBase(realRoot, realBase)) {\n          return { baseDirectory, entries: [] };\n        }\n        try {\n          return {\n            baseDirectory,\n            entries: await fs.promises.readdir(baseDirectory, {\n              withFileTypes: true,\n            }),\n          };\n        } catch {\n          return { baseDirectory, entries: [] };\n        }\n      })\n    );\n    const paths = entriesByBase.flatMap(({ baseDirectory, entries }) =>\n      entries\n        .filter(isVisibleDirectoryEntry)\n        .map((entry) => path.join(baseDirectory, entry.name, 'package.json'))\n    );\n    return [...new Set(paths)];\n  } catch {\n    return undefined;\n  }\n}\n\n/** Uses fast-glob for workspace layouts outside the bounded shallow form. */\nfunction readWorkspaceManifestPathsWithGlob(\n  cwd: string,\n  manifestPatterns: readonly string[]\n): string[] | undefined {\n  try {\n    return fg.sync([...manifestPatterns], workspaceGlobOptions(cwd));\n  } catch {\n    return undefined;\n  }\n}\n\n/** Shared options preserve the historical fast-glob matching semantics. */\nfunction workspaceGlobOptions(\n  cwd: string\n): NonNullable<Parameters<typeof fg.sync>[1]> {\n  return {\n    absolute: true,\n    cwd,\n    followSymbolicLinks: false,\n    ignore: ['**/node_modules/**'],\n    onlyFiles: true,\n    unique: true,\n  };\n}\n\n/**\n * Reads literal bases from patterns shaped like `<base>/<child>/package.json`.\n * Hidden child directories are intentionally excluded to match fast-glob's\n * default `dot: false` behavior.\n */\nfunction readShallowPositiveBases(\n  manifestPatterns: readonly string[]\n): string[] | undefined {\n  const bases: string[] = [];\n  for (const pattern of manifestPatterns) {\n    if (pattern.startsWith('!')) return undefined;\n    const segments = pattern.split('/');\n    if (\n      segments.length < 2 ||\n      segments.at(-1) !== 'package.json' ||\n      segments.at(-2) !== '*'\n    ) {\n      return undefined;\n    }\n    const base = segments.slice(0, -2).join('/') || '.';\n    if (fg.isDynamicPattern(base)) return undefined;\n    bases.push(base);\n  }\n  return [...new Set(bases)];\n}\n\n/** Matches only visible physical directories, excluding symlinked workspaces. */\nfunction isVisibleDirectoryEntry(entry: fs.Dirent): boolean {\n  return !entry.name.startsWith('.') && entry.isDirectory();\n}\n\n/** Validates one physical shallow base before skipping per-manifest realpath. */\nfunction isSafeShallowBase(\n  realRoot: string,\n  realBase: string | undefined\n): boolean {\n  if (!realBase || !isWithinOrEqualRoot(realRoot, realBase)) return false;\n  const relative = path.relative(realRoot, realBase);\n  return !relative.split(path.sep).includes('node_modules');\n}\n\nfunction cacheWorkspacePackages(\n  cache: WorkspaceDiscoveryCache,\n  cacheKey: string,\n  manifestWorkspaces: string,\n  packages: DeclaredWorkspacePackage[]\n): DeclaredWorkspacePackage[] {\n  cache.set(cacheKey, { manifestWorkspaces, packages });\n  return packages;\n}\n\nfunction getPackageJsonWorkspacePatterns(\n  manifest: JavaScriptPackageManifest\n): string[] {\n  if (Array.isArray(manifest.workspaces)) {\n    return manifest.workspaces.filter(\n      (pattern): pattern is string => typeof pattern === 'string'\n    );\n  }\n  if (\n    manifest.workspaces &&\n    typeof manifest.workspaces === 'object' &&\n    Array.isArray(manifest.workspaces.packages)\n  ) {\n    return manifest.workspaces.packages.filter(\n      (pattern): pattern is string => typeof pattern === 'string'\n    );\n  }\n  return [];\n}\n\nfunction getPnpmWorkspacePatterns(cwd: string): string[] | undefined {\n  const workspacePath = path.join(cwd, 'pnpm-workspace.yaml');\n  if (!fs.existsSync(workspacePath)) return undefined;\n\n  try {\n    const parsed = parseYaml(fs.readFileSync(workspacePath, 'utf8')) as unknown;\n    if (parsed == null) return [];\n    if (!isRecord(parsed)) return [];\n    if (parsed.packages == null) return [];\n    if (!Array.isArray(parsed.packages)) return [];\n    return parsed.packages.filter(\n      (pattern): pattern is string => typeof pattern === 'string'\n    );\n  } catch {\n    return [];\n  }\n}\n\nasync function getPnpmWorkspacePatternsAsync(\n  cwd: string\n): Promise<string[] | undefined> {\n  const workspacePath = path.join(cwd, 'pnpm-workspace.yaml');\n  if (!fs.existsSync(workspacePath)) return undefined;\n\n  try {\n    const parsed = parseYaml(\n      await fs.promises.readFile(workspacePath, 'utf8')\n    ) as unknown;\n    if (parsed == null) return [];\n    if (!isRecord(parsed)) return [];\n    if (parsed.packages == null) return [];\n    if (!Array.isArray(parsed.packages)) return [];\n    return parsed.packages.filter(\n      (pattern): pattern is string => typeof pattern === 'string'\n    );\n  } catch {\n    return [];\n  }\n}\n\nfunction toManifestPattern(pattern: string): string | null {\n  const trimmed = pattern.trim();\n  const negated = trimmed.startsWith('!');\n  const rawPattern = negated ? trimmed.slice(1) : trimmed;\n  if (!rawPattern) return null;\n\n  const normalized = path.posix.normalize(rawPattern.replaceAll('\\\\', '/'));\n  if (\n    path.posix.isAbsolute(normalized) ||\n    path.win32.isAbsolute(normalized) ||\n    /^[A-Za-z]:/.test(normalized) ||\n    containsParentTraversal(normalized) ||\n    normalized === '..' ||\n    normalized.startsWith('../')\n  ) {\n    return null;\n  }\n\n  const withoutTrailingSlash = normalized.replace(/\\/+$/, '');\n  const manifestPattern = withoutTrailingSlash.endsWith('/package.json')\n    ? withoutTrailingSlash\n    : `${withoutTrailingSlash}/package.json`;\n  return negated ? `!${manifestPattern}` : manifestPattern;\n}\n\n/** Rejects parent segments, including those hidden in glob alternatives. */\nfunction containsParentTraversal(pattern: string): boolean {\n  return /(^|[/{,(|])\\.\\.(?=$|[/},)|])/.test(pattern);\n}\n\nfunction readRealPath(filePath: string): string | undefined {\n  try {\n    return fs.realpathSync(filePath);\n  } catch {\n    return undefined;\n  }\n}\n\nasync function readRealPathAsync(\n  filePath: string\n): Promise<string | undefined> {\n  try {\n    return await fs.promises.realpath(filePath);\n  } catch {\n    return undefined;\n  }\n}\n\n/** Preserves the historical physical containment check for glob fallbacks. */\nfunction readValidatedManifestPath(\n  realRoot: string,\n  packagePath: string\n): string | undefined {\n  const realPackagePath = readRealPath(packagePath);\n  return realPackagePath &&\n    isWithinRoot(realRoot, realPackagePath) &&\n    !realPackagePath.split(path.sep).includes('node_modules')\n    ? realPackagePath\n    : undefined;\n}\n\n/** Asynchronous counterpart to {@link readValidatedManifestPath}. */\nasync function readValidatedManifestPathAsync(\n  realRoot: string,\n  packagePath: string\n): Promise<string | undefined> {\n  const realPackagePath = await readRealPathAsync(packagePath);\n  return realPackagePath &&\n    isWithinRoot(realRoot, realPackagePath) &&\n    !realPackagePath.split(path.sep).includes('node_modules')\n    ? realPackagePath\n    : undefined;\n}\n\nasync function readJavaScriptPackageManifestAsync(\n  packagePath: string\n): Promise<JavaScriptPackageManifest | undefined> {\n  let file: fs.promises.FileHandle | undefined;\n  try {\n    const stats = await fs.promises.lstat(packagePath);\n    if (!stats.isFile()) return undefined;\n    file = await fs.promises.open(packagePath, workspaceManifestOpenFlags());\n    const parsed = JSON.parse(await file.readFile('utf8')) as unknown;\n    return isRecord(parsed) ? (parsed as JavaScriptPackageManifest) : undefined;\n  } catch {\n    return undefined;\n  } finally {\n    await file?.close();\n  }\n}\n\n/** Reads a workspace manifest without following a manifest-file symlink. */\nfunction readWorkspacePackageManifest(\n  packagePath: string\n): JavaScriptPackageManifest | undefined {\n  let descriptor: number | undefined;\n  try {\n    if (!fs.lstatSync(packagePath).isFile()) return undefined;\n    descriptor = fs.openSync(packagePath, workspaceManifestOpenFlags());\n    const parsed = JSON.parse(fs.readFileSync(descriptor, 'utf8')) as unknown;\n    return isRecord(parsed) ? (parsed as JavaScriptPackageManifest) : undefined;\n  } catch {\n    return undefined;\n  } finally {\n    if (descriptor !== undefined) fs.closeSync(descriptor);\n  }\n}\n\n/** Prevents a shallow workspace candidate from redirecting its manifest. */\nfunction workspaceManifestOpenFlags(): number {\n  return fs.constants.O_RDONLY | (fs.constants.O_NOFOLLOW ?? 0);\n}\n\n/** Maps filesystem work concurrently without exhausting file descriptors. */\nasync function mapWithConcurrency<Input, Output>(\n  values: readonly Input[],\n  concurrency: number,\n  mapper: (value: Input) => Promise<Output>\n): Promise<Output[]> {\n  const results = Array.from({ length: values.length }) as Output[];\n  let nextIndex = 0;\n  const worker = async () => {\n    while (nextIndex < values.length) {\n      const index = nextIndex;\n      nextIndex += 1;\n      results[index] = await mapper(values[index]!);\n    }\n  };\n  await Promise.all(\n    Array.from({ length: Math.min(concurrency, values.length) }, () => worker())\n  );\n  return results;\n}\n\nfunction isWithinRoot(root: string, candidate: string): boolean {\n  const relativePath = path.relative(path.resolve(root), candidate);\n  return (\n    relativePath !== '' &&\n    relativePath !== '..' &&\n    !relativePath.startsWith(`..${path.sep}`) &&\n    !path.isAbsolute(relativePath)\n  );\n}\n\n/** Checks physical containment while allowing the project root itself. */\nfunction isWithinOrEqualRoot(root: string, candidate: string): boolean {\n  return (\n    path.resolve(root) === path.resolve(candidate) ||\n    isWithinRoot(root, candidate)\n  );\n}\n\nfunction isRecord(value: unknown): value is Record<string, unknown> {\n  return value !== null && typeof value === 'object' && !Array.isArray(value);\n}\n\nfunction comparePaths(left: string, right: string): number {\n  return left < right ? -1 : left > right ? 1 : 0;\n}\n"],"mappings":"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"}

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

@@ -0,0 +1,21 @@
+import type { JavaScriptPackageManifest } from './manifest.js';
+export type PublicImportEntry = {
+    entry: string;
+    specifier: string;
+};
+export type PublicGTImport = PublicImportEntry & {
+    exportNames: ReadonlySet<string>;
+};
+/**
+ * Returns whether a local package publicly exposes a gt-vue-derived value.
+ *
+ * Merely using gt-vue inside a package does not make every consumer a Vue
+ * application. This check starts at public import entrypoints and follows the
+ * same local ESM provenance graph as source extraction, so only an API that a
+ * consumer can actually import propagates Vue ownership.
+ */
+export declare function packagePubliclyExposesGT(packageDirectory: string, manifest: JavaScriptPackageManifest): boolean;
+/** Resolves every public import entry and retains its GT-derived export names. */
+export declare function readPublicGTImports(packageDirectory: string, manifest: JavaScriptPackageManifest): PublicGTImport[];
+/** Resolves a package's public ESM import entries without executing code. */
+export declare function readPublicImportEntries(packageDirectory: string, manifest: JavaScriptPackageManifest): PublicImportEntry[];