@qzsy/vinext 0.1.7

package/dist/plugins/client-reference-dedup.js

@@ -0,0 +1,189 @@
+import { isUnknownRecord } from "../utils/record.js";
+import { readFile } from "node:fs/promises";
+//#region src/plugins/client-reference-dedup.ts
+function defaultReadPackageJson(path) {
+	return readFile(path, "utf8");
+}
+function parsePackagePath(absolutePath) {
+	const lastIdx = absolutePath.lastIndexOf("/node_modules/");
+	if (lastIdx === -1) return null;
+	const rest = absolutePath.slice(lastIdx + 14);
+	const parts = rest.split("/");
+	const packagePartCount = rest.startsWith("@") ? 2 : 1;
+	const packageParts = parts.slice(0, packagePartCount);
+	if (packageParts.length < packagePartCount || packageParts.some((part) => part === "")) return null;
+	const packageName = packageParts.join("/");
+	const relativeParts = parts.slice(packagePartCount);
+	return {
+		packageName,
+		packageRoot: absolutePath.slice(0, lastIdx + 14 + packageName.length),
+		relativePath: relativeParts.join("/")
+	};
+}
+/**
+* Extract the bare package name from an absolute file path containing node_modules.
+*
+* Handles scoped packages (`@org/name`) and nested node_modules.
+* Returns `null` if the path doesn't contain `/node_modules/`.
+*/
+function extractPackageName(absolutePath) {
+	return parsePackagePath(absolutePath)?.packageName ?? null;
+}
+function normalizeExportTarget(target) {
+	return target.startsWith("./") ? target.slice(2) : target;
+}
+function matchExportTarget(target, relativePath) {
+	const normalizedTarget = normalizeExportTarget(target);
+	const wildcardIndex = normalizedTarget.indexOf("*");
+	if (wildcardIndex === -1) return normalizedTarget === relativePath ? "" : null;
+	const beforeWildcard = normalizedTarget.slice(0, wildcardIndex);
+	const afterWildcard = normalizedTarget.slice(wildcardIndex + 1);
+	if (!relativePath.startsWith(beforeWildcard) || !relativePath.endsWith(afterWildcard)) return null;
+	return relativePath.slice(beforeWildcard.length, relativePath.length - afterWildcard.length);
+}
+function exportKeyToSpecifier(packageName, exportKey, wildcardMatch) {
+	if (exportKey === ".") return packageName;
+	const subpath = exportKey.startsWith("./") ? exportKey.slice(2) : exportKey;
+	return `${packageName}/${subpath.includes("*") ? subpath.replace("*", wildcardMatch) : subpath}`;
+}
+function collectExportTargets(value) {
+	if (typeof value === "string") return [value];
+	if (Array.isArray(value)) return value.flatMap((entry) => collectExportTargets(entry));
+	if (!isUnknownRecord(value)) return [];
+	return Object.values(value).flatMap((entry) => collectExportTargets(entry));
+}
+function findExportSpecifier(packageName, exportsValue, relativePath) {
+	if (!isUnknownRecord(exportsValue)) {
+		for (const target of collectExportTargets(exportsValue)) {
+			const wildcardMatch = matchExportTarget(target, relativePath);
+			if (wildcardMatch !== null) return exportKeyToSpecifier(packageName, ".", wildcardMatch);
+		}
+		return null;
+	}
+	const entries = Object.entries(exportsValue);
+	if (!entries.some(([key]) => key === "." || key.startsWith("./"))) {
+		for (const target of collectExportTargets(exportsValue)) {
+			const wildcardMatch = matchExportTarget(target, relativePath);
+			if (wildcardMatch !== null) return exportKeyToSpecifier(packageName, ".", wildcardMatch);
+		}
+		return null;
+	}
+	let bestMatch = null;
+	for (const [key, value] of entries) {
+		if (key !== "." && !key.startsWith("./")) continue;
+		for (const target of collectExportTargets(value)) {
+			const wildcardMatch = matchExportTarget(target, relativePath);
+			if (wildcardMatch === null) continue;
+			if (!bestMatch || key.length > bestMatch.key.length) bestMatch = {
+				key,
+				wildcard: wildcardMatch
+			};
+		}
+	}
+	return bestMatch ? exportKeyToSpecifier(packageName, bestMatch.key, bestMatch.wildcard) : null;
+}
+function getLegacyEntry(packageJson) {
+	const browser = packageJson.browser;
+	if (typeof browser === "string") return browser;
+	const module = packageJson.module;
+	if (typeof module === "string") return module;
+	const main = packageJson.main;
+	return typeof main === "string" ? main : "index.js";
+}
+function matchesLegacyEntry(legacyEntry, relativePath) {
+	const normalizedEntry = normalizeExportTarget(legacyEntry);
+	return normalizedEntry === relativePath || `${normalizedEntry}.js` === relativePath;
+}
+/**
+* Convert an absolute package file path into the least lossy bare import
+* specifier that can be handed back to Vite's dependency optimizer.
+*/
+async function extractPackageImportSpecifier(absolutePath, readPackageJson = defaultReadPackageJson) {
+	const packagePath = parsePackagePath(absolutePath);
+	if (!packagePath) return null;
+	const { packageName, packageRoot, relativePath } = packagePath;
+	if (relativePath === "") return {
+		packageName,
+		specifier: packageName
+	};
+	let packageJson = null;
+	try {
+		const rawPackageJson = await readPackageJson(`${packageRoot}/package.json`);
+		const parsedPackageJson = JSON.parse(rawPackageJson);
+		packageJson = isUnknownRecord(parsedPackageJson) ? parsedPackageJson : null;
+	} catch {
+		packageJson = null;
+	}
+	if (!packageJson) return {
+		packageName,
+		specifier: packageName
+	};
+	if ("exports" in packageJson) return {
+		packageName,
+		specifier: findExportSpecifier(packageName, packageJson.exports, relativePath) ?? packageName
+	};
+	return {
+		packageName,
+		specifier: matchesLegacyEntry(getLegacyEntry(packageJson), relativePath) ? packageName : `${packageName}/${relativePath}`
+	};
+}
+const DEDUP_PREFIX = "\0vinext:dedup/";
+const DEDUP_FILTER = /^\0vinext:dedup\//;
+const PROXY_MARKER = "virtual:vite-rsc/client-in-server-package-proxy/";
+/**
+* Intercepts absolute node_modules path imports originating from RSC
+* `client-in-server-package-proxy` virtual modules in the client environment
+* and redirects them through bare specifier imports. This ensures the browser
+* loads the pre-bundled version (from `.vite/deps/`) rather than the raw ESM
+* file, preventing module duplication and broken React contexts.
+*
+* Dev-only — production builds use the SSR manifest which handles this correctly.
+*/
+function clientReferenceDedupPlugin(options = {}) {
+	let excludeSet = /* @__PURE__ */ new Set();
+	const readPackageJson = options.readFile ?? defaultReadPackageJson;
+	const packageImportCache = /* @__PURE__ */ new Map();
+	return {
+		name: "vinext:client-reference-dedup",
+		enforce: "pre",
+		apply: "serve",
+		configResolved(config) {
+			const clientExclude = config.environments?.client?.optimizeDeps?.exclude ?? config.optimizeDeps?.exclude ?? [];
+			excludeSet = new Set(clientExclude);
+		},
+		resolveId: {
+			filter: { id: /node_modules/ },
+			async handler(id, importer) {
+				if (this.environment?.name !== "client") return;
+				if (!importer || !importer.includes(PROXY_MARKER)) return;
+				if (!id.startsWith("/") || !id.includes("/node_modules/")) return;
+				const packageName = extractPackageName(id);
+				if (!packageName) return;
+				if (excludeSet.has(packageName)) return;
+				let packageImportPromise = packageImportCache.get(id);
+				if (!packageImportPromise) {
+					packageImportPromise = extractPackageImportSpecifier(id, readPackageJson);
+					packageImportCache.set(id, packageImportPromise);
+				}
+				const packageImport = await packageImportPromise;
+				if (!packageImport) return;
+				if (excludeSet.has(packageImport.specifier)) return;
+				return `${DEDUP_PREFIX}${packageImport.specifier}`;
+			}
+		},
+		load: {
+			filter: { id: DEDUP_FILTER },
+			handler(id) {
+				if (!id.startsWith(DEDUP_PREFIX)) return;
+				const pkgName = id.slice(14);
+				return [
+					`export * from ${JSON.stringify(pkgName)};`,
+					`import * as __all__ from ${JSON.stringify(pkgName)};`,
+					`export default __all__.default;`
+				].join("\n");
+			}
+		}
+	};
+}
+//#endregion
+export { clientReferenceDedupPlugin, extractPackageImportSpecifier, extractPackageName };

package/dist/plugins/css-data-url.d.ts

@@ -0,0 +1,6 @@
+import { Plugin } from "vite";
+
+//#region src/plugins/css-data-url.d.ts
+declare function dataUrlCssPlugin(): Plugin;
+//#endregion
+export { dataUrlCssPlugin };

package/dist/plugins/css-data-url.js

@@ -0,0 +1,83 @@
+import { createHash } from "node:crypto";
+//#region src/plugins/css-data-url.ts
+/**
+* Virtual module prefix. The leading `\0` is the Rollup/Vite convention for
+* synthetic ids; it suppresses on-disk lookups and signals to other plugins
+* that the module is virtual. The `.module.css` / `.css` suffix is required so
+* Vite's built-in `vite:css` plugin matches the id via its `CSS_LANGS_RE` /
+* `cssModuleRE` filters.
+*/
+const VIRTUAL_PREFIX = "\0vinext-data-css/";
+/**
+* Matches a CSS data URL string anywhere in source code. The match is bounded
+* by the surrounding string quotes (`'` or `"`) so we only rewrite literal
+* import specifiers, never identifiers or comments that happen to contain
+* `data:text/css`. The closing quote uses a backreference (`\1`) to the
+* opening quote, so mixed-quote spans cannot match accidentally.
+*
+* Groups:
+*   1. opening quote (preserved on output; the closing quote is `\1`)
+*   2. `+module` MIME suffix, or empty for plain stylesheets
+*   3. `;base64` flag, or empty for percent-encoded payloads
+*   4. encoded CSS payload
+*/
+const DATA_URL_IMPORT_RE = /(['"])data:text\/css(\+module)?(;base64)?,([\s\S]*?)\1/g;
+/** Quick filter for sources that contain at least one CSS data URL. */
+const DATA_URL_HINT = "data:text/css";
+function decode(payload, isBase64) {
+	if (isBase64) return Buffer.from(payload, "base64").toString("utf8");
+	return decodeURIComponent(payload);
+}
+function hash(text) {
+	return createHash("sha1").update(text).digest("hex").slice(0, 16);
+}
+function dataUrlCssPlugin() {
+	const entries = /* @__PURE__ */ new Map();
+	return {
+		name: "vinext:css-data-url",
+		enforce: "pre",
+		transform: {
+			filter: {
+				id: { exclude: new RegExp(`^${VIRTUAL_PREFIX}`) },
+				code: DATA_URL_HINT
+			},
+			handler(code, id) {
+				let mutated = false;
+				const rewritten = code.replace(DATA_URL_IMPORT_RE, (_match, quote, moduleFlag, base64Flag, payload) => {
+					const isModule = moduleFlag === "+module";
+					const isBase64 = base64Flag === ";base64";
+					let css;
+					try {
+						css = decode(payload, isBase64);
+					} catch (err) {
+						throw new Error(`[vinext] Failed to decode CSS data URL import in ${id}: ${err.message}`);
+					}
+					const ext = isModule ? ".module.css" : ".css";
+					const syntheticId = `${VIRTUAL_PREFIX}${hash(css + ext)}${ext}`;
+					entries.set(syntheticId, {
+						css,
+						isModule
+					});
+					mutated = true;
+					return `${quote}${syntheticId}${quote}`;
+				});
+				if (!mutated) return null;
+				return {
+					code: rewritten,
+					map: null
+				};
+			}
+		},
+		resolveId(id) {
+			if (id.startsWith(VIRTUAL_PREFIX)) return id;
+			return null;
+		},
+		load(id) {
+			const entry = entries.get(id);
+			if (!entry) return null;
+			return entry.css;
+		}
+	};
+}
+//#endregion
+export { dataUrlCssPlugin };

package/dist/plugins/dynamic-preload-metadata.d.ts

@@ -0,0 +1,13 @@
+import { Plugin } from "vite";
+import MagicString from "magic-string";
+
+//#region src/plugins/dynamic-preload-metadata.d.ts
+type TransformResult = {
+  code: string;
+  map: ReturnType<MagicString["generateMap"]>;
+};
+type ResolveDynamicImport = (specifier: string, importer: string) => Promise<string | null>;
+declare function transformNextDynamicPreloadMetadata(code: string, id: string, root: string, resolveDynamicImport: ResolveDynamicImport): Promise<TransformResult | null>;
+declare function createDynamicPreloadMetadataPlugin(): Plugin;
+//#endregion
+export { createDynamicPreloadMetadataPlugin, transformNextDynamicPreloadMetadata };