vinext 0.0.50 → 0.0.52

package/dist/config/next-config.d.ts

@@ -20,12 +20,29 @@ type NextRedirect = {
   permanent: boolean;
   has?: HasCondition[];
   missing?: HasCondition[];
+  /**
+   * When true (the default with i18n configured), Next.js prepends an internal
+   * locale alternation to the source so the rule matches locale-prefixed paths.
+   * When `false`, the source is left untouched and matches the raw path,
+   * letting user-supplied `:locale` segments capture the prefix themselves.
+   * See https://nextjs.org/docs/app/api-reference/config/next-config-js/redirects#locale
+   */
+  locale?: false;
+  /**
+   * When `false`, the rule is NOT prefixed with `basePath`. Source and
+   * destination are matched/applied verbatim. Mirrors Next.js's
+   * `Redirect.basePath: false` opt-out — see
+   * `.nextjs-ref/packages/next/src/lib/load-custom-routes.ts:26`.
+   */
+  basePath?: false;
 };
 type NextRewrite = {
   source: string;
   destination: string;
   has?: HasCondition[];
-  missing?: HasCondition[];
+  missing?: HasCondition[]; /** See {@link NextRedirect.locale}. */
+  locale?: false; /** See {@link NextRedirect.basePath}. */
+  basePath?: false;
 };
 type NextHeader = {
   source: string;
@@ -34,7 +51,8 @@ type NextHeader = {
   headers: Array<{
     key: string;
     value: string;
-  }>;
+  }>; /** See {@link NextRedirect.basePath}. */
+  basePath?: false;
 };
 type NextI18nConfig = {
   /** List of supported locales */locales: string[]; /** The default locale (used when no locale prefix is in the URL) */
@@ -66,7 +84,15 @@ type MdxOptions = {
 };
 type NextConfig = {
   /** Additional env variables */env?: Record<string, string>; /** Base URL path prefix */
-  basePath?: string; /** Whether to add trailing slashes */
+  basePath?: string;
+  /**
+   * Prefix applied to every emitted JS/CSS/image/static asset URL.
+   * Accepts a path prefix (e.g. `/custom-asset-prefix`) or an absolute
+   * URL (e.g. `https://cdn.example.com`). Distinct from `basePath`:
+   * `basePath` affects route URLs; `assetPrefix` only affects asset URLs.
+   * @see https://nextjs.org/docs/app/api-reference/config/next-config-js/assetPrefix
+   */
+  assetPrefix?: string; /** Whether to add trailing slashes */
   trailingSlash?: boolean; /** Internationalization routing config */
   i18n?: NextI18nConfig; /** URL redirect rules */
   redirects?: () => Promise<NextRedirect[]> | NextRedirect[]; /** URL rewrite rules */
@@ -151,6 +177,20 @@ type NextConfigInput = NextConfig | NextConfigFactory;
 type ResolvedNextConfig = {
   env: Record<string, string>;
   basePath: string;
+  /**
+   * Resolved `assetPrefix` from next.config.
+   *
+   * Empty string when unset. Trailing slashes are trimmed. May be either:
+   *  - a path prefix beginning with `/` (e.g. `"/custom-asset-prefix"`), or
+   *  - an absolute URL with `http(s)://` origin (e.g. `"https://cdn.example.com"`
+   *    or `"https://cdn.example.com/sub"`).
+   *
+   * Mirrors Next.js semantics — `assetPrefix` controls emitted asset URLs
+   * only; route URLs continue to live under `basePath`.
+   *
+   * @see https://nextjs.org/docs/app/api-reference/config/next-config-js/assetPrefix
+   */
+  assetPrefix: string;
   trailingSlash: boolean;
   output: "" | "export" | "standalone";
   pageExtensions: string[];
@@ -197,7 +237,52 @@ type ResolvedNextConfig = {
    * change without modifying source — useful for cache-busting after CDN poisoning.
    */
   hashSalt: string;
+  /**
+   * Raw `sassOptions` object from next.config (or `null` when unset). vinext
+   * passes the relevant keys through to Vite's `css.preprocessorOptions.scss`
+   * so SCSS variables defined via `additionalData` / `prependData`, partials
+   * resolved via `includePaths` / `loadPaths`, and a custom `implementation`
+   * all behave the same as in Next.js.
+   *
+   * Kept loose (`Record<string, unknown> | null`) to match Next.js's typing —
+   * the object is forwarded to Sass and may contain any modern Sass option.
+   */
+  sassOptions: Record<string, unknown> | null;
 };
+/**
+ * Whole-word substring check for any of the CJS-style globals that the
+ * injector plugin would shim. Used to skip the transform entirely for the
+ * common case where the config is pure ESM (no `__filename`, `__dirname`,
+ * `require`, `module`, or `exports` references).
+ *
+ * False positives are harmless: a comment, string literal, or unrelated
+ * identifier like `node:module` will trigger the transform unnecessarily,
+ * but the resulting injection is idempotent and the loaded config is
+ * unaffected. False negatives would be a correctness bug, so we err on the
+ * side of matching too eagerly.
+ *
+ * Note: `\bexports\b` does not match `export default` (different word
+ * boundaries), and `\brequire\b` does not match `requireSomething`.
+ */
+declare function referencesCjsGlobals(source: string): boolean;
+/**
+ * Static heuristic: returns true when the source appears to assign to
+ * `module.exports` — either via `module.exports = …`, `module.exports.foo = …`,
+ * or `module.exports[…] = …`. Used to decide whether the injector plugin
+ * needs to wire up the wrapper `module` object so {@link unwrapConfig} can
+ * read back the user's CJS-style export.
+ *
+ * Pure-ESM configs skip the wrapper entirely, which means a faster transform
+ * (no extra `export const` line) and a simpler unwrap path (no need to
+ * disambiguate "initial empty object" from "user reassigned to {}").
+ *
+ * Like {@link referencesCjsGlobals}, false positives are harmless: at worst
+ * we emit an unused `__vinext_cjs_exports` named export, and `unwrapConfig`
+ * still prefers it (it points at an empty object, which then gets treated
+ * as the config — equivalent to today's sentinel logic for pure-ESM files
+ * that happen to mention `module.exports` only in a string).
+ */
+declare function reassignsModuleExports(source: string): boolean;
 declare function findNextConfigPath(root: string): string | null;
 declare function resolveNextConfigInput(config: NextConfigInput, phase?: string): Promise<NextConfig>;
 /**
@@ -207,9 +292,26 @@ declare function resolveNextConfigInput(config: NextConfigInput, phase?: string)
  * Attempts Vite's module runner first so TS configs and extensionless local
  * imports (e.g. `import "./env"`) resolve consistently. If loading fails due
  * to CJS constructs (`require`, `module.exports`), falls back to `createRequire`
- * so common CJS plugin wrappers (nextra, @next/mdx, etc.) still work.
+ * so common CJS plugin wrappers (nextra, @next/mdx, etc.) still work, including
+ * `next.config.js` files written in CJS syntax inside a `"type": "module"`
+ * package (the common shape after `vinext init`).
  */
 declare function loadNextConfig(root: string, phase?: string): Promise<NextConfig | null>;
+/**
+ * Normalize the `assetPrefix` option from next.config.
+ *
+ * Accepts both absolute URLs (`https://cdn.example.com[/subpath]`) and
+ * path prefixes (`/custom-asset-prefix`). Trailing slashes are trimmed.
+ * Empty/whitespace-only strings are treated as unset and return `""`.
+ *
+ * Path prefixes that omit the leading slash get one added so they always
+ * begin with `/` — this matches how Next.js routes match against them.
+ *
+ * Non-string values are rejected to surface config mistakes early.
+ *
+ * @see https://nextjs.org/docs/app/api-reference/config/next-config-js/assetPrefix
+ */
+declare function normalizeAssetPrefix(value: unknown): string;
 /**
  * Resolve a NextConfig into a fully-resolved ResolvedNextConfig.
  * Awaits async functions for redirects/rewrites/headers.
@@ -242,5 +344,5 @@ declare function extractMdxOptions(config: NextConfig, root?: string): Promise<M
  */
 declare function detectNextIntlConfig(root: string, resolved: ResolvedNextConfig): void;
 //#endregion
-export { HasCondition, MdxOptions, NextConfig, NextConfigFactory, NextConfigInput, NextHeader, NextI18nConfig, NextRedirect, NextRewrite, PHASE_PRODUCTION_BUILD, ResolvedNextConfig, detectNextIntlConfig, extractMdxOptions, findNextConfigPath, loadNextConfig, parseBodySizeLimit, resolveNextConfig, resolveNextConfigInput };
+export { HasCondition, MdxOptions, NextConfig, NextConfigFactory, NextConfigInput, NextHeader, NextI18nConfig, NextRedirect, NextRewrite, PHASE_PRODUCTION_BUILD, ResolvedNextConfig, detectNextIntlConfig, extractMdxOptions, findNextConfigPath, loadNextConfig, normalizeAssetPrefix, parseBodySizeLimit, reassignsModuleExports, referencesCjsGlobals, resolveNextConfig, resolveNextConfigInput };
 //# sourceMappingURL=next-config.d.ts.map

package/dist/config/next-config.js

@@ -1,11 +1,13 @@
 import { normalizePageExtensions } from "../routing/file-matcher.js";
-import { isExternalUrl } from "./config-matchers.js";
+import { applyLocaleToRoutes, isExternalUrl } from "./config-matchers.js";
 import { PHASE_DEVELOPMENT_SERVER, PHASE_PRODUCTION_BUILD } from "../shims/constants.js";
+import { loadTsconfigPathAliasesForRoot } from "./tsconfig-paths.js";
 import { createRequire } from "node:module";
 import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { randomUUID } from "node:crypto";
+import commonjs from "vite-plugin-commonjs";
 //#region src/config/next-config.ts
 /**
 * next.config.js / next.config.mjs / next.config.ts parser
@@ -60,6 +62,7 @@ function parseBodySizeLimit(value) {
 }
 const CONFIG_FILES = [
 	"next.config.ts",
+	"next.config.mts",
 	"next.config.mjs",
 	"next.config.js",
 	"next.config.cjs"
@@ -97,11 +100,138 @@ async function resolveConfigValue(config, phase = DEFAULT_PHASE) {
 	return config;
 }
 /**
+* Named export attached by `cjsGlobalsInjectorPlugin` when the source
+* statically looks like it assigns to `module.exports`. Holds the wrapper
+* `module` object so {@link unwrapConfig} can read back the user's CJS-style
+* export. Pure-ESM configs skip the wrapper entirely and rely on the ESM
+* `default` export instead.
+*/
+const VINEXT_CJS_EXPORTS_KEY = "__vinext_cjs_exports";
+/**
+* Companion named export pointing at the initial empty `{}` that the wrapper
+* is constructed with. Lets {@link unwrapConfig} distinguish "user reassigned
+* or mutated module.exports" from "module.exports is still the untouched
+* empty wrapper" — the latter happens when {@link reassignsModuleExports}
+* matches inside a string or comment (a harmless false positive that should
+* still fall through to the ESM `default` export).
+*/
+const VINEXT_CJS_INITIAL_KEY = "__vinext_cjs_initial_exports";
+/**
 * Unwrap the config value from a loaded module namespace.
+*
+* Prefers `module.exports` (CJS style) when the config file reassigned it,
+* otherwise falls back to `default`/the namespace itself. Mirrors Next.js's
+* behaviour, where the config is loaded through `Module._compile` and CJS
+* assignments override any ESM-style exports.
+*
+* The presence of the `__vinext_cjs_exports` named export is the static
+* signal (set by `cjsGlobalsInjectorPlugin` when `reassignsModuleExports`
+* matched) that this file might use CJS-style exports. We then disambiguate
+* "user actually touched module.exports" from "static heuristic was a false
+* positive" by comparing identity against the initial empty wrapper: if
+* `module.exports` is still the original `{}`, fall back to ESM `default`.
 */
 async function unwrapConfig(mod, phase = PHASE_DEVELOPMENT_SERVER) {
+	const cjsExports = (mod?.[VINEXT_CJS_EXPORTS_KEY])?.exports;
+	const cjsInitial = mod?.[VINEXT_CJS_INITIAL_KEY];
+	if (cjsExports !== void 0 && cjsExports !== null && (cjsExports !== cjsInitial || typeof cjsExports === "object" && Object.keys(cjsExports).length > 0)) return await resolveConfigValue(cjsExports, phase);
 	return await resolveConfigValue(mod.default ?? mod, phase);
 }
+/**
+* Resolve a path through filesystem symlinks, falling back to the original
+* path when the file does not exist (e.g. virtual ids, query-suffixed ids).
+*/
+function safeRealpath(p) {
+	try {
+		return fs.realpathSync(p);
+	} catch {
+		return p;
+	}
+}
+/**
+* Whole-word substring check for any of the CJS-style globals that the
+* injector plugin would shim. Used to skip the transform entirely for the
+* common case where the config is pure ESM (no `__filename`, `__dirname`,
+* `require`, `module`, or `exports` references).
+*
+* False positives are harmless: a comment, string literal, or unrelated
+* identifier like `node:module` will trigger the transform unnecessarily,
+* but the resulting injection is idempotent and the loaded config is
+* unaffected. False negatives would be a correctness bug, so we err on the
+* side of matching too eagerly.
+*
+* Note: `\bexports\b` does not match `export default` (different word
+* boundaries), and `\brequire\b` does not match `requireSomething`.
+*/
+function referencesCjsGlobals(source) {
+	return /\b(?:__filename|__dirname|require|module|exports)\b/.test(source);
+}
+/**
+* Static heuristic: returns true when the source appears to assign to
+* `module.exports` — either via `module.exports = …`, `module.exports.foo = …`,
+* or `module.exports[…] = …`. Used to decide whether the injector plugin
+* needs to wire up the wrapper `module` object so {@link unwrapConfig} can
+* read back the user's CJS-style export.
+*
+* Pure-ESM configs skip the wrapper entirely, which means a faster transform
+* (no extra `export const` line) and a simpler unwrap path (no need to
+* disambiguate "initial empty object" from "user reassigned to {}").
+*
+* Like {@link referencesCjsGlobals}, false positives are harmless: at worst
+* we emit an unused `__vinext_cjs_exports` named export, and `unwrapConfig`
+* still prefers it (it points at an empty object, which then gets treated
+* as the config — equivalent to today's sentinel logic for pure-ESM files
+* that happen to mention `module.exports` only in a string).
+*/
+function reassignsModuleExports(source) {
+	return /\bmodule\s*\.\s*exports\b\s*(?:=(?!=)|\.\s*[A-Za-z_$][\w$]*\s*=(?!=)|\[)/.test(source);
+}
+/**
+* Vite plugin that prepends CJS-style globals (`__filename`, `__dirname`,
+* `module`, `exports`, `require`) to the next.config.* source before
+* Vite's module runner evaluates it.
+*
+* Next.js's `next.config.ts` loader (packages/next/src/build/next-config-ts/
+* transpile-config.ts → require-hook.ts) feeds the file through Node's
+* `Module._compile`, which provides these CJS globals even when the source
+* uses ESM syntax. Upstream test fixtures in `test/e2e/app-dir/next-config-ts*`
+* rely on that, e.g. `node-api-cjs/next.config.ts` reads
+* `fs.readFileSync(path.join(__dirname, 'foo.txt'), 'utf8')`. vinext loads
+* configs through Vite's ESM-only module runner, so we inject the same
+* globals as plain `const` declarations.
+*
+* For configs that don't reference any CJS global (the common case — every
+* upstream `next-config-ts` fixture except `node-api-cjs` is pure ESM) we
+* skip the transform entirely; see {@link referencesCjsGlobals}.
+*
+* `module.exports` reassignment is preserved by exposing the injected
+* `module` object as a named export (see {@link VINEXT_CJS_EXPORTS_KEY}) and
+* reading it back in {@link unwrapConfig}.
+*/
+function cjsGlobalsInjectorPlugin(configPath) {
+	const normalizedTarget = safeRealpath(path.resolve(configPath));
+	return {
+		name: "vinext:next-config-cjs-globals",
+		enforce: "pre",
+		transform(code, id) {
+			const idPath = id.startsWith("file://") ? fileURLToPath(id) : id.split("?")[0];
+			if (safeRealpath(path.resolve(idPath)) !== normalizedTarget) return null;
+			if (!referencesCjsGlobals(code)) return null;
+			const dirname = path.dirname(normalizedTarget);
+			const filenameLiteral = JSON.stringify(normalizedTarget);
+			const dirnameLiteral = JSON.stringify(dirname);
+			const requireBaseLiteral = JSON.stringify(path.join(dirname, "package.json"));
+			const moduleLines = reassignsModuleExports(code) ? `const __vinextInitialExports = {};
+const module = { exports: __vinextInitialExports };
+const exports = module.exports;
+export const ${VINEXT_CJS_EXPORTS_KEY} = module;\nexport const ${VINEXT_CJS_INITIAL_KEY} = __vinextInitialExports;\n` : "";
+			return {
+				code: `import { createRequire as __vinextCreateRequire } from "node:module";\nconst __filename = ${filenameLiteral};\nconst __dirname = ${dirnameLiteral};\nconst require = __vinextCreateRequire(${requireBaseLiteral});\n` + moduleLines + code,
+				map: null
+			};
+		}
+	};
+}
 function findNextConfigPath(root) {
 	for (const filename of CONFIG_FILES) {
 		const configPath = path.join(root, filename);
@@ -113,29 +243,84 @@ async function resolveNextConfigInput(config, phase = PHASE_DEVELOPMENT_SERVER)
 	return await resolveConfigValue(config, phase);
 }
 /**
+* Load a CJS-flavoured next.config.{js,cjs} via createRequire.
+*
+* For `.cjs` (or `.js` in a non-type-module package) Node's loader picks the
+* right format automatically and `require()` just works. For `.js` in a
+* `"type": "module"` package, Node infers ESM from package.json and the file
+* fails with `require is not defined`. In that case we copy the source to a
+* sibling temp `.cjs` (where the explicit extension forces CJS regardless of
+* the parent type field) and require *that*. Relative imports inside the
+* config still resolve against the original directory.
+*/
+async function loadConfigViaRequire(configPath, root, phase) {
+	const require = createRequire(path.join(root, "package.json"));
+	try {
+		return await unwrapConfig(require(configPath), phase);
+	} catch (e) {
+		if (!isCjsError(e) || !configPath.endsWith(".js")) throw e;
+		return await loadConfigViaCjsTempCopy(configPath, root, phase);
+	}
+}
+async function loadConfigViaCjsTempCopy(configPath, root, phase) {
+	const dir = path.dirname(configPath);
+	const tmpPath = path.join(dir, `.vinext-next-config.${process.pid}.${Date.now()}.cjs`);
+	fs.copyFileSync(configPath, tmpPath);
+	try {
+		return await unwrapConfig(createRequire(path.join(root, "package.json"))(tmpPath), phase);
+	} finally {
+		try {
+			fs.unlinkSync(tmpPath);
+		} catch {}
+	}
+}
+/**
 * Find and load the next.config file from the project root.
 * Returns null if no config file is found.
 *
 * Attempts Vite's module runner first so TS configs and extensionless local
 * imports (e.g. `import "./env"`) resolve consistently. If loading fails due
 * to CJS constructs (`require`, `module.exports`), falls back to `createRequire`
-* so common CJS plugin wrappers (nextra, @next/mdx, etc.) still work.
+* so common CJS plugin wrappers (nextra, @next/mdx, etc.) still work, including
+* `next.config.js` files written in CJS syntax inside a `"type": "module"`
+* package (the common shape after `vinext init`).
 */
 async function loadNextConfig(root, phase = DEFAULT_PHASE) {
 	const configPath = findNextConfigPath(root);
 	if (!configPath) return null;
 	const filename = path.basename(configPath);
+	const tsconfigAliases = loadTsconfigPathAliasesForRoot(root);
+	const normalizedConfigPath = safeRealpath(path.resolve(configPath));
 	try {
 		const { runnerImport } = await import("vite");
 		const { module: mod } = await runnerImport(configPath, {
 			root,
 			logLevel: "error",
-			clearScreen: false
+			clearScreen: false,
+			resolve: {
+				alias: tsconfigAliases,
+				extensions: [
+					".mjs",
+					".js",
+					".cjs",
+					".mts",
+					".ts",
+					".cts",
+					".jsx",
+					".tsx",
+					".json"
+				]
+			},
+			plugins: [.../\.[cm]?ts$/.test(configPath) ? [cjsGlobalsInjectorPlugin(configPath)] : [], commonjs({ filter: (id) => {
+				const idPath = id.startsWith("file://") ? fileURLToPath(id) : id.split("?")[0];
+				if (safeRealpath(path.resolve(idPath)) === normalizedConfigPath) return false;
+				return id.includes("node_modules") ? true : void 0;
+			} })]
 		});
 		return await unwrapConfig(mod, phase);
 	} catch (e) {
 		if (isCjsError(e) && (filename.endsWith(".js") || filename.endsWith(".cjs"))) try {
-			return await unwrapConfig(createRequire(path.join(root, "package.json"))(configPath), phase);
+			return await loadConfigViaRequire(configPath, root, phase);
 		} catch (e2) {
 			warnConfigLoadFailure(filename, e2);
 			throw e2;
@@ -169,6 +354,32 @@ async function resolveBuildId(generate) {
 	if (trimmed.length === 0) throw new Error("generateBuildId returned an empty string. https://nextjs.org/docs/messages/generatebuildid-not-a-string");
 	return trimmed;
 }
+/**
+* Normalize the `assetPrefix` option from next.config.
+*
+* Accepts both absolute URLs (`https://cdn.example.com[/subpath]`) and
+* path prefixes (`/custom-asset-prefix`). Trailing slashes are trimmed.
+* Empty/whitespace-only strings are treated as unset and return `""`.
+*
+* Path prefixes that omit the leading slash get one added so they always
+* begin with `/` — this matches how Next.js routes match against them.
+*
+* Non-string values are rejected to surface config mistakes early.
+*
+* @see https://nextjs.org/docs/app/api-reference/config/next-config-js/assetPrefix
+*/
+function normalizeAssetPrefix(value) {
+	if (value === void 0 || value === null || value === "") return "";
+	if (typeof value !== "string") throw new Error(`Invalid \`assetPrefix\` configuration: must be a string, got ${typeof value}. Accepts a path prefix ("/custom-asset-prefix") or an absolute URL ("https://cdn.example.com").`);
+	let trimmed = value.trim();
+	while (trimmed.endsWith("/")) trimmed = trimmed.slice(0, -1);
+	if (trimmed === "") return "";
+	if (/^https?:\/\//i.test(trimmed)) {
+		if (!URL.canParse(trimmed)) throw new Error(`Invalid \`assetPrefix\` configuration: "${value}" is not a parseable URL.`);
+		return trimmed;
+	}
+	return trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
+}
 function resolveDeploymentId(configDeploymentId) {
 	const deploymentId = configDeploymentId !== void 0 ? configDeploymentId : process.env.NEXT_DEPLOYMENT_ID;
 	if (deploymentId === void 0 || deploymentId === "") return void 0;
@@ -198,6 +409,7 @@ async function resolveNextConfig(config, root = process.cwd()) {
 		const resolved = {
 			env: {},
 			basePath: "",
+			assetPrefix: "",
 			trailingSlash: false,
 			output: "",
 			pageExtensions: normalizePageExtensions(),
@@ -224,7 +436,8 @@ async function resolveNextConfig(config, root = process.cwd()) {
 			enablePrerenderSourceMaps: true,
 			hashSalt: process.env.NEXT_HASH_SALT ?? "",
 			buildId,
-			deploymentId
+			deploymentId,
+			sassOptions: null
 		};
 		detectNextIntlConfig(root, resolved);
 		return resolved;
@@ -279,6 +492,7 @@ async function resolveNextConfig(config, root = process.cwd()) {
 	const legacyServerComponentsExternal = experimental?.serverComponentsExternalPackages;
 	const serverExternalPackages = Array.isArray(config.serverExternalPackages) ? config.serverExternalPackages : Array.isArray(legacyServerComponentsExternal) ? legacyServerComponentsExternal : [];
 	if (experimental?.swcEnvOptions !== void 0) console.warn("[vinext] next.config option \"experimental.swcEnvOptions\" is not applicable and will be ignored (vinext uses Vite, not SWC). A Vite-compatible polyfill solution may be explored in the future.");
+	if (experimental?.rootParams !== void 0) console.warn("[vinext] `experimental.rootParams` is no longer needed, because `next/root-params` is available by default. You can remove it from next.config.(js|mjs|ts).");
 	if (config.webpack !== void 0) if (mdx || Object.keys(webpackProbe.aliases).length > 0) console.warn("[vinext] next.config option \"webpack\" is only partially supported. vinext preserves resolve.alias entries and MDX loader settings, but other webpack customization is ignored");
 	else console.warn("[vinext] next.config option \"webpack\" is not yet supported and will be ignored");
 	const output = config.output ?? "";
@@ -295,9 +509,19 @@ async function resolveNextConfig(config, root = process.cwd()) {
 	const deploymentId = resolveDeploymentId(config.deploymentId);
 	const cacheHandler = typeof config.cacheHandler === "string" ? resolveCacheHandlerPathToFilesystem(config.cacheHandler) : void 0;
 	const cacheMaxMemorySize = typeof config.cacheMaxMemorySize === "number" ? config.cacheMaxMemorySize : void 0;
+	if (i18n) {
+		const opts = { trailingSlash: config.trailingSlash ?? false };
+		redirects = applyLocaleToRoutes(redirects, i18n, "redirect", opts);
+		rewrites = {
+			beforeFiles: applyLocaleToRoutes(rewrites.beforeFiles, i18n, "rewrite", opts),
+			afterFiles: applyLocaleToRoutes(rewrites.afterFiles, i18n, "rewrite", opts),
+			fallback: applyLocaleToRoutes(rewrites.fallback, i18n, "rewrite", opts)
+		};
+	}
 	const resolved = {
 		env: config.env ?? {},
 		basePath: config.basePath ?? "",
+		assetPrefix: normalizeAssetPrefix(config.assetPrefix),
 		trailingSlash: config.trailingSlash ?? false,
 		output: output === "export" || output === "standalone" ? output : "",
 		pageExtensions,
@@ -320,9 +544,11 @@ async function resolveNextConfig(config, root = process.cwd()) {
 		enablePrerenderSourceMaps: config.enablePrerenderSourceMaps ?? true,
 		hashSalt,
 		buildId,
-		deploymentId
+		deploymentId,
+		sassOptions: config.sassOptions && typeof config.sassOptions === "object" ? config.sassOptions : null
 	};
 	detectNextIntlConfig(root, resolved);
+	if (resolved.basePath !== "" && resolved.basePath !== "/" && resolved.assetPrefix === "") resolved.assetPrefix = resolved.basePath;
 	return resolved;
 }
 function normalizeAliasEntries(aliases, root) {
@@ -476,6 +702,6 @@ function extractPluginsFromOptions(opts) {
 	return null;
 }
 //#endregion
-export { PHASE_PRODUCTION_BUILD, detectNextIntlConfig, extractMdxOptions, findNextConfigPath, loadNextConfig, parseBodySizeLimit, resolveNextConfig, resolveNextConfigInput };
+export { PHASE_PRODUCTION_BUILD, detectNextIntlConfig, extractMdxOptions, findNextConfigPath, loadNextConfig, normalizeAssetPrefix, parseBodySizeLimit, reassignsModuleExports, referencesCjsGlobals, resolveNextConfig, resolveNextConfigInput };
 
 //# sourceMappingURL=next-config.js.map