vinext 1.2.1 → 1.3.1

package/dist/build/client-reference-groups.js

@@ -0,0 +1,572 @@
+import path from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
+import { parseModuleRecord } from "../plugins/ast-utils.js";
+import { actionOwnerRouteEntryIds } from "./action-owner-manifest.js";
+import { createHash } from "node:crypto";
+//#region src/build/client-reference-groups.ts
+/**
+* Client references whose estimated group cost (see
+* {@link measureClientReferenceGroupCosts}) is larger than this many
+* transformed source bytes keep their own lazy chunk instead of joining a route
+* group. Grouping makes every member load with the group, so a heavy component
+* that a route can reach but rarely renders must not be pulled into that
+* route's startup bundle.
+*/
+const CLIENT_REFERENCE_GROUP_MAX_COST_BYTES = 102400;
+const SEGMENT_FILE_ORDER = [
+	"layout",
+	"template",
+	"error",
+	"unauthorized",
+	"forbidden",
+	"not-found",
+	"loading",
+	"default",
+	"page"
+];
+/**
+* Order route files as they render: outer segments first and, within a
+* segment, each file before the ones it wraps. A group evaluates its members in
+* the order the walk reaches them, so this keeps an outer layout's top-level
+* side effects and CSS ahead of its page's, as Next.js evaluates client
+* references in render order.
+*/
+function inRenderOrder(files) {
+	const rank = (file) => {
+		const index = SEGMENT_FILE_ORDER.indexOf(path.basename(file).split(".")[0]);
+		return index === -1 ? SEGMENT_FILE_ORDER.length : index;
+	};
+	return files.map((file) => ({
+		file,
+		depth: path.dirname(file).split("/").length,
+		rank: rank(file)
+	})).sort((a, b) => a.depth - b.depth || a.rank - b.rank).map(({ file }) => file);
+}
+function interceptEntryIds(intercept) {
+	return [
+		intercept.pagePath,
+		...intercept.layoutPaths,
+		...intercept.loadingPaths ?? [],
+		intercept.notFoundPath,
+		intercept.forbiddenPath,
+		intercept.unauthorizedPath,
+		...intercept.notFoundPaths ?? [],
+		...intercept.forbiddenPaths ?? [],
+		...intercept.unauthorizedPaths ?? [],
+		...intercept.errorPaths ?? []
+	].filter((value) => typeof value === "string");
+}
+/**
+* Map each client reference reachable from App Router route files to a
+* signature naming the owners that reach it. A route owns its page, layouts,
+* templates, boundaries and parallel slots, which render with it. Intercepting
+* routes (which only render on soft navigation), global-error and
+* global-not-found render on their own, so each is owned by its file, named by
+* its path relative to `root`. References with the same signature are needed
+* together, mirroring Next.js' per-route client entries. The map is in the
+* order a depth-first walk in import order first reaches each reference from
+* the route files in render order, which follows ES module evaluation order.
+*
+* References reachable from no route file (for example vinext's internal
+* runtime references) are omitted and keep their own lazy chunk. So are
+* references that route code reaches through a dynamic import (`next/dynamic`,
+* `React.lazy`), directly or through the dynamically imported module's graph.
+*/
+function collectClientReferenceRouteSignatures(options) {
+	const canonicalize = options.canonicalizeModuleId ?? ((id) => id);
+	const moduleInfoCache = /* @__PURE__ */ new Map();
+	const getModuleInfo = (id) => {
+		let info = moduleInfoCache.get(id);
+		if (info === void 0) {
+			info = options.getModuleInfo(id);
+			moduleInfoCache.set(id, info);
+		}
+		return info;
+	};
+	const lazyReferences = /* @__PURE__ */ new Set();
+	const lazyVisited = /* @__PURE__ */ new Set();
+	const markLazy = (root) => {
+		const stack = [root];
+		while (stack.length > 0) {
+			const id = stack.pop();
+			if (lazyVisited.has(id)) continue;
+			lazyVisited.add(id);
+			if (options.clientReferenceIds.has(id)) {
+				lazyReferences.add(id);
+				continue;
+			}
+			const info = getModuleInfo(id);
+			if (info) stack.push(...info.importedIds, ...info.dynamicallyImportedIds);
+		}
+	};
+	const referencesByFile = /* @__PURE__ */ new Map();
+	const referencesReachedFrom = (file) => {
+		let references = referencesByFile.get(file);
+		if (references) return references;
+		references = /* @__PURE__ */ new Set();
+		const visited = /* @__PURE__ */ new Set();
+		const stack = [canonicalize(file)];
+		while (stack.length > 0) {
+			const id = stack.pop();
+			if (visited.has(id)) continue;
+			visited.add(id);
+			if (options.clientReferenceIds.has(id)) {
+				references.add(id);
+				continue;
+			}
+			const info = getModuleInfo(id);
+			if (!info) continue;
+			for (const importedId of info.dynamicallyImportedIds) markLazy(importedId);
+			for (let index = info.importedIds.length - 1; index >= 0; index--) stack.push(info.importedIds[index]);
+		}
+		referencesByFile.set(file, references);
+		return references;
+	};
+	const owners = /* @__PURE__ */ new Map();
+	const addOwner = (owner, files) => {
+		for (const file of files) for (const reference of referencesReachedFrom(file)) {
+			let referenceOwners = owners.get(reference);
+			if (!referenceOwners) {
+				referenceOwners = /* @__PURE__ */ new Set();
+				owners.set(reference, referenceOwners);
+			}
+			referenceOwners.add(owner);
+		}
+	};
+	const fileOwner = (file) => path.relative(options.root, file);
+	for (const route of options.routes) {
+		addOwner(route.pattern, inRenderOrder(actionOwnerRouteEntryIds({
+			...route,
+			parallelSlots: route.parallelSlots.map((slot) => ({
+				...slot,
+				interceptingRoutes: []
+			})),
+			siblingIntercepts: []
+		})));
+		const intercepts = [...route.parallelSlots.flatMap((slot) => slot.interceptingRoutes), ...route.siblingIntercepts];
+		for (const intercept of intercepts) addOwner(fileOwner(intercept.pagePath), inRenderOrder(interceptEntryIds(intercept)));
+	}
+	for (const file of options.sharedRoots ?? []) addOwner(fileOwner(file), [file]);
+	const signatures = /* @__PURE__ */ new Map();
+	for (const [reference, referenceOwners] of owners) {
+		if (lazyReferences.has(reference)) continue;
+		signatures.set(reference, [...referenceOwners].sort().join("\n"));
+	}
+	return signatures;
+}
+/**
+* Plan which client references SSR loads before rendering each route. A route
+* preloads every client reference its page, layouts, templates, boundaries and
+* parallel slots reach, statically or through dynamic imports (a
+* `next/dynamic` component renders on the server), plus the `always` set.
+* Intercepting routes only render on soft navigation, which SSR never
+* renders, so they add to no set. `entryIds` are the RSC graph's entries:
+* walking them up to route files finds what renders outside any route.
+*/
+function collectClientReferencePreloadPlan(options) {
+	const canonicalize = options.canonicalizeModuleId ?? ((id) => id);
+	const moduleInfoCache = /* @__PURE__ */ new Map();
+	const getModuleInfo = (id) => {
+		let info = moduleInfoCache.get(id);
+		if (info === void 0) {
+			info = options.getModuleInfo(id);
+			moduleInfoCache.set(id, info);
+		}
+		return info;
+	};
+	const reached = /* @__PURE__ */ new Set();
+	const referencesReachedFrom = (roots, stopAt) => {
+		const references = [];
+		const visited = /* @__PURE__ */ new Set();
+		const stack = roots.map(canonicalize).reverse();
+		while (stack.length > 0) {
+			const id = stack.pop();
+			if (visited.has(id)) continue;
+			visited.add(id);
+			if (stopAt?.has(id)) continue;
+			if (options.clientReferenceIds.has(id)) {
+				references.push(id);
+				reached.add(id);
+				continue;
+			}
+			const info = getModuleInfo(id);
+			if (!info) continue;
+			const imports = [...info.importedIds, ...info.dynamicallyImportedIds];
+			for (let index = imports.length - 1; index >= 0; index--) stack.push(imports[index]);
+		}
+		return references;
+	};
+	const files = [];
+	const fileIndices = /* @__PURE__ */ new Map();
+	const fileIndex = (file) => {
+		const id = canonicalize(file);
+		let index = fileIndices.get(id);
+		if (index === void 0) {
+			index = files.length;
+			fileIndices.set(id, index);
+			files.push(referencesReachedFrom([id]));
+		}
+		return index;
+	};
+	const routes = /* @__PURE__ */ new Map();
+	const interceptFiles = [];
+	for (const route of options.routes) {
+		const indices = inRenderOrder(actionOwnerRouteEntryIds({
+			...route,
+			parallelSlots: route.parallelSlots.map((slot) => ({
+				...slot,
+				interceptingRoutes: []
+			})),
+			siblingIntercepts: []
+		})).map(fileIndex);
+		routes.set(route.pattern, [.../* @__PURE__ */ new Set([...routes.get(route.pattern) ?? [], ...indices])]);
+		for (const intercept of [...route.parallelSlots.flatMap((slot) => slot.interceptingRoutes), ...route.siblingIntercepts]) interceptFiles.push(...interceptEntryIds(intercept));
+	}
+	const routeless = [...new Set((options.routelessFiles ?? []).map(fileIndex))];
+	referencesReachedFrom(interceptFiles);
+	const alwaysRoots = options.alwaysRoots ?? [];
+	const stopAt = /* @__PURE__ */ new Set([...fileIndices.keys(), ...[...interceptFiles, ...alwaysRoots].map(canonicalize)]);
+	const always = /* @__PURE__ */ new Set([...referencesReachedFrom(options.entryIds, stopAt), ...referencesReachedFrom(alwaysRoots)]);
+	for (const id of options.clientReferenceIds) if (!reached.has(id)) always.add(id);
+	const dynamicallyReached = /* @__PURE__ */ new Set();
+	const visited = /* @__PURE__ */ new Set();
+	const pending = [...options.entryIds.map(canonicalize), ...stopAt].map((id) => [
+		id,
+		false,
+		true
+	]);
+	while (pending.length > 0) {
+		const [id, dynamic, root] = pending.pop();
+		if (!root && stopAt.has(id)) continue;
+		const key = dynamic ? `dynamic:${id}` : id;
+		if (visited.has(key)) continue;
+		visited.add(key);
+		if (options.clientReferenceIds.has(id)) {
+			if (dynamic) dynamicallyReached.add(id);
+			continue;
+		}
+		const info = getModuleInfo(id);
+		if (!info) continue;
+		for (const imported of info.importedIds) pending.push([
+			imported,
+			dynamic,
+			false
+		]);
+		for (const imported of info.dynamicallyImportedIds) pending.push([
+			imported,
+			true,
+			false
+		]);
+	}
+	const staticOnly = [...new Set(files.flat())].filter((id) => !always.has(id) && !dynamicallyReached.has(id));
+	return {
+		always: [...always],
+		files,
+		routes,
+		routeless,
+		staticOnly
+	};
+}
+function importedName(kind, name) {
+	if (kind === "Name") return name;
+	return kind === "Default" ? "default" : "*";
+}
+/**
+* Read a module's static imports and re-exports for
+* {@link measureClientReferenceGroupCosts}. Returns undefined when the code does
+* not parse or a specifier does not resolve to one of `importedIds`.
+*/
+async function readClientModuleBindings(options) {
+	const { code } = options;
+	const record = parseModuleRecord(code, "js");
+	if (!record) return void 0;
+	const specifiers = /* @__PURE__ */ new Set([...record.staticImports.map((statement) => statement.moduleRequest.value), ...record.staticExports.flatMap((statement) => statement.entries.flatMap((entry) => entry.moduleRequest ? [entry.moduleRequest.value] : []))]);
+	const importedIds = new Set(options.importedIds);
+	const ids = /* @__PURE__ */ new Map();
+	for (const [specifier, id] of await Promise.all([...specifiers].map(async (specifier) => [specifier, await options.resolve(specifier)]))) {
+		if (id === null || !importedIds.has(id)) return void 0;
+		ids.set(specifier, id);
+	}
+	const isIndirect = (statement) => code.startsWith("import", statement.start);
+	const exportList = /export\s*[{*]/y;
+	const ranges = [
+		...record.staticImports,
+		...record.staticExports.filter((statement) => {
+			exportList.lastIndex = statement.start;
+			return exportList.test(code);
+		}),
+		...record.staticExports.filter(isIndirect).flatMap((statement) => statement.entries)
+	].sort((a, b) => a.start - b.start);
+	let body = "";
+	let offset = 0;
+	for (const range of ranges) {
+		if (range.start > offset) body += code.slice(offset, range.start);
+		offset = Math.max(offset, range.end);
+	}
+	body += code.slice(offset);
+	const reexports = [];
+	const localExports = /* @__PURE__ */ new Map();
+	const addLocalExport = (key, exportName) => localExports.set(key, [...localExports.get(key) ?? [], exportName]);
+	for (const statement of record.staticExports) for (const entry of statement.entries) {
+		const exportName = importedName(entry.exportName.kind, entry.exportName.name);
+		const importName = importedName(entry.importName.kind, entry.importName.name);
+		if (entry.moduleRequest && isIndirect(statement)) addLocalExport(`\0${entry.importName.start}`, exportName);
+		else if (entry.moduleRequest) reexports.push({
+			id: ids.get(entry.moduleRequest.value),
+			exportName,
+			importName
+		});
+		else if (entry.localName.name !== null) addLocalExport(entry.localName.name, exportName);
+	}
+	const imports = [];
+	for (const statement of record.staticImports) {
+		const id = ids.get(statement.moduleRequest.value);
+		imports.push({
+			id,
+			names: /* @__PURE__ */ new Set()
+		});
+		for (const entry of statement.entries) {
+			if (entry.isType) continue;
+			const name = importedName(entry.importName.kind, entry.importName.name);
+			const local = entry.localName.value;
+			const exportNames = [...localExports.get(local) ?? [], ...entry.importName.start !== null && localExports.get(`\0${entry.importName.start}`) || []];
+			if (exportNames.length > 0 && !new RegExp(`(?<![\\w$])${local.replaceAll("$", "\\$")}(?![\\w$])`).test(body)) for (const exportName of exportNames) reexports.push({
+				id,
+				exportName,
+				importName: name
+			});
+			else imports.push({
+				id,
+				names: name === "*" ? "*" : /* @__PURE__ */ new Set([name])
+			});
+		}
+	}
+	const covered = new Set(ids.values());
+	for (const id of options.importedIds) if (!covered.has(id)) imports.push({
+		id,
+		names: "*"
+	});
+	return {
+		bytes: Buffer.byteLength(body, "utf8"),
+		imports,
+		reexports
+	};
+}
+/**
+* Estimate, in transformed source bytes, how much code each client reference
+* would add to a route group's chunk: the modules only it uses, plus the cost
+* of every client reference it statically imports (grouping a reference pulls
+* those along). Modules shared with other client references are not charged
+* to any one of them, so shared libraries do not block grouping. With
+* {@link readClientModuleBindings}, a side-effect-free module only charges the
+* re-exports that are imported from it, so a reference that imports one icon
+* from a barrel is not charged for the whole library.
+*
+* `references` maps each client reference id to its module id in the client
+* graph. `isSideEffectFree` reports a module's package `sideEffects` flag as
+* the bundler resolved it. Traversal stops at modules for which `isExcluded`
+* returns true (CSS, always-loaded framework chunks, virtual modules that must
+* not be loaded re-entrantly). A reference whose import graph cannot be fully
+* loaded is reported as `null` so callers keep it out of groups.
+*/
+async function measureClientReferenceGroupCosts(options) {
+	const loaded = /* @__PURE__ */ new Map();
+	const load = (id) => {
+		let module = loaded.get(id);
+		if (!module) {
+			module = options.loadModule(id).catch(() => null);
+			loaded.set(id, module);
+		}
+		return module;
+	};
+	const referenceByModuleId = /* @__PURE__ */ new Map();
+	for (const [referenceId, moduleId] of options.references) referenceByModuleId.set(moduleId, referenceId);
+	const reexportIndexes = /* @__PURE__ */ new Map();
+	const indexReexports = (id, bindings) => {
+		let index = reexportIndexes.get(id);
+		if (index) return index;
+		index = {
+			byName: /* @__PURE__ */ new Map(),
+			stars: [],
+			sideEffectTargets: /* @__PURE__ */ new Set()
+		};
+		for (const edge of bindings.reexports) {
+			if (edge.exportName === "*") {
+				index.stars.push(edge);
+				continue;
+			}
+			const edges = index.byName.get(edge.exportName);
+			if (edges) edges.push(edge);
+			else index.byName.set(edge.exportName, [edge]);
+			if (!options.isSideEffectFree(edge.id)) index.sideEffectTargets.add(edge.id);
+		}
+		reexportIndexes.set(id, index);
+		return index;
+	};
+	const noNames = /* @__PURE__ */ new Set();
+	const importedNames = (edge) => edge.importName === "*" ? "*" : /* @__PURE__ */ new Set([edge.importName]);
+	const slots = /* @__PURE__ */ new Map();
+	const moduleBytes = /* @__PURE__ */ new Map();
+	let frontier = [];
+	const slot = (id, name) => {
+		const key = `${name}\0${id}`;
+		let found = slots.get(key);
+		if (!found) {
+			found = {
+				id,
+				name,
+				children: [],
+				references: [],
+				failed: false
+			};
+			slots.set(key, found);
+			frontier.push(found);
+		}
+		return found;
+	};
+	const link = (from, id, names) => {
+		if (options.isExcluded(id)) return;
+		const reference = referenceByModuleId.get(id);
+		if (reference !== void 0) from.references.push(reference);
+		else if (names === "*" || !options.isSideEffectFree(id)) from.children.push(slot(id, "*"));
+		else for (const name of names) from.children.push(slot(id, name));
+	};
+	const rootSlots = /* @__PURE__ */ new Map();
+	for (const [referenceId, rootModuleId] of options.references) rootSlots.set(referenceId, slot(rootModuleId, "*"));
+	while (frontier.length > 0) {
+		const current = frontier;
+		frontier = [];
+		const modules = await Promise.all(current.map((from) => load(from.id)));
+		for (let index = 0; index < modules.length; index++) {
+			const module = modules[index];
+			const from = current[index];
+			if (!module) {
+				from.failed = true;
+				continue;
+			}
+			const { bindings } = module;
+			moduleBytes.set(from.id, bindings?.bytes ?? (module.code ? Buffer.byteLength(module.code, "utf8") : 0));
+			if (!bindings) {
+				for (const importedId of module.importedIds) link(from, importedId, "*");
+				continue;
+			}
+			for (const edge of bindings.imports) link(from, edge.id, edge.names);
+			if (from.name === "*") {
+				for (const edge of bindings.reexports) link(from, edge.id, importedNames(edge));
+				continue;
+			}
+			const reexports = indexReexports(from.id, bindings);
+			for (const edge of reexports.byName.get(from.name) ?? []) link(from, edge.id, importedNames(edge));
+			const starNames = from.name === "default" ? noNames : /* @__PURE__ */ new Set([from.name]);
+			for (const edge of reexports.stars) link(from, edge.id, starNames);
+			for (const target of reexports.sideEffectTargets) link(from, target, noNames);
+		}
+	}
+	const parents = /* @__PURE__ */ new Map();
+	const leads = /* @__PURE__ */ new Set();
+	for (const from of slots.values()) {
+		for (const child of from.children) {
+			let childParents = parents.get(child);
+			if (!childParents) {
+				childParents = [];
+				parents.set(child, childParents);
+			}
+			childParents.push(from);
+		}
+		if (from.references.length > 0 || from.failed) leads.add(from);
+	}
+	for (const lead of leads) for (const parent of parents.get(lead) ?? []) leads.add(parent);
+	const importedReferences = /* @__PURE__ */ new Map();
+	const unloadable = /* @__PURE__ */ new Set();
+	for (const [referenceId, root] of rootSlots) {
+		const imported = /* @__PURE__ */ new Set();
+		importedReferences.set(referenceId, imported);
+		if (!leads.has(root)) continue;
+		const visited = /* @__PURE__ */ new Set([root]);
+		const stack = [root];
+		while (stack.length > 0) {
+			const current = stack.pop();
+			if (current.failed) unloadable.add(referenceId);
+			for (const reference of current.references) if (reference !== referenceId) imported.add(reference);
+			for (const child of current.children) if (leads.has(child) && !visited.has(child)) {
+				visited.add(child);
+				stack.push(child);
+			}
+		}
+	}
+	const slotOwners = /* @__PURE__ */ new Map();
+	const marks = [];
+	for (const [referenceId, root] of rootSlots) if (!unloadable.has(referenceId)) marks.push([root, referenceId]);
+	while (marks.length > 0) {
+		const [marked, owner] = marks.pop();
+		const current = slotOwners.get(marked);
+		const next = current === void 0 || current === owner ? owner : null;
+		if (next === current) continue;
+		slotOwners.set(marked, next);
+		for (const child of marked.children) marks.push([child, next]);
+	}
+	const moduleOwners = /* @__PURE__ */ new Map();
+	for (const [marked, owner] of slotOwners) {
+		const current = moduleOwners.get(marked.id);
+		moduleOwners.set(marked.id, current === void 0 || current === owner ? owner : null);
+	}
+	const exclusiveBytes = /* @__PURE__ */ new Map();
+	for (const [moduleId, owner] of moduleOwners) {
+		if (owner === null) continue;
+		exclusiveBytes.set(owner, (exclusiveBytes.get(owner) ?? 0) + (moduleBytes.get(moduleId) ?? 0));
+	}
+	const costs = /* @__PURE__ */ new Map();
+	for (const referenceId of options.references.keys()) {
+		let cost = 0;
+		const visited = /* @__PURE__ */ new Set();
+		const queue = [referenceId];
+		for (let index = 0; index < queue.length && cost !== null; index++) {
+			const current = queue[index];
+			if (visited.has(current)) continue;
+			visited.add(current);
+			cost = unloadable.has(current) ? null : cost + (exclusiveBytes.get(current) ?? 0);
+			for (const importedReference of importedReferences.get(current) ?? []) queue.push(importedReference);
+		}
+		costs.set(referenceId, cost);
+	}
+	return costs;
+}
+/**
+* Group client references that share a route signature. References without a
+* signature, references whose cost is unknown or above `maxCostBytes`, and
+* signatures with a single member stay ungrouped. Group keys derive from the
+* members' `referenceKeys`, so a group keeps its chunk name when routes change
+* but its members do not.
+*/
+function planClientReferenceGroups(options) {
+	const membersBySignature = /* @__PURE__ */ new Map();
+	for (const [referenceId, signature] of options.signatures) {
+		if (!options.referenceIds.has(referenceId)) continue;
+		const cost = options.costs.get(referenceId);
+		if (cost == null || cost > options.maxCostBytes) continue;
+		let members = membersBySignature.get(signature);
+		if (!members) {
+			members = [];
+			membersBySignature.set(signature, members);
+		}
+		members.push(referenceId);
+	}
+	const groups = [];
+	const usedKeys = /* @__PURE__ */ new Set();
+	for (const signature of [...membersBySignature.keys()].sort()) {
+		const members = membersBySignature.get(signature);
+		if (members.length < 2) continue;
+		const memberKeys = members.map((referenceId) => options.referenceKeys.get(referenceId));
+		const hash = createHash("sha256").update(memberKeys.sort().join("\0")).digest("hex");
+		let length = 10;
+		while (usedKeys.has(hash.slice(0, length))) length++;
+		const key = hash.slice(0, length);
+		usedKeys.add(key);
+		groups.push({
+			key,
+			referenceIds: members
+		});
+	}
+	return groups;
+}
+//#endregion
+export { CLIENT_REFERENCE_GROUP_MAX_COST_BYTES, collectClientReferencePreloadPlan, collectClientReferenceRouteSignatures, measureClientReferenceGroupCosts, planClientReferenceGroups, readClientModuleBindings };

package/dist/build/css-url-assets.d.ts

@@ -26,4 +26,5 @@ export declare function rebaseCssUrlAssetReferences(code: string, sourceDirector
  * code only has the leaked marker stripped — no sibling files are emitted.
  */
 export declare function restoreDedupedCssAssetReferences(bundle: CssUrlAssetBundle, emitRestoredAsset: EmitRestoredCssUrlAsset): void;
-//#endregion
+//#endregion
+export {};

package/dist/build/google-fonts/fallback-metrics.d.ts

@@ -8,4 +8,5 @@ type AdjustFontFallback = {
 };
 export declare function getFallbackFontOverrideMetrics(fontFamily: string): AdjustFontFallback | undefined;
 export declare function buildFallbackFontFace(family: string, metrics: AdjustFontFallback): string;
-//#endregion
+//#endregion
+export {};

package/dist/build/google-fonts/find-font-files-in-css.d.ts

@@ -11,5 +11,6 @@
 export declare function findFontFilesInCss(css: string, subsetsToPreload?: string[]): {
   googleFontFileUrl: string;
   preloadFontFile: boolean;
+  ext: string;
 }[];
 //#endregion

package/dist/build/google-fonts/find-font-files-in-css.js

@@ -1,4 +1,11 @@
 //#region src/build/google-fonts/find-font-files-in-css.ts
+const formatToExtension = /* @__PURE__ */ new Map([
+	["woff", "woff"],
+	["woff2", "woff2"],
+	["truetype", "ttf"],
+	["opentype", "otf"],
+	["embedded-opentype", "eot"]
+]);
 /**
 * Find all font files in the CSS response and determine which files should be preloaded.
 * In Google Fonts responses, the @font-face's subset is above it in a comment.
@@ -16,10 +23,16 @@ function findFontFilesInCss(css, subsetsToPreload) {
 		if (newSubset) currentSubset = newSubset;
 		else {
 			const googleFontFileUrl = /src: url\((.+?)\)/.exec(line)?.[1];
-			if (googleFontFileUrl && !fontFiles.some((foundFile) => foundFile.googleFontFileUrl === googleFontFileUrl)) fontFiles.push({
-				googleFontFileUrl,
-				preloadFontFile: !!subsetsToPreload?.includes(currentSubset)
-			});
+			if (googleFontFileUrl && !fontFiles.some((foundFile) => foundFile.googleFontFileUrl === googleFontFileUrl)) {
+				const pathname = googleFontFileUrl.split(/[?#]/, 1)[0];
+				const format = /format\(['"](.+?)['"]\)/.exec(line)?.[1];
+				const ext = /\.(woff|woff2|eot|ttf|otf)$/.exec(pathname)?.[1] ?? formatToExtension.get(format ?? "") ?? "woff2";
+				fontFiles.push({
+					googleFontFileUrl,
+					preloadFontFile: !!subsetsToPreload?.includes(currentSubset),
+					ext
+				});
+			}
 		}
 	}
 	return fontFiles;

package/dist/build/google-fonts/font-metadata.d.ts

@@ -16,4 +16,5 @@ type FontFamilyMetadata = {
   subsets: string[];
 };
 export declare const googleFontsMetadata: Record<string, FontFamilyMetadata>;
-//#endregion
+//#endregion
+export {};

package/dist/build/google-fonts/validate.d.ts

@@ -23,4 +23,5 @@ type ValidatedGoogleFontOptions = {
   subsets: string[];
 };
 export declare function validateGoogleFontOptions(fontFamily: string, options: GoogleFontOptions): ValidatedGoogleFontOptions;
-//#endregion
+//#endregion
+export {};

package/dist/build/inline-css.d.ts

@@ -2,4 +2,5 @@
 type InlineCssManifest = Record<string, string>;
 export declare function collectInlineCssManifest(clientDir: string, assetPrefix: string): InlineCssManifest;
 export declare function injectInlineCssManifestGlobal(entryPath: string, manifest: InlineCssManifest): boolean;
-//#endregion
+//#endregion
+export {};

package/dist/build/layout-classification.d.ts

@@ -58,4 +58,5 @@ export declare function isStaticModuleGraphResult(graphResult: ModuleGraphClassi
  * Used only by `tests/layout-classification.test.ts`.
  */
 export declare function classifyAllRouteLayouts(routes: readonly RouteForClassification[], dynamicShimPaths: ReadonlySet<string>, moduleInfo: ModuleInfoProvider): Map<string, LayoutBuildClassification>;
-//#endregion
+//#endregion
+export {};