vinext 0.0.33 → 0.0.34

package/dist/index.js

@@ -163,6 +163,92 @@ function extractStaticValue(node) {
 		default: return;
 	}
 }
+function isRecord(value) {
+	return !!value && typeof value === "object" && !Array.isArray(value);
+}
+const TSCONFIG_FILES = ["tsconfig.json", "jsconfig.json"];
+function resolveTsconfigPathCandidate(candidate) {
+	const candidates = candidate.endsWith(".json") ? [candidate] : [
+		candidate,
+		`${candidate}.json`,
+		path.join(candidate, "tsconfig.json")
+	];
+	for (const item of candidates) if (fs.existsSync(item) && fs.statSync(item).isFile()) return item;
+	return null;
+}
+function resolveTsconfigExtends(configPath, specifier) {
+	const fromDir = path.dirname(configPath);
+	if (specifier.startsWith(".") || specifier.startsWith("/") || specifier.startsWith("\\")) return resolveTsconfigPathCandidate(path.resolve(fromDir, specifier));
+	const requireFromConfig = createRequire(configPath);
+	const candidates = [
+		specifier,
+		`${specifier}.json`,
+		path.join(specifier, "tsconfig.json")
+	];
+	for (const item of candidates) try {
+		return requireFromConfig.resolve(item);
+	} catch {}
+	return null;
+}
+function materializeTsconfigPathAliases(pathsConfig, baseUrl, projectRoot) {
+	const aliases = {};
+	for (const [find, rawTargets] of Object.entries(pathsConfig)) {
+		const target = Array.isArray(rawTargets) ? rawTargets.find((value) => typeof value === "string") : typeof rawTargets === "string" ? rawTargets : null;
+		if (!target) continue;
+		if (find.includes("*") || target.includes("*")) {
+			if (!find.endsWith("/*") || !target.endsWith("/*")) continue;
+			if (find.indexOf("*") !== find.length - 1 || target.indexOf("*") !== target.length - 1) continue;
+			const aliasKey = find.slice(0, -2);
+			const targetDir = target.slice(0, -2);
+			if (!aliasKey || !targetDir) continue;
+			aliases[aliasKey] = toViteAliasReplacement(path.resolve(baseUrl, targetDir), projectRoot);
+			continue;
+		}
+		aliases[find] = toViteAliasReplacement(path.resolve(baseUrl, target), projectRoot);
+	}
+	return aliases;
+}
+function toViteAliasReplacement(absolutePath, projectRoot) {
+	const normalizedPath = absolutePath.replace(/\\/g, "/");
+	const rootCandidates = new Set([projectRoot]);
+	const realRoot = tryRealpathSync(projectRoot);
+	if (realRoot) rootCandidates.add(realRoot);
+	const pathCandidates = new Set([absolutePath]);
+	const realPath = tryRealpathSync(absolutePath);
+	if (realPath) pathCandidates.add(realPath);
+	for (const rootCandidate of rootCandidates) for (const pathCandidate of pathCandidates) {
+		if (pathCandidate === rootCandidate) return "/";
+		const relativeId = relativeWithinRoot(rootCandidate, pathCandidate);
+		if (relativeId) return "/" + relativeId;
+	}
+	return normalizedPath;
+}
+function loadTsconfigPathAliases(configPath, projectRoot, seen = /* @__PURE__ */ new Set()) {
+	const normalizedPath = tryRealpathSync(configPath) ?? configPath;
+	if (seen.has(normalizedPath)) return {};
+	seen.add(normalizedPath);
+	let parsed = null;
+	try {
+		parsed = parseStaticObjectLiteral(fs.readFileSync(normalizedPath, "utf-8"));
+	} catch {
+		return {};
+	}
+	if (!parsed) return {};
+	let aliases = {};
+	if (typeof parsed.extends === "string") {
+		const extendedPath = resolveTsconfigExtends(normalizedPath, parsed.extends);
+		if (extendedPath) aliases = loadTsconfigPathAliases(extendedPath, projectRoot, seen);
+	}
+	const compilerOptions = isRecord(parsed.compilerOptions) ? parsed.compilerOptions : null;
+	const pathsConfig = compilerOptions && isRecord(compilerOptions.paths) ? compilerOptions.paths : null;
+	if (!pathsConfig) return aliases;
+	const baseUrl = compilerOptions && typeof compilerOptions.baseUrl === "string" ? compilerOptions.baseUrl : ".";
+	const resolvedBaseUrl = path.resolve(path.dirname(normalizedPath), baseUrl);
+	return {
+		...aliases,
+		...materializeTsconfigPathAliases(pathsConfig, resolvedBaseUrl, projectRoot)
+	};
+}
 /**
 * Detect Vite major version at runtime by resolving from cwd.
 * The plugin may be installed in a workspace root with Vite 7 but used
@@ -212,6 +298,19 @@ const POSTCSS_CONFIG_FILES = [
 * parallel) all await the same in-flight scan rather than each starting their own.
 */
 const _postcssCache = /* @__PURE__ */ new Map();
+const _tsconfigAliasCache = /* @__PURE__ */ new Map();
+function resolveTsconfigAliases(projectRoot) {
+	if (_tsconfigAliasCache.has(projectRoot)) return _tsconfigAliasCache.get(projectRoot);
+	let aliases = {};
+	for (const name of TSCONFIG_FILES) {
+		const candidate = path.join(projectRoot, name);
+		if (!fs.existsSync(candidate)) continue;
+		aliases = loadTsconfigPathAliases(candidate, projectRoot);
+		break;
+	}
+	_tsconfigAliasCache.set(projectRoot, aliases);
+	return aliases;
+}
 /**
 * Resolve PostCSS string plugin names in a project's PostCSS config.
 *
@@ -279,9 +378,18 @@ const VIRTUAL_APP_SSR_ENTRY = "virtual:vinext-app-ssr-entry";
 const RESOLVED_APP_SSR_ENTRY = "\0" + VIRTUAL_APP_SSR_ENTRY;
 const VIRTUAL_APP_BROWSER_ENTRY = "virtual:vinext-app-browser-entry";
 const RESOLVED_APP_BROWSER_ENTRY = "\0" + VIRTUAL_APP_BROWSER_ENTRY;
+const VIRTUAL_GOOGLE_FONTS = "virtual:vinext-google-fonts";
+const RESOLVED_VIRTUAL_GOOGLE_FONTS = "\0" + VIRTUAL_GOOGLE_FONTS;
 /** Image file extensions handled by the vinext:image-imports plugin.
 *  Shared between the Rolldown hook filter and the transform handler regex. */
 const IMAGE_EXTS = "png|jpe?g|gif|webp|avif|svg|ico|bmp|tiff?";
+const GOOGLE_FONT_UTILITY_EXPORTS = new Set([
+	"buildGoogleFontsUrl",
+	"getSSRFontLinks",
+	"getSSRFontStyles",
+	"getSSRFontPreloads",
+	"createFontLoader"
+]);
 /**
 * Extract the npm package name from a module ID (file path).
 * Returns null if not in node_modules.
@@ -301,6 +409,102 @@ function getPackageName(id) {
 }
 /** Absolute path to vinext's shims directory, used by clientManualChunks. */
 const _shimsDir = path.resolve(__dirname, "shims") + "/";
+const _fontGoogleShimPath = resolveShimModulePath(_shimsDir, "font-google");
+function parseGoogleFontNamedSpecifiers(specifiersStr, forceType = false) {
+	return specifiersStr.split(",").map((spec) => spec.trim()).filter(Boolean).map((raw) => {
+		const isType = forceType || raw.startsWith("type ");
+		const asParts = (isType ? raw.replace(/^type\s+/, "") : raw).split(/\s+as\s+/);
+		return {
+			imported: asParts[0]?.trim() ?? "",
+			local: (asParts[1] || asParts[0] || "").trim(),
+			isType,
+			raw
+		};
+	}).filter((spec) => spec.imported.length > 0 && spec.local.length > 0);
+}
+function parseGoogleFontImportClause(clause) {
+	const trimmed = clause.trim();
+	if (trimmed.startsWith("type ")) {
+		const braceStart = trimmed.indexOf("{");
+		const braceEnd = trimmed.lastIndexOf("}");
+		if (braceStart === -1 || braceEnd === -1) return {
+			defaultLocal: null,
+			namespaceLocal: null,
+			named: []
+		};
+		return {
+			defaultLocal: null,
+			namespaceLocal: null,
+			named: parseGoogleFontNamedSpecifiers(trimmed.slice(braceStart + 1, braceEnd), true)
+		};
+	}
+	const braceStart = trimmed.indexOf("{");
+	const braceEnd = trimmed.lastIndexOf("}");
+	if (braceStart !== -1 && braceEnd !== -1) return {
+		defaultLocal: trimmed.slice(0, braceStart).trim().replace(/,\s*$/, "").trim() || null,
+		namespaceLocal: null,
+		named: parseGoogleFontNamedSpecifiers(trimmed.slice(braceStart + 1, braceEnd))
+	};
+	const commaIndex = trimmed.indexOf(",");
+	if (commaIndex !== -1) {
+		const defaultLocal = trimmed.slice(0, commaIndex).trim() || null;
+		const rest = trimmed.slice(commaIndex + 1).trim();
+		if (rest.startsWith("* as ")) return {
+			defaultLocal,
+			namespaceLocal: rest.slice(5).trim() || null,
+			named: []
+		};
+	}
+	if (trimmed.startsWith("* as ")) return {
+		defaultLocal: null,
+		namespaceLocal: trimmed.slice(5).trim() || null,
+		named: []
+	};
+	return {
+		defaultLocal: trimmed || null,
+		namespaceLocal: null,
+		named: []
+	};
+}
+function encodeGoogleFontsVirtualId(payload) {
+	const params = new URLSearchParams();
+	if (payload.hasDefault) params.set("default", "1");
+	if (payload.fonts.length > 0) params.set("fonts", payload.fonts.join(","));
+	if (payload.utilities.length > 0) params.set("utilities", payload.utilities.join(","));
+	return `${VIRTUAL_GOOGLE_FONTS}?${params.toString()}`;
+}
+function parseGoogleFontsVirtualId(id) {
+	const cleanId = id.startsWith("\0") ? id.slice(1) : id;
+	if (!cleanId.startsWith(VIRTUAL_GOOGLE_FONTS)) return null;
+	const queryIndex = cleanId.indexOf("?");
+	const params = new URLSearchParams(queryIndex === -1 ? "" : cleanId.slice(queryIndex + 1));
+	return {
+		hasDefault: params.get("default") === "1",
+		fonts: params.get("fonts")?.split(",").map((value) => value.trim()).filter(Boolean) ?? [],
+		utilities: params.get("utilities")?.split(",").map((value) => value.trim()).filter(Boolean) ?? []
+	};
+}
+function generateGoogleFontsVirtualModule(id) {
+	const payload = parseGoogleFontsVirtualId(id);
+	if (!payload) return null;
+	const utilities = Array.from(new Set(payload.utilities));
+	const fonts = Array.from(new Set(payload.fonts));
+	const lines = [];
+	lines.push(`import { createFontLoader } from ${JSON.stringify(_fontGoogleShimPath)};`);
+	const reExports = [];
+	if (payload.hasDefault) reExports.push("default");
+	reExports.push(...utilities);
+	if (reExports.length > 0) lines.push(`export { ${reExports.join(", ")} } from ${JSON.stringify(_fontGoogleShimPath)};`);
+	for (const fontName of fonts) {
+		const family = fontName.replace(/_/g, " ");
+		lines.push(`export const ${fontName} = /*#__PURE__*/ createFontLoader(${JSON.stringify(family)});`);
+	}
+	lines.push("");
+	return lines.join("\n");
+}
+function propertyNameToGoogleFontFamily(prop) {
+	return prop.replace(/_/g, " ").replace(/([a-z])([A-Z])/g, "$1 $2");
+}
 /**
 * manualChunks function for client builds.
 *
@@ -743,6 +947,7 @@ function vinext(options = {}) {
 				root = config.root ?? process.cwd();
 				const userResolve = config.resolve;
 				const shouldEnableNativeTsconfigPaths = viteMajorVersion >= 8 && userResolve?.tsconfigPaths === void 0;
+				const tsconfigPathAliases = resolveTsconfigAliases(root);
 				const mode = env?.mode ?? "development";
 				const dotenvVars = loadEnv(mode, config.envDir ?? root, "");
 				for (const [key, value] of Object.entries(dotenvVars)) if (process.env[key] === void 0) process.env[key] = value;
@@ -916,6 +1121,7 @@ function vinext(options = {}) {
 					} },
 					resolve: {
 						alias: {
+							...tsconfigPathAliases,
 							...nextConfig.aliases,
 							...nextShimMap
 						},
@@ -1059,9 +1265,14 @@ function vinext(options = {}) {
 					if (cleanId === VIRTUAL_RSC_ENTRY) return RESOLVED_RSC_ENTRY;
 					if (cleanId === VIRTUAL_APP_SSR_ENTRY) return RESOLVED_APP_SSR_ENTRY;
 					if (cleanId === VIRTUAL_APP_BROWSER_ENTRY) return RESOLVED_APP_BROWSER_ENTRY;
+					if (cleanId.startsWith(VIRTUAL_GOOGLE_FONTS + "?")) return RESOLVED_VIRTUAL_GOOGLE_FONTS + cleanId.slice(27);
 					if (cleanId.endsWith("/" + VIRTUAL_RSC_ENTRY) || cleanId.endsWith("\\" + VIRTUAL_RSC_ENTRY)) return RESOLVED_RSC_ENTRY;
 					if (cleanId.endsWith("/" + VIRTUAL_APP_SSR_ENTRY) || cleanId.endsWith("\\" + VIRTUAL_APP_SSR_ENTRY)) return RESOLVED_APP_SSR_ENTRY;
 					if (cleanId.endsWith("/" + VIRTUAL_APP_BROWSER_ENTRY) || cleanId.endsWith("\\" + VIRTUAL_APP_BROWSER_ENTRY)) return RESOLVED_APP_BROWSER_ENTRY;
+					if (cleanId.includes("/" + VIRTUAL_GOOGLE_FONTS + "?") || cleanId.includes("\\" + VIRTUAL_GOOGLE_FONTS + "?")) {
+						const queryIndex = cleanId.indexOf(VIRTUAL_GOOGLE_FONTS + "?");
+						return RESOLVED_VIRTUAL_GOOGLE_FONTS + cleanId.slice(queryIndex + 27);
+					}
 				}
 			},
 			async load(id) {
@@ -1084,6 +1295,7 @@ function vinext(options = {}) {
 				}
 				if (id === RESOLVED_APP_SSR_ENTRY && hasAppDir) return generateSsrEntry(hasPagesDir);
 				if (id === RESOLVED_APP_BROWSER_ENTRY && hasAppDir) return generateBrowserEntry();
+				if (id.startsWith(RESOLVED_VIRTUAL_GOOGLE_FONTS + "?")) return generateGoogleFontsVirtualModule(id);
 			}
 		},
 		asyncHooksStubPlugin,
@@ -1571,38 +1783,82 @@ function vinext(options = {}) {
 			},
 			transform: {
 				filter: {
-					id: {
-						include: /\.(tsx?|jsx?|mjs)$/,
-						exclude: /node_modules/
-					},
+					id: { include: /\.(tsx?|jsx?|mjs)$/ },
 					code: "next/font/google"
 				},
 				async handler(code, id) {
-					if (!this._isBuild) return null;
-					if (id.includes("node_modules")) return null;
 					if (id.startsWith("\0")) return null;
 					if (!id.match(/\.(tsx?|jsx?|mjs)$/)) return null;
 					if (!code.includes("next/font/google")) return null;
-					const fontCallRe = /\b([A-Z][A-Za-z]*(?:_[A-Z][A-Za-z]*)*)\s*\(\s*(\{[^}]*\})\s*\)/g;
-					const importMatch = code.match(/import\s*\{([^}]+)\}\s*from\s*['"]next\/font\/google['"]/);
-					if (!importMatch) return null;
-					const importedNames = new Set(importMatch[1].split(",").map((s) => s.trim()).filter(Boolean));
+					if (id.startsWith(_shimsDir)) return null;
 					const s = new MagicString(code);
 					let hasChanges = false;
+					let proxyImportCounter = 0;
+					const overwrittenRanges = [];
+					const fontLocals = /* @__PURE__ */ new Map();
+					const proxyObjectLocals = /* @__PURE__ */ new Set();
+					const importRe = /^[ \t]*import\s+([^;]+?)\s+from\s*(["'])next\/font\/google\2\s*;?/gm;
+					let importMatch;
+					while ((importMatch = importRe.exec(code)) !== null) {
+						const [fullMatch, clause] = importMatch;
+						const matchStart = importMatch.index;
+						const matchEnd = matchStart + fullMatch.length;
+						const parsed = parseGoogleFontImportClause(clause);
+						const utilityImports = parsed.named.filter((spec) => !spec.isType && GOOGLE_FONT_UTILITY_EXPORTS.has(spec.imported));
+						const fontImports = parsed.named.filter((spec) => !spec.isType && !GOOGLE_FONT_UTILITY_EXPORTS.has(spec.imported));
+						if (parsed.defaultLocal) proxyObjectLocals.add(parsed.defaultLocal);
+						for (const fontImport of fontImports) fontLocals.set(fontImport.local, fontImport.imported);
+						if (fontImports.length > 0) {
+							const virtualId = encodeGoogleFontsVirtualId({
+								hasDefault: Boolean(parsed.defaultLocal),
+								fonts: Array.from(new Set(fontImports.map((spec) => spec.imported))),
+								utilities: Array.from(new Set(utilityImports.map((spec) => spec.imported)))
+							});
+							s.overwrite(matchStart, matchEnd, `import ${clause} from ${JSON.stringify(virtualId)};`);
+							overwrittenRanges.push([matchStart, matchEnd]);
+							hasChanges = true;
+							continue;
+						}
+						if (parsed.namespaceLocal) {
+							const proxyImportName = `__vinext_google_fonts_proxy_${proxyImportCounter++}`;
+							const replacementLines = [`import ${proxyImportName} from ${JSON.stringify(_fontGoogleShimPath)};`];
+							if (parsed.defaultLocal) replacementLines.push(`var ${parsed.defaultLocal} = ${proxyImportName};`);
+							replacementLines.push(`var ${parsed.namespaceLocal} = ${proxyImportName};`);
+							s.overwrite(matchStart, matchEnd, replacementLines.join("\n"));
+							overwrittenRanges.push([matchStart, matchEnd]);
+							proxyObjectLocals.add(parsed.namespaceLocal);
+							hasChanges = true;
+						}
+					}
+					const exportRe = /^[ \t]*export\s*\{([^}]+)\}\s*from\s*(["'])next\/font\/google\2\s*;?/gm;
+					let exportMatch;
+					while ((exportMatch = exportRe.exec(code)) !== null) {
+						const [fullMatch, specifiers] = exportMatch;
+						const matchStart = exportMatch.index;
+						const matchEnd = matchStart + fullMatch.length;
+						const namedExports = parseGoogleFontNamedSpecifiers(specifiers);
+						const utilityExports = namedExports.filter((spec) => !spec.isType && GOOGLE_FONT_UTILITY_EXPORTS.has(spec.imported));
+						const fontExports = namedExports.filter((spec) => !spec.isType && !GOOGLE_FONT_UTILITY_EXPORTS.has(spec.imported));
+						if (fontExports.length === 0) continue;
+						const virtualId = encodeGoogleFontsVirtualId({
+							hasDefault: false,
+							fonts: Array.from(new Set(fontExports.map((spec) => spec.imported))),
+							utilities: Array.from(new Set(utilityExports.map((spec) => spec.imported)))
+						});
+						s.overwrite(matchStart, matchEnd, `export { ${specifiers.trim()} } from ${JSON.stringify(virtualId)};`);
+						overwrittenRanges.push([matchStart, matchEnd]);
+						hasChanges = true;
+					}
 					const cacheDir = this._cacheDir;
 					const fontCache = this._fontCache;
-					let match;
-					while ((match = fontCallRe.exec(code)) !== null) {
-						const [fullMatch, fontName, optionsStr] = match;
-						if (!importedNames.has(fontName)) continue;
-						const family = fontName.replace(/_/g, " ").replace(/([a-z])([A-Z])/g, "$1 $2");
+					async function injectSelfHostedCss(callStart, callEnd, optionsStr, family, calleeSource) {
 						let options = {};
 						try {
 							const parsed = parseStaticObjectLiteral(optionsStr);
-							if (!parsed) continue;
+							if (!parsed) return;
 							options = parsed;
 						} catch {
-							continue;
+							return;
 						}
 						const weights = options.weight ? Array.isArray(options.weight) ? options.weight : [options.weight] : [];
 						const styles = options.style ? Array.isArray(options.style) ? options.style : [options.style] : [];
@@ -1626,16 +1882,37 @@ function vinext(options = {}) {
 							localCSS = await fetchAndCacheFont(cssUrl, family, cacheDir);
 							fontCache.set(cssUrl, localCSS);
 						} catch {
-							continue;
+							return;
 						}
-						const matchStart = match.index;
-						const matchEnd = matchStart + fullMatch.length;
 						const escapedCSS = JSON.stringify(localCSS);
 						const closingBrace = optionsStr.lastIndexOf("}");
-						const replacement = `${fontName}(${optionsStr.slice(0, closingBrace) + (optionsStr.slice(0, closingBrace).trim().endsWith("{") ? "" : ", ") + `_selfHostedCSS: ${escapedCSS}` + optionsStr.slice(closingBrace)})`;
-						s.overwrite(matchStart, matchEnd, replacement);
+						const replacement = `${calleeSource}(${optionsStr.slice(0, closingBrace) + (optionsStr.slice(0, closingBrace).trim().endsWith("{") ? "" : ", ") + `_selfHostedCSS: ${escapedCSS}` + optionsStr.slice(closingBrace)})`;
+						s.overwrite(callStart, callEnd, replacement);
 						hasChanges = true;
 					}
+					if (this._isBuild) {
+						const namedCallRe = /\b([A-Za-z_$][A-Za-z0-9_$]*)\s*\(\s*(\{[^}]*\})\s*\)/g;
+						let namedCallMatch;
+						while ((namedCallMatch = namedCallRe.exec(code)) !== null) {
+							const [fullMatch, localName, optionsStr] = namedCallMatch;
+							const importedName = fontLocals.get(localName);
+							if (!importedName) continue;
+							const callStart = namedCallMatch.index;
+							const callEnd = callStart + fullMatch.length;
+							if (overwrittenRanges.some(([start, end]) => callStart < end && callEnd > start)) continue;
+							await injectSelfHostedCss(callStart, callEnd, optionsStr, importedName.replace(/_/g, " "), localName);
+						}
+						const memberCallRe = /\b([A-Za-z_$][A-Za-z0-9_$]*)\.([A-Za-z_$][A-Za-z0-9_$]*)\s*\(\s*(\{[^}]*\})\s*\)/g;
+						let memberCallMatch;
+						while ((memberCallMatch = memberCallRe.exec(code)) !== null) {
+							const [fullMatch, objectName, propName, optionsStr] = memberCallMatch;
+							if (!proxyObjectLocals.has(objectName)) continue;
+							const callStart = memberCallMatch.index;
+							const callEnd = callStart + fullMatch.length;
+							if (overwrittenRanges.some(([start, end]) => callStart < end && callEnd > start)) continue;
+							await injectSelfHostedCss(callStart, callEnd, optionsStr, propertyNameToGoogleFontFamily(propName), `${objectName}.${propName}`);
+						}
+					}
 					if (!hasChanges) return null;
 					return {
 						code: s.toString(),