vinext 0.1.1 → 0.1.2

package/dist/utils/lazy-chunks.js

@@ -44,5 +44,69 @@ function computeLazyChunks(buildManifest) {
 	}
 	return lazyChunks;
 }
+function normalizeManifestKey(key) {
+	return key.split("?")[0].replace(/\\/g, "/").replace(/^\/+/, "");
+}
+function addFile(files, seen, file) {
+	if (!file || seen.has(file)) return;
+	seen.add(file);
+	files.push(file);
+}
+function collectStaticChunkFiles(buildManifest, key, files, seenFiles, visitedChunks) {
+	if (visitedChunks.has(key)) return;
+	visitedChunks.add(key);
+	const chunk = buildManifest[key];
+	if (!chunk) return;
+	if (chunk.file.endsWith(".js")) addFile(files, seenFiles, chunk.file);
+	for (const cssFile of chunk.css ?? []) addFile(files, seenFiles, cssFile);
+	for (const importedKey of chunk.imports ?? []) collectStaticChunkFiles(buildManifest, importedKey, files, seenFiles, visitedChunks);
+}
+/**
+* Compute the production preload files for each module referenced by a
+* `next/dynamic()` boundary.
+*
+* Next.js records module IDs during compilation, then resolves those IDs
+* against its react-loadable manifest at render time. Vinext's equivalent
+* source of truth is Vite's build manifest: each chunk lists the modules it
+* reaches through `dynamicImports`, and each dynamic entry lists the JS/CSS
+* files required to evaluate it.
+*
+* Note on shared chunks: a boundary's static-import tree (`collectStaticChunkFiles`)
+* can include chunks that the page entry ALSO loads eagerly (a shared vendor
+* chunk imported by both). Those files are intentionally NOT subtracted here, so
+* a rendered boundary may emit a `<link rel="preload">` / `<link rel="stylesheet">`
+* for a chunk the page already `<link rel="modulepreload">`s. This is harmless —
+* the browser dedupes preloads by URL, `ReactDOM.preload()` dedupes script hints,
+* and React's stylesheet resource model dedupes by href + precedence — and it
+* mirrors Next.js listing a module's full file set in its react-loadable
+* manifest. Subtracting the eager set would couple this to the entry's import
+* closure for no correctness gain.
+*
+* @returns A map keyed by root-relative module ID, with JS/CSS files that
+* should be preloaded when that dynamic boundary is rendered.
+*/
+function computeDynamicImportPreloads(buildManifest) {
+	const preloads = {};
+	for (const chunk of Object.values(buildManifest)) for (const dynamicKey of chunk.dynamicImports ?? []) {
+		const files = [];
+		collectStaticChunkFiles(buildManifest, dynamicKey, files, /* @__PURE__ */ new Set(), /* @__PURE__ */ new Set());
+		if (files.length === 0) continue;
+		const normalizedKey = normalizeManifestKey(dynamicKey);
+		const existing = preloads[normalizedKey] ?? [];
+		const merged = new Set(existing);
+		for (const file of files) {
+			if (merged.has(file)) continue;
+			merged.add(file);
+			existing.push(file);
+		}
+		preloads[normalizedKey] = existing;
+	}
+	return preloads;
+}
+function dynamicImportPreloadsWithBase(preloads, applyBase) {
+	const withBase = {};
+	for (const [key, files] of Object.entries(preloads)) withBase[key] = files.map(applyBase);
+	return withBase;
+}
 //#endregion
-export { computeLazyChunks };
+export { computeDynamicImportPreloads, computeLazyChunks, dynamicImportPreloadsWithBase };

package/dist/utils/manifest-paths.d.ts

@@ -1,6 +1,24 @@
 //#region src/utils/manifest-paths.d.ts
 declare function manifestFileWithBase(file: string, base: string): string;
-declare function manifestFilesWithBase(files: string[], base: string): string[];
+declare function manifestFileWithAssetPrefix(file: string, base: string, assetPrefix: string): string;
+/**
+ * Resolve the URL a client asset is actually SERVED from, starting from a
+ * base-anchored manifest / SSR-manifest value (no leading slash), e.g.
+ * `"docs/cdn/_next/static/x.js"`.
+ *
+ * Next.js semantics: `assetPrefix` REPLACES `basePath` for asset URLs (they do
+ * not stack). So when an `assetPrefix` is configured we strip the basePath
+ * segment and re-anchor under the assetPrefix — matching how `next/dynamic`
+ * preloads are computed (`manifestFileWithAssetPrefix`) and what the prod server
+ * / Cloudflare ASSETS binding actually serve. Without this, a `basePath` +
+ * path-style `assetPrefix` build emits `/<basePath>/<assetPrefix>/_next/...`
+ * which 404s. When no `assetPrefix` is set, the base-anchored value is already
+ * the served URL and is returned unchanged (just root-anchored).
+ *
+ * Returns an absolute URL for an absolute `assetPrefix`, otherwise a
+ * root-relative URL beginning with `/`.
+ */
+declare function assetServingUrlFromBaseAnchored(value: string, basePath: string, assetPrefix: string): string;
 /**
  * Strip a `base` prefix that Vite applied twice: it bakes `base` into the
  * on-disk chunk fileName and then prepends it again in `ssr-manifest.json`,
@@ -9,4 +27,4 @@ declare function manifestFilesWithBase(files: string[], base: string): string[];
  */
 declare function collapseDuplicateBase(file: string, base: string): string;
 //#endregion
-export { collapseDuplicateBase, manifestFileWithBase, manifestFilesWithBase };
+export { assetServingUrlFromBaseAnchored, collapseDuplicateBase, manifestFileWithAssetPrefix, manifestFileWithBase };

package/dist/utils/manifest-paths.js

@@ -1,3 +1,4 @@
+import { ASSET_PREFIX_URL_DIR, isAbsoluteAssetPrefix, resolveAssetUrlPrefix, resolveAssetsDir } from "./asset-prefix.js";
 //#region src/utils/manifest-paths.ts
 function normalizeManifestFile(file) {
 	return file.startsWith("/") ? file.slice(1) : file;
@@ -10,8 +11,42 @@ function manifestFileWithBase(file, base) {
 	if (normalizedFile.startsWith(normalizedBase + "/")) return normalizedFile;
 	return normalizedBase + "/" + normalizedFile;
 }
-function manifestFilesWithBase(files, base) {
-	return files.map((file) => manifestFileWithBase(file, base));
+function manifestFileWithAssetPrefix(file, base, assetPrefix) {
+	if (!assetPrefix) return manifestFileWithBase(file, base);
+	const normalizedFile = normalizeManifestFile(file);
+	const onDiskDirPrefix = normalizeManifestFile(resolveAssetsDir(assetPrefix)) + "/";
+	const staticDirPrefix = ASSET_PREFIX_URL_DIR + "/";
+	const stripped = normalizedFile.startsWith(onDiskDirPrefix) ? normalizedFile.slice(onDiskDirPrefix.length) : normalizedFile.startsWith(staticDirPrefix) ? normalizedFile.slice(staticDirPrefix.length) : normalizedFile;
+	const urlPrefix = resolveAssetUrlPrefix(assetPrefix);
+	return (isAbsoluteAssetPrefix(assetPrefix) ? urlPrefix : normalizeManifestFile(urlPrefix)) + stripped;
+}
+function stripBasePathSegment(file, basePath) {
+	const normalizedBase = normalizeManifestFile(basePath).replace(/\/+$/, "");
+	if (!normalizedBase) return file;
+	return file.startsWith(normalizedBase + "/") ? file.slice(normalizedBase.length + 1) : file;
+}
+/**
+* Resolve the URL a client asset is actually SERVED from, starting from a
+* base-anchored manifest / SSR-manifest value (no leading slash), e.g.
+* `"docs/cdn/_next/static/x.js"`.
+*
+* Next.js semantics: `assetPrefix` REPLACES `basePath` for asset URLs (they do
+* not stack). So when an `assetPrefix` is configured we strip the basePath
+* segment and re-anchor under the assetPrefix — matching how `next/dynamic`
+* preloads are computed (`manifestFileWithAssetPrefix`) and what the prod server
+* / Cloudflare ASSETS binding actually serve. Without this, a `basePath` +
+* path-style `assetPrefix` build emits `/<basePath>/<assetPrefix>/_next/...`
+* which 404s. When no `assetPrefix` is set, the base-anchored value is already
+* the served URL and is returned unchanged (just root-anchored).
+*
+* Returns an absolute URL for an absolute `assetPrefix`, otherwise a
+* root-relative URL beginning with `/`.
+*/
+function assetServingUrlFromBaseAnchored(value, basePath, assetPrefix) {
+	const normalized = normalizeManifestFile(value);
+	if (!assetPrefix) return "/" + normalized;
+	const anchored = manifestFileWithAssetPrefix(stripBasePathSegment(normalized, basePath), "/", assetPrefix);
+	return isAbsoluteAssetPrefix(assetPrefix) ? anchored : "/" + anchored;
 }
 /**
 * Strip a `base` prefix that Vite applied twice: it bakes `base` into the
@@ -28,4 +63,4 @@ function collapseDuplicateBase(file, base) {
 	return normalizedFile.startsWith(doubledPrefix) ? normalizedFile.slice(normalizedBase.length + 1) : normalizedFile;
 }
 //#endregion
-export { collapseDuplicateBase, manifestFileWithBase, manifestFilesWithBase };
+export { assetServingUrlFromBaseAnchored, collapseDuplicateBase, manifestFileWithAssetPrefix, manifestFileWithBase };

package/dist/utils/path.d.ts

@@ -11,5 +11,6 @@
  * appear in filesystem paths on Linux/macOS.
  */
 declare function normalizePathSeparators(p: string): string;
+declare function stripViteModuleQuery(id: string): string;
 //#endregion
-export { normalizePathSeparators };
+export { normalizePathSeparators, stripViteModuleQuery };

package/dist/utils/path.js

@@ -14,5 +14,9 @@ const isWindows = process.platform === "win32";
 function normalizePathSeparators(p) {
 	return isWindows ? p.replace(/\\/g, "/") : p;
 }
+function stripViteModuleQuery(id) {
+	const queryIndex = id.search(/[?#]/);
+	return queryIndex === -1 ? id : id.slice(0, queryIndex);
+}
 //#endregion
-export { normalizePathSeparators };
+export { normalizePathSeparators, stripViteModuleQuery };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vinext",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Run Next.js apps on Vite. Drop-in replacement for the next CLI.",
   "license": "MIT",
   "repository": {
@@ -101,7 +101,7 @@
     "react-server-dom-webpack": "^19.2.7",
     "vite": "npm:@voidzero-dev/vite-plus-core@0.1.24",
     "vite-plus": "0.1.24",
-    "@vinext/cloudflare": "0.1.0"
+    "@vinext/cloudflare": "0.1.1"
   },
   "peerDependencies": {
     "@mdx-js/rollup": "^3.0.0",