cloudflare-next-intl 0.9.47 → 0.9.49

package/dist/src/vite/auto_locale_params_plugin.js

@@ -0,0 +1,71 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { checkLocaleParams } from "../locale_params_check/check_locale_params.js";
+import { registerBuildWriteRestore } from "./build_write_restore_stack.js";
+const RESTORABLE_ACTIONS = new Set(['added-locale-params']);
+export function autoLocaleParamsPlugin(options = {}) {
+    let ran = false;
+    return {
+        name: "cloudflare-next-intl-auto-locale-params",
+        enforce: "pre",
+        async configResolved(config) {
+            if (ran)
+                return;
+            const isBuild = config.command === "build";
+            const isDev = config.command === "serve";
+            if (!isBuild && !(isDev && options.runOnDev))
+                return;
+            ran = true;
+            const root = config.root || process.cwd();
+            let appDir = options.appDir;
+            if (!appDir) {
+                if (existsSync(resolve(root, "src/app"))) {
+                    appDir = resolve(root, "src/app");
+                }
+                else if (existsSync(resolve(root, "app"))) {
+                    appDir = resolve(root, "app");
+                }
+            }
+            if (!appDir || !existsSync(appDir))
+                return;
+            const restoreAfterBuild = isBuild && (options.restoreAfterBuild ?? true);
+            const originals = new Map();
+            try {
+                const reports = await checkLocaleParams({
+                    appDir,
+                    mode: options.mode ?? "fix",
+                    localeParam: options.localeParam,
+                    skip: options.skip,
+                    overrides: options.overrides,
+                    verbose: options.verbose ?? false,
+                }, restoreAfterBuild
+                    ? {
+                        writeFile: (file, contents) => {
+                            if (!originals.has(file)) {
+                                try {
+                                    originals.set(file, readFileSync(file, "utf8"));
+                                }
+                                catch {
+                                }
+                            }
+                            writeFileSync(file, contents, "utf8");
+                        },
+                    }
+                    : undefined);
+                if (!restoreAfterBuild)
+                    return;
+                const restorable = new Set(reports
+                    .filter((report) => RESTORABLE_ACTIONS.has(report.action))
+                    .map((report) => report.file));
+                for (const file of [...originals.keys()]) {
+                    if (!restorable.has(file))
+                        originals.delete(file);
+                }
+                registerBuildWriteRestore(originals);
+            }
+            catch (err) {
+                console.warn("[cloudflare-next-intl] autoLocaleParams check error:", err);
+            }
+        },
+    };
+}

package/dist/src/vite/build_write_restore_stack.d.ts

@@ -0,0 +1 @@
+export declare function registerBuildWriteRestore(originals: ReadonlyMap<string, string>): void;

package/dist/src/vite/build_write_restore_stack.js

@@ -0,0 +1,43 @@
+import { writeFileSync } from "node:fs";
+const restoreStack = [];
+let registered = false;
+export function registerBuildWriteRestore(originals) {
+    if (originals.size === 0)
+        return;
+    restoreStack.push(() => {
+        for (const [file, contents] of originals) {
+            try {
+                writeFileSync(file, contents, "utf8");
+            }
+            catch {
+            }
+        }
+    });
+    if (registered)
+        return;
+    registered = true;
+    armProcessRestoreHandlers();
+}
+function runAllRestores() {
+    while (restoreStack.length > 0) {
+        const restore = restoreStack.pop();
+        restore();
+    }
+}
+function armProcessRestoreHandlers() {
+    process.once("exit", runAllRestores);
+    for (const signal of ["SIGINT", "SIGTERM"]) {
+        process.once(signal, () => {
+            runAllRestores();
+            process.kill(process.pid, signal);
+        });
+    }
+    process.once("uncaughtException", (err) => {
+        runAllRestores();
+        throw err;
+    });
+    process.once("unhandledRejection", (reason) => {
+        runAllRestores();
+        throw reason;
+    });
+}

package/dist/src/vite/index.d.ts

@@ -1,8 +1,10 @@
 export { autoDynamicPagesPlugin, type AutoDynamicPagesPluginOptions } from "./auto_dynamic_pages_plugin.js";
+export { autoLocaleParamsPlugin, type AutoLocaleParamsPluginOptions } from "./auto_locale_params_plugin.js";
 export { buildIdAsset } from "./build_id_asset.js";
 export { userAgentStubPlugin, USER_AGENT_STUB_ID, USER_AGENT_STUB_CODE } from "./user_agent_stub.js";
 export { cfWorkersClientStubPlugin, CF_WORKERS_CLIENT_STUB_ID, CF_WORKERS_CLIENT_STUB_CODE } from "./cf_workers_client_stub.js";
 export { vinextRouteWiringFixPlugin, patchAppPageRouteWiring, isAppPageRouteWiringFile, isAppPageRouteWiringAlreadyFixed, type VinextRouteWiringFixPluginOptions } from "./vinext_route_wiring_fix.js";
 export { localeFilePlugin, resolveDefaultIntlConfigPath, type LocaleFilePluginOptions } from "./locale_file_plugin.js";
+export { lucideOptimizerPlugin, detectLucideReact, resolveLucideEsmEntry, parseLucideIconMap, transformLucideImports, transformNextJsImports, type LucideOptimizerPluginOptions, } from "./lucide_optimizer_plugin.js";
 export { cloudflareNextIntl, cloudflareNextIntlPlugin, type CloudflareNextIntlOptions, default } from "./plugin.js";
 export { imageOptimizer, imageOptimizerPlugin, VIRTUAL_IMAGE_SHIM_ID, type ImageFormat, type ImageBlurOptions, type ImageOverrideOptions, type ImageOptimizerPluginOptions, type ResolvedBlurOptions, type ResolvedOptions, type ResolvedImageConfig, type OptimizedImage, type ManifestData, type ManifestEntry, } from "../image_optimizer/index.js";

package/dist/src/vite/index.js

@@ -1,8 +1,10 @@
 export { autoDynamicPagesPlugin } from "./auto_dynamic_pages_plugin.js";
+export { autoLocaleParamsPlugin } from "./auto_locale_params_plugin.js";
 export { buildIdAsset } from "./build_id_asset.js";
 export { userAgentStubPlugin, USER_AGENT_STUB_ID, USER_AGENT_STUB_CODE } from "./user_agent_stub.js";
 export { cfWorkersClientStubPlugin, CF_WORKERS_CLIENT_STUB_ID, CF_WORKERS_CLIENT_STUB_CODE } from "./cf_workers_client_stub.js";
 export { vinextRouteWiringFixPlugin, patchAppPageRouteWiring, isAppPageRouteWiringFile, isAppPageRouteWiringAlreadyFixed } from "./vinext_route_wiring_fix.js";
 export { localeFilePlugin, resolveDefaultIntlConfigPath } from "./locale_file_plugin.js";
+export { lucideOptimizerPlugin, detectLucideReact, resolveLucideEsmEntry, parseLucideIconMap, transformLucideImports, transformNextJsImports, } from "./lucide_optimizer_plugin.js";
 export { cloudflareNextIntl, cloudflareNextIntlPlugin, default } from "./plugin.js";
 export { imageOptimizer, imageOptimizerPlugin, VIRTUAL_IMAGE_SHIM_ID, } from "../image_optimizer/index.js";

package/dist/src/vite/lucide_optimizer_plugin.d.ts

@@ -0,0 +1,21 @@
+import type { Plugin } from "vite";
+export interface LucideOptimizerPluginOptions {
+    root?: string;
+    normalizeNextJsImports?: boolean;
+    lucideEntryPath?: string;
+}
+export declare const JS_EXT_RE: RegExp;
+export declare const LUCIDE_IMPORT_RE: RegExp;
+export declare const NEXT_JS_IMPORT_RE: RegExp;
+export declare function detectLucideReact(root: string): boolean;
+export declare function resolveLucideEsmEntry(root: string): string | null;
+export declare function parseLucideIconMap(esmEntryPath: string): Map<string, string>;
+export declare function transformLucideImports(code: string, iconMap: Map<string, string>): {
+    code: string;
+    changed: boolean;
+};
+export declare function transformNextJsImports(code: string): {
+    code: string;
+    changed: boolean;
+};
+export declare function lucideOptimizerPlugin(options?: LucideOptimizerPluginOptions): Plugin;

package/dist/src/vite/lucide_optimizer_plugin.js

@@ -0,0 +1,190 @@
+import fs from "node:fs";
+import path from "node:path";
+import { createRequire } from "node:module";
+export const JS_EXT_RE = /\.[cm]?[jt]sx?$/;
+export const LUCIDE_IMPORT_RE = /import\s+(?:type\s+)?\{([^}]+)\}\s+from\s*['"]lucide-react['"];?/g;
+export const NEXT_JS_IMPORT_RE = /(['"])next\/([a-zA-Z0-9_-]+)\.js\1/g;
+export function detectLucideReact(root) {
+    try {
+        const req = createRequire(path.join(root, "package.json"));
+        req.resolve("lucide-react");
+        return true;
+    }
+    catch {
+        return fs.existsSync(path.join(root, "node_modules", "lucide-react"));
+    }
+}
+export function resolveLucideEsmEntry(root) {
+    try {
+        const req = createRequire(path.join(root, "package.json"));
+        const pkgJsonPath = req.resolve("lucide-react/package.json");
+        const dir = path.dirname(pkgJsonPath);
+        const esm = path.join(dir, "dist", "esm", "lucide-react.mjs");
+        if (fs.existsSync(esm))
+            return esm;
+    }
+    catch {
+        const fallback = path.join(root, "node_modules", "lucide-react", "dist", "esm", "lucide-react.mjs");
+        if (fs.existsSync(fallback))
+            return fallback;
+    }
+    return null;
+}
+export function parseLucideIconMap(esmEntryPath) {
+    const iconMap = new Map();
+    try {
+        const content = fs.readFileSync(esmEntryPath, "utf8");
+        const exportRegex = /export\s*\{\s*([^}]+)\s*\}\s*from\s*['"](\.\/icons\/[^'"]+)['"];/g;
+        let match;
+        while ((match = exportRegex.exec(content)) !== null) {
+            const [, specifiers, file] = match;
+            const normalizedFile = file.replace(/^\.\//, "lucide-react/dist/esm/");
+            for (const part of specifiers.split(",")) {
+                const m = part.trim().match(/(?:(\w+)\s+as\s+)?(\w+)$/);
+                if (m)
+                    iconMap.set(m[2], normalizedFile);
+            }
+        }
+        iconMap.set("LucideProvider", "lucide-react/dist/esm/context.mjs");
+        iconMap.set("useLucideContext", "lucide-react/dist/esm/context.mjs");
+    }
+    catch {
+    }
+    return iconMap;
+}
+export function transformLucideImports(code, iconMap) {
+    if (!code.includes("lucide-react") || iconMap.size === 0) {
+        return { code, changed: false };
+    }
+    let changed = false;
+    const replaced = code.replace(new RegExp(LUCIDE_IMPORT_RE), (_match, specifiersStr) => {
+        const clean = specifiersStr
+            .replace(/\/\/[^\n]*/g, "")
+            .replace(/\/\*[\s\S]*?\*\//g, "");
+        const parts = clean
+            .split(",")
+            .map((s) => s.trim())
+            .filter(Boolean);
+        const newImports = [];
+        const remaining = [];
+        for (const part of parts) {
+            if (part.startsWith("type ")) {
+                remaining.push(part);
+                continue;
+            }
+            const m = part.match(/^(\w+)(?:\s+as\s+(\w+))?$/);
+            if (m) {
+                const [, imported, local] = m;
+                const iconPath = iconMap.get(imported);
+                if (iconPath) {
+                    newImports.push(`import ${local || imported} from "${iconPath}";`);
+                    continue;
+                }
+            }
+            remaining.push(part);
+        }
+        if (remaining.length > 0) {
+            newImports.push(`import { ${remaining.join(", ")} } from "lucide-react";`);
+        }
+        return newImports.join("\n");
+    });
+    if (replaced !== code) {
+        changed = true;
+    }
+    return { code: replaced, changed };
+}
+export function transformNextJsImports(code) {
+    if (!code.includes("next/") || !code.includes(".js")) {
+        return { code, changed: false };
+    }
+    const replaced = code.replace(new RegExp(NEXT_JS_IMPORT_RE), "$1next/$2$1");
+    return { code: replaced, changed: replaced !== code };
+}
+export function lucideOptimizerPlugin(options = {}) {
+    let resolvedRoot = options.root ?? process.cwd();
+    let isLucidePresent = false;
+    let iconMap = new Map();
+    const normalizeNext = options.normalizeNextJsImports ?? true;
+    return {
+        name: "cloudflare-next-intl-lucide-optimizer",
+        enforce: "pre",
+        config(config) {
+            const root = config.root || resolvedRoot;
+            resolvedRoot = root;
+            isLucidePresent = detectLucideReact(root);
+            if (isLucidePresent) {
+                const entry = options.lucideEntryPath ?? resolveLucideEsmEntry(root);
+                if (entry) {
+                    iconMap = parseLucideIconMap(entry);
+                }
+            }
+            const vinextHeadersShim = path.join(root, "node_modules", "vinext", "dist", "shims", "headers.js");
+            const hasVinextHeaders = fs.existsSync(vinextHeadersShim);
+            const aliasEntries = [];
+            if (hasVinextHeaders) {
+                aliasEntries.push({
+                    find: /^next\/headers(\.js)?$/,
+                    replacement: vinextHeadersShim,
+                });
+            }
+            if (normalizeNext) {
+                aliasEntries.push({
+                    find: /^next\/(.+)\.js$/,
+                    replacement: "next/$1",
+                });
+            }
+            return {
+                resolve: {
+                    alias: aliasEntries,
+                },
+                optimizeDeps: {
+                    include: [
+                        "next/dynamic",
+                        "next/link",
+                        "next/navigation",
+                        "next/image",
+                    ],
+                    exclude: [
+                        "next/server",
+                        "next/headers",
+                        ...(isLucidePresent ? ["lucide-react"] : []),
+                    ],
+                },
+            };
+        },
+        configResolved(config) {
+            if (config.root) {
+                resolvedRoot = config.root;
+            }
+        },
+        transform(code, id) {
+            const cleanId = id.split("?")[0];
+            if (!JS_EXT_RE.test(cleanId) || cleanId.includes("node_modules/lucide-react")) {
+                return null;
+            }
+            if (cleanId.includes("node_modules") && !cleanId.includes("cloudflare-next-intl")) {
+                return null;
+            }
+            let transformed = code;
+            let hasChange = false;
+            if (isLucidePresent && iconMap.size > 0) {
+                const res = transformLucideImports(transformed, iconMap);
+                if (res.changed) {
+                    transformed = res.code;
+                    hasChange = true;
+                }
+            }
+            if (normalizeNext) {
+                const res = transformNextJsImports(transformed);
+                if (res.changed) {
+                    transformed = res.code;
+                    hasChange = true;
+                }
+            }
+            if (!hasChange) {
+                return null;
+            }
+            return { code: transformed, map: null };
+        },
+    };
+}

package/dist/src/vite/plugin.d.ts

@@ -2,8 +2,11 @@ import type { Plugin } from "vite";
 import { type LocaleFilePluginOptions } from "./locale_file_plugin.js";
 import { type ImageOptimizerPluginOptions } from "../image_optimizer/index.js";
 import { type AutoDynamicPagesPluginOptions } from "./auto_dynamic_pages_plugin.js";
+import { type AutoLocaleParamsPluginOptions } from "./auto_locale_params_plugin.js";
 import { type VinextRouteWiringFixPluginOptions } from "./vinext_route_wiring_fix.js";
+import { type LucideOptimizerPluginOptions } from "./lucide_optimizer_plugin.js";
 export interface CloudflareNextIntlOptions extends LocaleFilePluginOptions {
+    lucideOptimizer?: boolean | LucideOptimizerPluginOptions;
     autoDynamicPages?: boolean | AutoDynamicPagesPluginOptions;
     buildIdAsset?: boolean | string;
     localeFiles?: boolean;
@@ -11,6 +14,7 @@ export interface CloudflareNextIntlOptions extends LocaleFilePluginOptions {
     cfWorkersClientStub?: boolean;
     imageOptimizer?: boolean | ImageOptimizerPluginOptions;
     vinextRouteWiringFix?: boolean | VinextRouteWiringFixPluginOptions;
+    autoLocaleParams?: boolean | AutoLocaleParamsPluginOptions;
 }
 export declare function cloudflareNextIntl(options?: CloudflareNextIntlOptions): Plugin[];
 export declare const cloudflareNextIntlPlugin: typeof cloudflareNextIntl;

package/dist/src/vite/plugin.js

@@ -4,9 +4,21 @@ import { cfWorkersClientStubPlugin } from "./cf_workers_client_stub.js";
 import { localeFilePlugin } from "./locale_file_plugin.js";
 import { imageOptimizerPlugin } from "../image_optimizer/index.js";
 import { autoDynamicPagesPlugin } from "./auto_dynamic_pages_plugin.js";
+import { autoLocaleParamsPlugin } from "./auto_locale_params_plugin.js";
 import { vinextRouteWiringFixPlugin } from "./vinext_route_wiring_fix.js";
+import { lucideOptimizerPlugin } from "./lucide_optimizer_plugin.js";
 export function cloudflareNextIntl(options = {}) {
     const plugins = [];
+    if (options.lucideOptimizer !== false) {
+        plugins.push(lucideOptimizerPlugin(typeof options.lucideOptimizer === "object"
+            ? options.lucideOptimizer
+            : { root: options.root }));
+    }
+    if (options.autoLocaleParams !== false) {
+        plugins.push(autoLocaleParamsPlugin(typeof options.autoLocaleParams === "object"
+            ? options.autoLocaleParams
+            : undefined));
+    }
     if (options.autoDynamicPages !== false) {
         plugins.push(autoDynamicPagesPlugin(typeof options.autoDynamicPages === "object"
             ? options.autoDynamicPages

package/dist/src/vite/vinext_route_wiring_fix.js

@@ -1,6 +1,6 @@
 import { existsSync, readFileSync, writeFileSync, rmSync } from "node:fs";
 import { resolve } from "node:path";
-const PREFETCH_LOADING_FN_RE = /function\s+getPrefetchLoadingEntry\s*\(\s*route\s*\)\s*\{[\s\S]*?return\s+getDefaultExport\s*\(\s*route\.loading\s*\)\s*\?[\s\S]*?:\s*null\s*;\s*\}/;
+const PREFETCH_LOADING_FN_RE = /function\s+getPrefetchLoadingEntry\s*\(\s*route\s*\)\s*\{[\s\S]*?firstNestedEntry[\s\S]*?route\.loadings[\s\S]*?return\s+getDefaultExport\s*\(\s*route\.loading\s*\)\s*\?[\s\S]*?:\s*null\s*;\s*\}/;
 const FIXED_PREFETCH_LOADING_FN = `function getPrefetchLoadingEntry(route) {
 	let rootEntry = null;
 	let deepestNestedEntry = null;
@@ -29,7 +29,8 @@ const FIXED_PREFETCH_LOADING_FN = `function getPrefetchLoadingEntry(route) {
 const ROUTE_LOADING_GUARD_RE = /if\s*\(\s*!isPrefetchLoadingShell\s*&&\s*treePosition\s*<\s*routeSegments\.length\s*\)\s*\{/g;
 const FIXED_ROUTE_LOADING_GUARD = "if (!isPrefetchLoadingShell && treePosition < routeSegments.length && !routeLoadingComponent) {";
 export function isAppPageRouteWiringAlreadyFixed(code) {
-    const hasBuggyPrefetch = code.includes("firstNestedEntry") && PREFETCH_LOADING_FN_RE.test(code);
+    const hasBuggyPrefetch = code.includes("firstNestedEntry") &&
+        PREFETCH_LOADING_FN_RE.test(code);
     const hasBuggySuspense = !code.includes("!routeLoadingComponent") && ROUTE_LOADING_GUARD_RE.test(code);
     return !hasBuggyPrefetch && !hasBuggySuspense;
 }
@@ -38,8 +39,10 @@ export function patchAppPageRouteWiring(code) {
         return code;
     }
     let result = code;
-    const hasBuggyPrefetch = code.includes("firstNestedEntry") && PREFETCH_LOADING_FN_RE.test(code);
-    if (hasBuggyPrefetch && !result.includes("deepestNestedEntry")) {
+    const hasBuggyPrefetch = code.includes("firstNestedEntry") &&
+        !result.includes("deepestNestedEntry") &&
+        PREFETCH_LOADING_FN_RE.test(result);
+    if (hasBuggyPrefetch) {
         result = result.replace(PREFETCH_LOADING_FN_RE, FIXED_PREFETCH_LOADING_FN);
     }
     const hasBuggySuspense = !result.includes("!routeLoadingComponent") && ROUTE_LOADING_GUARD_RE.test(result);
@@ -53,13 +56,20 @@ export function isRouteMatchingFile(id) {
     return cleanId.endsWith("/routing/route-matching.js") || cleanId.endsWith("/routing/route-matching.ts");
 }
 export function isRouteMatchingAlreadyFixed(code) {
-    return code.includes("hasLeadingLocaleParam");
+    if (code.includes("hasLeadingLocaleParam")) {
+        return true;
+    }
+    const hasUpstreamLocaleMatch = code.includes(":locale") &&
+        (code.includes("activeLocale") || code.includes("getActiveRouteLocale") || code.includes("matchWithLocale") || code.includes("localeMatch")) &&
+        /function\s+matchRouteWithTrie[\s\S]*?:locale/.test(code);
+    return Boolean(hasUpstreamLocaleMatch);
 }
-const MATCH_ROUTE_WITH_TRIE_RE = /function\s+matchRouteWithTrie\s*\(\s*url\s*,\s*routes\s*,\s*cache\s*\)\s*\{[\s\S]*?return\s+trieMatch\([\s\S]*?\);\s*\}/;
-const FIXED_MATCH_ROUTE_WITH_TRIE = `function getActiveRouteLocale() {
+const GET_ACTIVE_ROUTE_LOCALE_FN = `function getActiveRouteLocale() {
 	return (typeof document !== "undefined" && (document.documentElement?.lang || document.cookie.match(/__user_locale_key__=([^;]+)/)?.[1])) || (typeof window !== "undefined" && window.__VINEXT_LOCALE__) || "en";
 }
-function matchRouteWithTrie(url, routes, cache) {
+`;
+const MATCH_ROUTE_WITH_TRIE_RE = /function\s+matchRouteWithTrie\s*\(\s*url\s*,\s*routes\s*,\s*cache\s*\)\s*\{[\s\S]*?normalizePathnameForRouteMatch[\s\S]*?getOrBuildTrie\(\s*cache\s*,\s*routes\s*\)\s*;?\s*\n\s*return\s+trieMatch\(\s*trie\s*,\s*urlParts\s*\)\s*;?\s*\}/;
+const FIXED_MATCH_ROUTE_WITH_TRIE_BODY = `function matchRouteWithTrie(url, routes, cache) {
 	const pathname = url.split("?")[0];
 	let normalizedUrl = pathname === "/" ? "/" : pathname.replace(/\\/$/, "");
 	normalizedUrl = normalizePathnameForRouteMatch(normalizedUrl);
@@ -75,7 +85,7 @@ function matchRouteWithTrie(url, routes, cache) {
 	}
 	return trieMatch(trie, urlParts);
 }`;
-const MATCH_ROUTE_WITH_TRIE_RAW_RE = /function\s+matchRouteWithTrieRawPathname\s*\(\s*url\s*,\s*routes\s*,\s*cache\s*\)\s*\{[\s\S]*?return\s+trieMatch\([\s\S]*?\);\s*\}/;
+const MATCH_ROUTE_WITH_TRIE_RAW_RE = /function\s+matchRouteWithTrieRawPathname\s*\(\s*url\s*,\s*routes\s*,\s*cache\s*\)\s*\{[\s\S]*?urlParts\s*=[\s\S]*?return\s+trieMatch\(\s*(?:trie|getOrBuildTrie\(\s*cache\s*,\s*routes\s*\))\s*,\s*urlParts\s*\)\s*;?\s*\}/;
 const FIXED_MATCH_ROUTE_WITH_TRIE_RAW = `function matchRouteWithTrieRawPathname(url, routes, cache) {
 	const pathname = url.split("?")[0];
 	const urlParts = (pathname === "/" ? "/" : pathname.replace(/\\/$/, "")).split("/").filter(Boolean);
@@ -95,11 +105,17 @@ export function patchRouteMatching(code) {
         return code;
     }
     let result = code;
-    if (MATCH_ROUTE_WITH_TRIE_RE.test(result)) {
-        result = result.replace(MATCH_ROUTE_WITH_TRIE_RE, FIXED_MATCH_ROUTE_WITH_TRIE);
+    if (!result.includes("hasLeadingLocaleParam") && MATCH_ROUTE_WITH_TRIE_RE.test(result)) {
+        const replacement = result.includes("function getActiveRouteLocale")
+            ? FIXED_MATCH_ROUTE_WITH_TRIE_BODY
+            : `${GET_ACTIVE_ROUTE_LOCALE_FN}${FIXED_MATCH_ROUTE_WITH_TRIE_BODY}`;
+        result = result.replace(MATCH_ROUTE_WITH_TRIE_RE, replacement);
     }
-    if (MATCH_ROUTE_WITH_TRIE_RAW_RE.test(result)) {
-        result = result.replace(MATCH_ROUTE_WITH_TRIE_RAW_RE, FIXED_MATCH_ROUTE_WITH_TRIE_RAW);
+    if (!result.includes("hasLeadingLocaleParam") && MATCH_ROUTE_WITH_TRIE_RAW_RE.test(result)) {
+        const replacement = result.includes("function getActiveRouteLocale")
+            ? FIXED_MATCH_ROUTE_WITH_TRIE_RAW
+            : `${GET_ACTIVE_ROUTE_LOCALE_FN}${FIXED_MATCH_ROUTE_WITH_TRIE_RAW}`;
+        result = result.replace(MATCH_ROUTE_WITH_TRIE_RAW_RE, replacement);
     }
     return result;
 }
@@ -111,13 +127,17 @@ export function isOptimisticRoutingAlreadyFixed(code) {
     const hasLocalePrefixFirst = code.includes("hasLeadingLocaleParam") &&
         code.indexOf("hasLeadingLocaleParam") < code.indexOf("const match = matchNode(trie, urlParts.normalized");
     const hasRawPartsFix = code.includes("options.rawUrlParts[0] !== options.match.params.locale");
-    return hasLocalePrefixFirst && hasRawPartsFix;
-}
-const MATCH_OPTIMISTIC_ROUTE_RE = /function\s+matchOptimisticRouteManifestRoute\s*\(\s*options\s*\)\s*\{[\s\S]*?getRouteTrie\([\s\S]*?\)[\s\S]*?\n\}/;
-const FIXED_MATCH_OPTIMISTIC_ROUTE = `function getActiveRouteLocale() {
-	return (typeof document !== "undefined" && (document.documentElement?.lang || document.cookie.match(/__user_locale_key__=([^;]+)/)?.[1])) || (typeof window !== "undefined" && window.__VINEXT_LOCALE__) || "en";
+    if (hasLocalePrefixFirst && hasRawPartsFix) {
+        return true;
+    }
+    const hasUpstreamLocaleMatch = code.includes(":locale") &&
+        (code.includes("activeLocale") || code.includes("getActiveRouteLocale") || code.includes("localeMatch")) &&
+        /function\s+matchOptimisticRouteManifestRoute[\s\S]*?:locale/.test(code);
+    const hasUpstreamRawPartsFix = /function\s+resolveOptimisticNavigationParams[\s\S]*?:locale/.test(code);
+    return Boolean(hasUpstreamLocaleMatch && hasUpstreamRawPartsFix);
 }
-function matchOptimisticRouteManifestRoute(options) {
+const MATCH_OPTIMISTIC_ROUTE_RE = /function\s+matchOptimisticRouteManifestRoute\s*\(\s*options\s*\)\s*\{[\s\S]*?hrefToRouteParts\(\s*options\.href\s*,\s*options\.basePath\s*\)[\s\S]*?matchNode\([\s\S]*?urlParts\.normalized\s*,\s*0\s*,\s*\[\]\)[\s\S]*?decodeMatchedParams\(\s*match\.params\s*\)[\s\S]*?\n\}/;
+const FIXED_MATCH_OPTIMISTIC_ROUTE_BODY = `function matchOptimisticRouteManifestRoute(options) {
 	const urlParts = hrefToRouteParts(options.href, options.basePath);
 	if (urlParts === null) return null;
 	const trie = getRouteTrie(options.routeManifest);
@@ -151,7 +171,10 @@ export function patchOptimisticRouting(code) {
     }
     let result = code;
     if (!result.includes("hasLeadingLocaleParam") && MATCH_OPTIMISTIC_ROUTE_RE.test(result)) {
-        result = result.replace(MATCH_OPTIMISTIC_ROUTE_RE, FIXED_MATCH_OPTIMISTIC_ROUTE);
+        const replacement = result.includes("function getActiveRouteLocale")
+            ? FIXED_MATCH_OPTIMISTIC_ROUTE_BODY
+            : `${GET_ACTIVE_ROUTE_LOCALE_FN}${FIXED_MATCH_OPTIMISTIC_ROUTE_BODY}`;
+        result = result.replace(MATCH_OPTIMISTIC_ROUTE_RE, replacement);
     }
     if (!result.includes("options.rawUrlParts[0] !== options.match.params.locale") && RESOLVE_OPTIMISTIC_NAV_PARAMS_RE.test(result)) {
         result = result.replace(RESOLVE_OPTIMISTIC_NAV_PARAMS_RE, FIXED_RESOLVE_OPTIMISTIC_NAV_PARAMS);
@@ -165,9 +188,16 @@ export function isPrefetchLearningFile(id) {
 export function isPrefetchLearningAlreadyFixed(code) {
     const hasFixedFunction = code.includes("stripRsc(parsePrefetchCacheKey(cacheKey).rscUrl)") && code.includes("hasOptimisticTemplate");
     const hasFixedCallSite = code.includes("targetHref: currentHref,") && code.includes("targetRscUrl: rscUrl,") && !LEARN_TEMPLATES_CALL_RE.test(code);
-    return hasFixedFunction && hasFixedCallSite;
+    if (hasFixedFunction && hasFixedCallSite) {
+        return true;
+    }
+    const hasBuggySkip = /if\s*\(\s*!isSettledPrefetchCacheEntry\(\s*entry\s*\)\s*\)\s*continue\s*;/.test(code);
+    if (!hasBuggySkip && code.includes("learnOptimisticRouteTemplatesFromPrefetchCache")) {
+        return true;
+    }
+    return false;
 }
-const LEARN_TEMPLATES_FN_RE = /async\s+function\s+learnOptimisticRouteTemplatesFromPrefetchCache\s*\(\s*options\s*\)\s*\{[\s\S]*?await\s+Promise\.allSettled\(\s*learning\s*\);\s*\}/;
+const LEARN_TEMPLATES_FN_RE = /async\s+function\s+learnOptimisticRouteTemplatesFromPrefetchCache\s*\(\s*options\s*\)\s*\{[\s\S]*?getPrefetchCache\(\)[\s\S]*?if\s*\(\s*!isSettledPrefetchCacheEntry\(\s*entry\s*\)\s*\)\s*continue\s*;[\s\S]*?learnOptimisticRouteTemplateFromPrefetch[\s\S]*?await\s+Promise\.allSettled\(\s*learning\s*\)\s*;?\s*\}/;
 const FIXED_LEARN_TEMPLATES_FN = `async function learnOptimisticRouteTemplatesFromPrefetchCache(options) {
 	if (options.routeManifest === null) return;
 	const hasOptimisticTemplate = options.targetHref !== void 0 && resolveOptimisticNavigationPayload({
@@ -241,10 +271,15 @@ export function patchPrefetchLearning(code) {
         return code;
     }
     let result = code;
-    if (!result.includes("hasOptimisticTemplate") && LEARN_TEMPLATES_FN_RE.test(result)) {
+    const hasBuggyFn = !result.includes("hasOptimisticTemplate") &&
+        !result.includes("isPendingNavigationTarget") &&
+        LEARN_TEMPLATES_FN_RE.test(result);
+    const hasFixedFunction = result.includes("stripRsc(parsePrefetchCacheKey(cacheKey).rscUrl)") &&
+        result.includes("hasOptimisticTemplate");
+    if (hasBuggyFn) {
         result = result.replace(LEARN_TEMPLATES_FN_RE, FIXED_LEARN_TEMPLATES_FN);
     }
-    if (LEARN_TEMPLATES_CALL_RE.test(result)) {
+    if ((hasBuggyFn || hasFixedFunction) && LEARN_TEMPLATES_CALL_RE.test(result)) {
         result = result.replace(LEARN_TEMPLATES_CALL_RE, FIXED_LEARN_TEMPLATES_CALL);
     }
     return result;
@@ -386,6 +421,9 @@ export function vinextRouteWiringFixPlugin(options = {}) {
                     return;
                 }
                 const patched = patchAppPageRouteWiring(code);
+                if (patched === code) {
+                    return;
+                }
                 return {
                     code: patched,
                     map: null,
@@ -396,6 +434,9 @@ export function vinextRouteWiringFixPlugin(options = {}) {
                     return;
                 }
                 const patched = patchRouteMatching(code);
+                if (patched === code) {
+                    return;
+                }
                 return {
                     code: patched,
                     map: null,
@@ -406,6 +447,9 @@ export function vinextRouteWiringFixPlugin(options = {}) {
                     return;
                 }
                 const patched = patchPrefetchLearning(code);
+                if (patched === code) {
+                    return;
+                }
                 return {
                     code: patched,
                     map: null,
@@ -416,6 +460,9 @@ export function vinextRouteWiringFixPlugin(options = {}) {
                     return;
                 }
                 const patched = patchOptimisticRouting(code);
+                if (patched === code) {
+                    return;
+                }
                 return {
                     code: patched,
                     map: null,

package/llms.txt

@@ -27,7 +27,9 @@ other subpath can be used.
 - `./db` — `withPublicDb(fn)` / `withUserDb(fn, uid?)` server-side Postgres/Drizzle context helpers (require `db` set on your `RoutingConfig`; direct Postgres or Supabase Data API with automatic PostgREST REST translation and `cfni_exec` fallback, see below).
 - `./dbEslint` — flat-config ESLint fragment banning direct `@supabase/supabase-js`, `pg`, `postgres`, and deep `dist/` imports in application code.
 - `./dbHelpers` — generic Drizzle SQL helper functions (`excluded`, `onConflictSet`, `ago`, `currentDate`, `windowCount`, `unnestLateral`, `ascNullsLast`, `alwaysTrue`, `lateral`, `aliasColumn`, `minOf`, `maxOf`, `roundReal`, `multiply`, `scalarFromCte`) for use with `./db`.
-- `./vite` — `cloudflareNextIntl(options?)` / `cloudflareNextIntlPlugin`, `imageOptimizerPlugin(options?)` / `imageOptimizer`, `buildIdAsset(fileName?)`, `localeFilePlugin(options?)`, `userAgentStubPlugin()`, `cfWorkersClientStubPlugin()`, `vinextRouteWiringFixPlugin(options?)`: All-in-one Vite plugin required for Vinext/Cloudflare Workers environments (bundles `@locale-file/*` via eager glob, resolves `@intl-config`, stubs Node.js `user-agent` to prevent runtime `node:fs` errors, stubs `cloudflare:workers` for client builds, emits client `BUILD_ID`, runs build-time/dev Image Optimizer with Next.js blur placeholder shimming, and fixes vinext route wiring, matching, and non-blocking optimistic prefetch learning).
+- `./vite` — `cloudflareNextIntl(options?)` / `cloudflareNextIntlPlugin`, `imageOptimizerPlugin(options?)` / `imageOptimizer`, `autoLocaleParamsPlugin(options?)`, `buildIdAsset(fileName?)`, `localeFilePlugin(options?)`, `userAgentStubPlugin()`, `cfWorkersClientStubPlugin()`, `vinextRouteWiringFixPlugin(options?)`, `lucideOptimizerPlugin(options?)`: All-in-one Vite plugin required for Vinext/Cloudflare Workers environments (bundles `@locale-file/*` via eager glob, resolves `@intl-config`, stubs Node.js `user-agent` to prevent runtime `node:fs` errors, stubs `cloudflare:workers` for client builds, emits client `BUILD_ID`, runs build-time/dev Image Optimizer with Next.js blur placeholder shimming, fixes vinext route wiring/matching/non-blocking optimistic prefetch learning, auto-inserts locale params for pages reading locale from cookies, and rewrites `lucide-react` imports to deep icon paths). Also wraps `checkDynamicPages`/`checkLocaleParams` (see `./checkDynamicPages` / `./checkLocaleParams`), running `autoLocaleParams` before `autoDynamicPages` so a page whose locale param this fixes no longer trips the cookie-derived-locale dynamic signal.
+- `./checkDynamicPages` — `checkDynamicPages(options, io?)`: standalone SSG-eligibility scanner/fixer for `page`/`route` files (text-heuristic, transitive local-import following, capped/cycle-safe). Modes `"off" | "report" | "fix"`. Also usable as the `cfni-check-dynamic-pages` CLI bin.
+- `./checkLocaleParams` — `checkLocaleParams(options, io?)`: standalone scanner/fixer for `page`/`layout`/`loading` files under a `[locale]`-scoped route that call `getTranslations()`/`useTranslations()` without a `locale` param or `setLocale()` call (the source of a hidden cookie-derived-locale dependency). Modes `"off" | "report" | "fix"`; options include `appDir`, `localeParam` (default `"locale"`), `skip`, `overrides`. Also usable as the `cfni-check-locale-params` CLI bin.
 - `./image-optimizer` / `./imageOptimizer` — image optimization suite: `imageOptimizerPlugin`, `imageOptimizer`, `resolveOptions`, `resolveImageConfig`, `resolveBlurOptions`, `processImage`, `makeBlurDataURL`, `getImageBlurSvg`, `renderManifest`, `writeManifest`, `isFresh`, `loadCache`, `saveCache`, `collectImages`, `run`.
 - `./errorHandling` — error reporting & stale deploy recovery barrel: `reportError`, `withErrorHandling`, `installConsoleErrorOverride`, `installGlobalErrorOverride`, `stringifyUnknown`, `formatErrorMessage`, `defaultIgnoredConsoleErrors`, `createServerErrorAction`, `isStaleDeployError`, `defaultStaleDeployPatterns`, `setStaleDeployPatterns`, `getStaleDeployPatterns`, `clearClientCache`, `useStaleDeployRecovery`, `shouldRecoverFromStaleDeploy`, `isRecentBuild`.
 - `./isStaleDeployError` — `isStaleDeployError(error, patterns?)`, `setStaleDeployPatterns(patterns)`, `getStaleDeployPatterns()`: detector returning `true` for version skew / chunk load / dynamic import / server action 404 / hydration errors (ChunkLoadError, UnrecognizedActionError, server action not found, failed to fetch, dynamically imported module failure, loading CSS chunk, connection closed, RSC payload failure, minified error #412, or missing stream error `undefined`) with fast pre-lowercased pattern cache and intl-config integration (`errorHandling.staleDeployPatterns`).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cloudflare-next-intl",
-  "version": "0.9.47",
+  "version": "0.9.49",
   "description": "Optimized Next Intl Package Special for App Router and Cloudflare",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -11,7 +11,8 @@
     "cfni-db-install-exec": "bin/db_install_exec.mjs",
     "cfni-image-optimizer": "bin/image_optimizer.mjs",
     "optimize-images": "bin/image_optimizer.mjs",
-    "cfni-check-dynamic-pages": "bin/check_dynamic_pages.mjs"
+    "cfni-check-dynamic-pages": "bin/check_dynamic_pages.mjs",
+    "cfni-check-locale-params": "bin/check_locale_params.mjs"
   },
   "files": [
     "dist",
@@ -238,6 +239,10 @@
       "types": "./dist/src/dynamic_pages_check/index.d.ts",
       "import": "./dist/src/dynamic_pages_check/index.js"
     },
+    "./checkLocaleParams": {
+      "types": "./dist/src/locale_params_check/index.d.ts",
+      "import": "./dist/src/locale_params_check/index.js"
+    },
     "./db": {
       "types": "./dist/src/db/index.d.ts",
       "import": "./dist/src/db/index.js"