cloudflare-next-intl 0.9.47 → 0.9.48

package/README.md

@@ -261,12 +261,14 @@ export default defineConfig({
    The scan (`checkDynamicPages`, also usable standalone from `cloudflare-next-intl/checkDynamicPages`) is a text heuristic, not a real parser, so it's deliberately conservative and follows a page's own local (relative/`@/`-alias) imports transitively — cycle-safe, capped at 300 files — so a signal several files away (a component's repository calling `cookies()`) still marks the page dynamic, not just literal text in the page file itself. A locally-imported file that opens with a `"use server"` directive is never opened by the scan (its exports are Server Actions, invoked only on explicit call — never merely by being imported), the same treatment a bare npm-package import already gets. Recognized signals: `cookies()`, `headers()`, `searchParams`, `unstable_noStore()`, `connection()`, `cache: "no-store"`, `next: { revalidate: 0 }`, and this package's own `getAuthUser()`/`useAuthUser()`/`withUserDb()` (each of which reads `cookies()` internally) — except a `useAuthUser()` call in a file that opens with `"use client"`, which is this package's client-side hook (a different export under the same name) and contributes no signal. Set `resolveImports: false` on `checkDynamicPages` to restore the original single-file-only scan, or pass `aliases` to override the default `@/` → `<appDir>/..` mapping.
 
    Being text-only and transitive, it can over-flag: any local file the page reaches — however many imports away — that merely *calls* a recognized signal counts, even along a branch that never runs in production (a `Config.isDev`-gated `fetch(..., { cache: "no-store" })`) or one that's optional/best-effort (a `try`/`catch`-wrapped `getAuthUser()` used only to tag a log line). It cannot see that a call is conditional or swallowed. For a page whose only reason for being flagged is that kind of optional read — attaching "whoever's signed in, if anyone" to an error report, analytics event, or log line — switch that read to `resolveOptionalAuthUser()` (`cloudflare-next-intl/resolveOptionalAuthUser`, see Firebase Auth below): it wraps `getAuthUser()` the same way but, being an npm-package import, is a boundary the scan doesn't open, so it contributes no signal. If that read lives in a shared `onError` sink used by many pages at once, `resolveErrorReportingUser(useAuthUser?)` (same subpath) is the more precise fix: it's off (`{ user: null }`, no `getAuthUser()` call) by default, and only a `reportError({ ..., useAuthUser: true })` call site that actually wants the user on that report opts in per-call — instead of every page reaching that sink getting flagged.
-2. **Build-Time Image Optimizer (`imageOptimizer`)**: Automatically scans your image directories (`public/images`, `public/icons`), downscales oversized assets, produces sibling formats (`webp` by default; also supports `avif`, `png`, `jpeg`, `gif`, `tiff`, `heif`, `jp2`, `jxl`), generates 8px `.blur.webp` thumbnails with Next.js-matching SVG Gaussian blur placeholders, and provides transparent `<Image placeholder="blur" />` shimming via virtual modules. When more than one format is generated for an image, the shim renders a `<picture>` with one `<source>` per format — ordered exactly as configured — so the browser picks the best format it supports, with the original untouched file as an `onError` fallback if a generated asset fails to load. When the same image is used at different widths across the codebase, each size gets its own generated variant, and each `<Image>` usage automatically resolves to the closest matching size. Runs on production build only by default (`dev: false`) — downscaling/format conversion is a build concern, and re-scanning on every dev server start slows cold starts for no dev-time benefit; the shim degrades cleanly with no manifest (plain, unoptimized `next/image` rendering, no blur placeholder). Pass `dev: true` to also run it in dev and preview real optimized output/blur.
-3. **Locale File Bundling & Resolution (`localeFiles`)**: Resolves `@locale-file/*` to your `./messages` directory and transforms dynamic imports into `import.meta.glob('/messages/*.json', { eager: true })` for lightning-fast locale loading on Cloudflare Workers.
-4. **User-Agent Stub (`userAgentStub`)**: Prevents Next.js `user-agent` from importing `node:fs` during workerd runtime execution (which otherwise causes runtime 404 / 500 crashes in Workers proxy/middleware).
-5. **Cloudflare Workers Client Stub (`cfWorkersClientStub`)**: Stubs `cloudflare:workers` in client builds so shared modules can be referenced without client bundling errors.
-6. **Build ID Asset Emission (`buildIdAsset`)**: Emits `BUILD_ID` static asset in the client build directory from `process.env.__VINEXT_SHARED_BUILD_ID` or `process.env.__VINEXT_BUILD_ID`.
-7. **Vinext Route Wiring & Optimistic Prefetch Fix (`vinextRouteWiringFix`)**: Patches Vinext runtime route wiring, route matching, optimistic route template resolution, and prefetch learning so pending prefetches with already cached templates don't block navigation, and leading `:locale` segments route correctly.
+2. **Auto Locale Params for Static Pages (`autoLocaleParams`)**: Automatically scans `page`/`layout`/`loading` files under a `[locale]`-scoped route during `configResolved` and inserts the `locale` param from `params` plus a `setLocale(locale)` call wherever `getTranslations()`/`useTranslations()` is used without one — the common cause of a page reading `NEXT_LOCALE` from cookies (and so implicitly becoming request-dependent) even though it never calls `cookies()` itself. Runs before `autoDynamicPages` so a page fixed this way no longer trips the cookie-derived-locale signal below. The scan (`checkLocaleParams`, also usable standalone from `cloudflare-next-intl/checkLocaleParams`, or via the `cfni-check-locale-params` CLI bin) is a text heuristic like `checkDynamicPages`; pass `mode: "report"` to only log without editing files, or `skip`/`overrides`/`localeParam` to fine-tune per-file.
+4. **Build-Time Image Optimizer (`imageOptimizer`)**: Automatically scans your image directories (`public/images`, `public/icons`), downscales oversized assets, produces sibling formats (`webp` by default; also supports `avif`, `png`, `jpeg`, `gif`, `tiff`, `heif`, `jp2`, `jxl`), generates 8px `.blur.webp` thumbnails with Next.js-matching SVG Gaussian blur placeholders, and provides transparent `<Image placeholder="blur" />` shimming via virtual modules. When more than one format is generated for an image, the shim renders a `<picture>` with one `<source>` per format — ordered exactly as configured — so the browser picks the best format it supports, with the original untouched file as an `onError` fallback if a generated asset fails to load. When the same image is used at different widths across the codebase, each size gets its own generated variant, and each `<Image>` usage automatically resolves to the closest matching size. Runs on production build only by default (`dev: false`) — downscaling/format conversion is a build concern, and re-scanning on every dev server start slows cold starts for no dev-time benefit; the shim degrades cleanly with no manifest (plain, unoptimized `next/image` rendering, no blur placeholder). Pass `dev: true` to also run it in dev and preview real optimized output/blur.
+5. **Locale File Bundling & Resolution (`localeFiles`)**: Resolves `@locale-file/*` to your `./messages` directory and transforms dynamic imports into `import.meta.glob('/messages/*.json', { eager: true })` for lightning-fast locale loading on Cloudflare Workers.
+6. **User-Agent Stub (`userAgentStub`)**: Prevents Next.js `user-agent` from importing `node:fs` during workerd runtime execution (which otherwise causes runtime 404 / 500 crashes in Workers proxy/middleware).
+7. **Cloudflare Workers Client Stub (`cfWorkersClientStub`)**: Stubs `cloudflare:workers` in client builds so shared modules can be referenced without client bundling errors.
+8. **Build ID Asset Emission (`buildIdAsset`)**: Emits `BUILD_ID` static asset in the client build directory from `process.env.__VINEXT_SHARED_BUILD_ID` or `process.env.__VINEXT_BUILD_ID`.
+9. **Vinext Route Wiring & Optimistic Prefetch Fix (`vinextRouteWiringFix`)**: Patches Vinext runtime route wiring, route matching, optimistic route template resolution, and prefetch learning so pending prefetches with already cached templates don't block navigation, and leading `:locale` segments route correctly.
+10. **Lucide & Next.js Specifier Optimizer (`lucideOptimizer`)**: Auto-detects `lucide-react` in project dependencies, rewrites named imports to direct deep icon paths (`lucide-react/dist/esm/icons/<icon>.mjs`) to avoid browser socket exhaustion (`ERR_INSUFFICIENT_RESOURCES`), and normalizes Next.js `.js` specifiers (`next/dynamic.js` -> `next/dynamic`) to prevent mid-session Vite re-optimization and React dispatcher splitting.
 
 ##### Plugin Options
 All features are enabled by default, and can be individually configured or toggled off:
@@ -292,6 +294,11 @@ export default defineConfig({
                     "/images/logo.png": { formats: false, blur: false },
                 },
             },
+            autoLocaleParams: {                   // Auto-insert locale params/setLocale (or `false` to disable)
+                mode: "fix",                       // "fix" | "report" | "off" (default: "fix")
+                localeParam: "locale",             // Route param name to read (default: "locale")
+                skip: ["src/app/[locale]/(marketing)/**"], // Glob(s) to exclude from the scan
+            },
             messagesDir: "./messages",            // Path to locale JSON files (default: './messages')
             intlConfigPath: "./src/l18n/intl_config.ts", // Path to intl config (auto-detected if omitted)
             buildIdAsset: true,                   // Emit BUILD_ID asset (or custom string filename, default: true)
@@ -299,13 +306,14 @@ export default defineConfig({
             userAgentStub: true,                  // Enable regex-based user-agent stub (default: true)
             cfWorkersClientStub: true,            // Enable client cloudflare:workers stub (default: true)
             vinextRouteWiringFix: true,           // Enable vinext route wiring, matching, and prefetch fixes (default: true, or options object)
+            lucideOptimizer: true,                // Auto-optimize lucide-react deep imports and normalize next/*.js (default: true, or options object)
         }),
     ],
 });
 ```
 
 Individual standalone plugins are also exported if you only need a specific feature:
-`imageOptimizerPlugin` (or `imageOptimizer`), `buildIdAsset`, `localeFilePlugin`, `userAgentStubPlugin`, `cfWorkersClientStubPlugin`, `vinextRouteWiringFixPlugin`.
+`imageOptimizerPlugin` (or `imageOptimizer`), `autoLocaleParamsPlugin`, `buildIdAsset`, `localeFilePlugin`, `userAgentStubPlugin`, `cfWorkersClientStubPlugin`, `vinextRouteWiringFixPlugin`, `lucideOptimizerPlugin`.
 
 ##### Per-Image Optimizer Settings
 

package/bin/check_locale_params.mjs

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+// Usage: cfni-check-locale-params [--app-dir=src/app] [--mode=off|report|fix] [--locale-param=locale] [--skip=a/page.tsx,b/page.tsx] [--verbose]
+// Env equivalents: CFNI_LOCALE_PARAMS_APP_DIR, CFNI_LOCALE_PARAMS_MODE, CFNI_LOCALE_PARAMS_LOCALE_PARAM, CFNI_LOCALE_PARAMS_SKIP (comma-separated), CFNI_LOCALE_PARAMS_VERBOSE.
+import { resolve } from 'node:path';
+import { checkLocaleParams } from '../dist/src/locale_params_check/check_locale_params.js';
+
+function argValue(name) {
+    const prefix = `--${name}=`;
+    const arg = process.argv.slice(2).find((a) => a.startsWith(prefix));
+    return arg ? arg.slice(prefix.length) : undefined;
+}
+
+const appDir = resolve(argValue('app-dir') ?? process.env.CFNI_LOCALE_PARAMS_APP_DIR ?? 'src/app');
+const mode = argValue('mode') ?? process.env.CFNI_LOCALE_PARAMS_MODE ?? 'report';
+const localeParam = argValue('locale-param') ?? process.env.CFNI_LOCALE_PARAMS_LOCALE_PARAM ?? 'locale';
+const skipRaw = argValue('skip') ?? process.env.CFNI_LOCALE_PARAMS_SKIP ?? '';
+const skip = skipRaw.split(',').map((s) => s.trim()).filter(Boolean).map((s) => resolve(s));
+const verbose = process.argv.includes('--verbose') || process.env.CFNI_LOCALE_PARAMS_VERBOSE === 'true';
+
+const reports = await checkLocaleParams({ appDir, mode, localeParam, skip, verbose });
+
+if (reports.length === 0) {
+    console.log(mode === 'off' ? 'checkLocaleParams: disabled (mode=off).' : `checkLocaleParams: no [${localeParam}]-scoped page/layout/loading files found under ${appDir}.`);
+} else if (!verbose) {
+    for (const { file, action } of reports) console.log(`${action.padEnd(24)} ${file}`);
+}

package/dist/src/dynamic_pages_check/check_dynamic_pages.js

@@ -51,6 +51,10 @@ function displayPath(file) {
     const rel = relative(process.cwd(), file);
     return rel === '' || rel.startsWith('..') ? file : rel;
 }
+function fileKind(file) {
+    const match = /([a-z]+)\.(?:tsx|ts|jsx|js)$/.exec(file);
+    return match ? match[1] : file;
+}
 function logReports(reports, appDir, pageLabel) {
     console.log(`[cloudflare-next-intl] dynamic-pages check\n${LEGEND}\n`);
     reports.forEach((report, index) => {
@@ -58,8 +62,9 @@ function logReports(reports, appDir, pageLabel) {
         const branch = isLast ? '└' : '├';
         const isApi = isApiRoute(report.file);
         const glyph = actionGlyph(report, isApi);
-        const route = deriveRoute(appDir, report.file);
-        console.log(`${branch} ${glyph} ${route}  ${pageLabel(report.file)}  — ${actionDetail(report, isApi)}`);
+        const kind = fileKind(report.file);
+        const route = deriveRoute(appDir, report.file) + (kind === 'page' || kind === 'route' ? '' : `/${kind}`);
+        console.log(`${branch} ${glyph} ${route}  ${pageLabel(report.file)} [${kind}]  — ${actionDetail(report, isApi)}`);
         const continuation = isLast ? ' ' : '│';
         for (const signal of report.signals ?? []) {
             const location = `${displayPath(signal.file)}:${signal.line}`;

package/dist/src/dynamic_pages_check/detect_dynamic_usage.js

@@ -41,6 +41,8 @@ const DYNAMIC_API_CHECKS = [
     { name: 'withUserDb()', pattern: /\bwithUserDb\s*\(/ },
 ];
 const USE_AUTH_USER_CALL = /\buseAuthUser\s*\(/;
+const TRANSLATIONS_CALL_NO_LOCALE = /\b(?:getTranslations|useTranslations)\s*\(\s*(?:['"][^'"]*['"]|[A-Za-z_$][\w$]*)\s*\)/;
+const SET_LOCALE_CALL = /\bsetLocale(?:Async)?\s*\(/;
 export const USE_CLIENT_DIRECTIVE = /^(?:\s*['"]use \w[\w-]*['"]\s*;?\s*)*['"]use client['"]\s*;?/;
 const EXPLICIT_DYNAMIC_EXPORT = /export\s+const\s+dynamic\s*=/;
 export function detectDynamicUsage(sourceText, extraChecks = []) {
@@ -57,6 +59,11 @@ export function detectDynamicUsage(sourceText, extraChecks = []) {
         if (found !== null)
             matches.push({ name: 'useAuthUser()', line: lineOf(sourceText, found.index) });
     }
+    if (!SET_LOCALE_CALL.test(code)) {
+        const found = TRANSLATIONS_CALL_NO_LOCALE.exec(code);
+        if (found !== null)
+            matches.push({ name: 'getTranslations()/useTranslations() (cookie-derived locale)', line: lineOf(sourceText, found.index) });
+    }
     return {
         hasExplicitDynamicExport: EXPLICIT_DYNAMIC_EXPORT.test(code),
         detectedDynamicApis: matches.map((m) => m.name),

package/dist/src/dynamic_pages_check/find_page_files.js

@@ -1,6 +1,6 @@
 import { readdirSync } from 'node:fs';
 import { join } from 'node:path';
-const PAGE_FILE_NAMES = new Set(['page.tsx', 'page.ts', 'page.jsx', 'page.js', 'route.ts', 'route.js']);
+const PAGE_FILE_NAMES = new Set(['page.tsx', 'page.ts', 'page.jsx', 'page.js', 'route.ts', 'route.js', 'loading.tsx', 'loading.ts', 'loading.jsx', 'loading.js']);
 export function findPageFiles(appDir) {
     let entries;
     try {

package/dist/src/locale_params_check/check_locale_params.d.ts

@@ -0,0 +1,24 @@
+import { type PageLabelStyle } from '../dynamic_pages_check/derive_page_label.js';
+export type LocaleParamsCheckMode = 'off' | 'report' | 'fix';
+export interface CheckLocaleParamsOptions {
+    appDir: string;
+    mode?: LocaleParamsCheckMode;
+    localeParam?: string;
+    skip?: readonly string[];
+    overrides?: Readonly<Record<string, {
+        localeParam?: string;
+    }>>;
+    verbose?: boolean | {
+        pageLabel?: PageLabelStyle | ((file: string, appDir: string) => string);
+    };
+}
+export interface CheckLocaleParamsReport {
+    file: string;
+    action: 'added-locale-params' | 'would-add-locale-params' | 'already-set-up' | 'needs-manual-edit' | 'skipped';
+}
+export interface CheckLocaleParamsIo {
+    findLocaleScopedFiles?: (appDir: string, localeParam: string) => string[];
+    readFile?: (file: string) => string;
+    writeFile?: (file: string, contents: string) => void;
+}
+export declare function checkLocaleParams(options: CheckLocaleParamsOptions, io?: CheckLocaleParamsIo): Promise<CheckLocaleParamsReport[]>;

package/dist/src/locale_params_check/check_locale_params.js

@@ -0,0 +1,104 @@
+import { readFileSync, writeFileSync } from 'node:fs';
+import { relative } from 'node:path';
+import { detectLocaleParams } from './detect_locale_params.js';
+import { insertLocaleParamsSignature, insertLocaleParamsBody, ensureLocaleInParamsType, addParamsPropToExistingDestructure, ensureSetLocaleImport } from './insert_locale_params.js';
+import { findLocaleScopedFiles } from './find_locale_scoped_files.js';
+import { deriveRoute, makePageLabeler } from '../dynamic_pages_check/derive_page_label.js';
+const ZERO_ARG_DEFAULT_EXPORT = /export\s+default\s+(async\s+)?function\s+[A-Za-z_$][\w$]*\s*\(\s*\)/;
+const LEGEND = '✓ Set up   + Added   ? Needs manual edit   · Skipped';
+function actionGlyph(action) {
+    switch (action) {
+        case 'added-locale-params': return '+';
+        case 'would-add-locale-params': return '+';
+        case 'already-set-up': return '✓';
+        case 'needs-manual-edit': return '?';
+        case 'skipped': return '·';
+    }
+}
+function actionDetail(action) {
+    switch (action) {
+        case 'added-locale-params': return 'Missing locale-param setup — added it';
+        case 'would-add-locale-params': return 'Missing locale-param setup — would add it';
+        case 'already-set-up': return 'Already resolves locale from params (setLocaleAsync/setLocale)';
+        case 'needs-manual-edit': return 'Existing params shape not recognized — needs a manual edit';
+        case 'skipped': return 'Skipped — excluded from this scan';
+    }
+}
+function displayPath(file) {
+    const rel = relative(process.cwd(), file);
+    return rel === '' || rel.startsWith('..') ? file : rel;
+}
+function fileKind(file) {
+    const match = /([a-z]+)\.(?:tsx|ts|jsx|js)$/.exec(file);
+    return match ? match[1] : file;
+}
+function logReports(reports, appDir, pageLabel) {
+    console.log(`[cloudflare-next-intl] locale-params check\n${LEGEND}\n`);
+    reports.forEach((report, index) => {
+        const isLast = index === reports.length - 1;
+        const branch = isLast ? '└' : '├';
+        const kind = fileKind(report.file);
+        const route = deriveRoute(appDir, report.file) + (kind === 'page' || kind === 'route' ? '' : `/${kind}`);
+        console.log(`${branch} ${actionGlyph(report.action)} ${route}  ${pageLabel(report.file)} [${kind}]  — ${actionDetail(report.action)}`);
+    });
+}
+export async function checkLocaleParams(options, io = {}) {
+    const mode = options.mode ?? 'report';
+    if (mode === 'off')
+        return [];
+    const defaultLocaleParam = options.localeParam ?? 'locale';
+    const findFiles = io.findLocaleScopedFiles ?? findLocaleScopedFiles;
+    const readFile = io.readFile ?? ((file) => readFileSync(file, 'utf8'));
+    const writeFile = io.writeFile ?? ((file, contents) => writeFileSync(file, contents, 'utf8'));
+    const skipSet = new Set(options.skip ?? []);
+    const overrides = options.overrides ?? {};
+    const reports = [];
+    for (const file of findFiles(options.appDir, defaultLocaleParam)) {
+        if (skipSet.has(file)) {
+            reports.push({ file, action: 'skipped' });
+            continue;
+        }
+        const localeParam = overrides[file]?.localeParam ?? defaultLocaleParam;
+        const source = readFile(file);
+        const detection = detectLocaleParams(source, localeParam);
+        if (detection.hasLocaleParamSetup) {
+            reports.push({ file, action: 'already-set-up' });
+            continue;
+        }
+        const isZeroArg = ZERO_ARG_DEFAULT_EXPORT.test(source);
+        const canReuseExistingParams = detection.hasDestructuredParamsProp && !detection.hasConflictingLocaleBinding;
+        const canAddParamsKey = detection.hasDestructuredObjectWithoutParams && !detection.hasConflictingLocaleBinding;
+        if (!isZeroArg && !detection.hasInlineDestructure && !canReuseExistingParams && !canAddParamsKey) {
+            reports.push({ file, action: 'needs-manual-edit' });
+            continue;
+        }
+        if (mode === 'report') {
+            reports.push({ file, action: 'would-add-locale-params' });
+            continue;
+        }
+        let updated = source;
+        if (isZeroArg) {
+            updated = insertLocaleParamsSignature(updated, localeParam);
+        }
+        else if (canAddParamsKey) {
+            updated = addParamsPropToExistingDestructure(updated, localeParam);
+        }
+        else if (canReuseExistingParams && !detection.hasParamsType) {
+            updated = ensureLocaleInParamsType(updated, localeParam);
+        }
+        updated = insertLocaleParamsBody(updated, localeParam, detection.hasInlineDestructure);
+        if (updated === source) {
+            reports.push({ file, action: 'needs-manual-edit' });
+            continue;
+        }
+        updated = ensureSetLocaleImport(updated);
+        writeFile(file, updated);
+        reports.push({ file, action: 'added-locale-params' });
+    }
+    if (options.verbose) {
+        const pageLabelStyle = typeof options.verbose === 'object' ? options.verbose.pageLabel : undefined;
+        const pageLabel = makePageLabeler(options.appDir, pageLabelStyle, displayPath);
+        logReports(reports, options.appDir, pageLabel);
+    }
+    return reports;
+}

package/dist/src/locale_params_check/detect_locale_params.d.ts

@@ -0,0 +1,10 @@
+export interface LocaleParamsDetectionResult {
+    hasInlineDestructure: boolean;
+    hasSetLocaleCall: boolean;
+    hasLocaleParamSetup: boolean;
+    hasParamsType: boolean;
+    hasDestructuredParamsProp: boolean;
+    hasConflictingLocaleBinding: boolean;
+    hasDestructuredObjectWithoutParams: boolean;
+}
+export declare function detectLocaleParams(sourceText: string, localeParam: string): LocaleParamsDetectionResult;

package/dist/src/locale_params_check/detect_locale_params.js

@@ -0,0 +1,96 @@
+import { stripComments } from '../dynamic_pages_check/detect_dynamic_usage.js';
+const SET_LOCALE_ASYNC_CALL = /\bsetLocaleAsync\s*\(\s*params\s*\)/;
+const SET_LOCALE_CALL = /\bsetLocale(?:Cache)?\s*\(/;
+function inlineDestructureRegex(localeParam) {
+    return new RegExp(`\\{[^}]*\\b${localeParam}\\b[^}]*\\}\\s*=\\s*await\\s+params\\b`);
+}
+function paramsTypeRegex(localeParam) {
+    return new RegExp(`params\\s*:\\s*Promise<\\{[^}]*\\b${localeParam}\\b`);
+}
+const DESTRUCTURED_PARAMS_PROP = /export\s+default\s+(?:async\s+)?function\s+[A-Za-z_$][\w$]*\s*\(\s*\{[^}]*(?<![\w$:])params(?![\w$:])[^}]*\}/;
+const DEFAULT_EXPORT_FUNCTION_OPEN_PAREN = /export\s+default\s+(?:async\s+)?function\s+[A-Za-z_$][\w$]*\s*\(/;
+function findMatchingBraceEnd(code, openBraceIndex) {
+    let depth = 0;
+    for (let i = openBraceIndex; i < code.length; i++) {
+        if (code[i] === '{')
+            depth++;
+        else if (code[i] === '}') {
+            depth--;
+            if (depth === 0)
+                return i + 1;
+        }
+    }
+    return null;
+}
+function findDestructuredObjectWithInlineType(code) {
+    const openParenMatch = DEFAULT_EXPORT_FUNCTION_OPEN_PAREN.exec(code);
+    if (openParenMatch === null)
+        return null;
+    let i = openParenMatch.index + openParenMatch[0].length;
+    while (i < code.length && /\s/.test(code[i]))
+        i++;
+    if (code[i] !== '{')
+        return null;
+    const keysEnd = findMatchingBraceEnd(code, i);
+    if (keysEnd === null)
+        return null;
+    const keys = code.slice(i + 1, keysEnd - 1);
+    let j = keysEnd;
+    while (j < code.length && /\s/.test(code[j]))
+        j++;
+    if (code[j] !== ':')
+        return null;
+    j++;
+    while (j < code.length && /\s/.test(code[j]))
+        j++;
+    if (code[j] !== '{')
+        return null;
+    const typeEnd = findMatchingBraceEnd(code, j);
+    if (typeEnd === null)
+        return null;
+    const typeBody = code.slice(j + 1, typeEnd - 1);
+    return { keys, typeBody };
+}
+function declaredBindingNames(code) {
+    const names = new Set();
+    const declRegex = /\b(?:const|let|var)\s+([^=;]+)=/g;
+    let declMatch;
+    while ((declMatch = declRegex.exec(code)) !== null) {
+        const target = declMatch[1];
+        if (/^[A-Za-z_$][\w$]*\s*$/.test(target)) {
+            names.add(target.trim());
+            continue;
+        }
+        const braceMatch = /^\{([\s\S]*)\}\s*$/.exec(target.trim());
+        if (braceMatch === null)
+            continue;
+        for (const part of braceMatch[1].split(',')) {
+            const key = part.split(':')[0].trim();
+            if (/^[A-Za-z_$][\w$]*$/.test(key))
+                names.add(key);
+        }
+    }
+    return names;
+}
+export function detectLocaleParams(sourceText, localeParam) {
+    const code = stripComments(sourceText);
+    const hasSetLocaleAsync = SET_LOCALE_ASYNC_CALL.test(code);
+    const hasInlineDestructure = inlineDestructureRegex(localeParam).test(code);
+    const hasSetLocaleCall = hasSetLocaleAsync || SET_LOCALE_CALL.test(code);
+    const hasConflictingLocaleBinding = !hasInlineDestructure && declaredBindingNames(code).has(localeParam);
+    const hasDestructuredParamsProp = DESTRUCTURED_PARAMS_PROP.test(code);
+    const destructuredObject = findDestructuredObjectWithInlineType(code);
+    const hasAnyParamsKey = /(?<![\w$])params(?![\w$])/.test(destructuredObject?.keys ?? '');
+    const hasDestructuredObjectWithoutParams = !hasDestructuredParamsProp
+        && destructuredObject !== null
+        && !hasAnyParamsKey;
+    return {
+        hasInlineDestructure,
+        hasSetLocaleCall,
+        hasLocaleParamSetup: hasSetLocaleAsync || (hasInlineDestructure && hasSetLocaleCall),
+        hasParamsType: paramsTypeRegex(localeParam).test(code),
+        hasDestructuredParamsProp,
+        hasConflictingLocaleBinding,
+        hasDestructuredObjectWithoutParams,
+    };
+}

package/dist/src/locale_params_check/find_locale_scoped_files.d.ts

@@ -0,0 +1 @@
+export declare function findLocaleScopedFiles(appDir: string, localeParam: string): string[];

package/dist/src/locale_params_check/find_locale_scoped_files.js

@@ -0,0 +1,14 @@
+import { sep } from 'node:path';
+import { findPageFiles } from '../dynamic_pages_check/find_page_files.js';
+const LOCALE_SCOPED_FILE_NAMES = new Set([
+    'page.tsx', 'page.ts', 'page.jsx', 'page.js',
+    'layout.tsx', 'layout.ts', 'layout.jsx', 'layout.js',
+    'loading.tsx', 'loading.ts', 'loading.jsx', 'loading.js',
+]);
+export function findLocaleScopedFiles(appDir, localeParam) {
+    const prefix = `${appDir}${sep}[${localeParam}]${sep}`;
+    return findPageFiles(appDir).filter((file) => {
+        const name = file.slice(file.lastIndexOf(sep) + 1);
+        return LOCALE_SCOPED_FILE_NAMES.has(name) && file.startsWith(prefix);
+    });
+}

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

@@ -0,0 +1,4 @@
+export { checkLocaleParams, type LocaleParamsCheckMode, type CheckLocaleParamsOptions, type CheckLocaleParamsReport, type CheckLocaleParamsIo } from './check_locale_params.js';
+export { findLocaleScopedFiles } from './find_locale_scoped_files.js';
+export { detectLocaleParams, type LocaleParamsDetectionResult } from './detect_locale_params.js';
+export { insertLocaleParamsSignature, insertLocaleParamsBody, ensureLocaleInParamsType, addParamsPropToExistingDestructure, ensureSetLocaleImport } from './insert_locale_params.js';

package/dist/src/locale_params_check/index.js

@@ -0,0 +1,4 @@
+export { checkLocaleParams } from './check_locale_params.js';
+export { findLocaleScopedFiles } from './find_locale_scoped_files.js';
+export { detectLocaleParams } from './detect_locale_params.js';
+export { insertLocaleParamsSignature, insertLocaleParamsBody, ensureLocaleInParamsType, addParamsPropToExistingDestructure, ensureSetLocaleImport } from './insert_locale_params.js';

package/dist/src/locale_params_check/insert_locale_params.d.ts

@@ -0,0 +1,5 @@
+export declare function insertLocaleParamsSignature(sourceText: string, localeParam: string): string;
+export declare function addParamsPropToExistingDestructure(sourceText: string, localeParam: string): string;
+export declare function insertLocaleParamsBody(sourceText: string, localeParam: string, hasInlineDestructure: boolean): string;
+export declare function ensureLocaleInParamsType(sourceText: string, localeParam: string): string;
+export declare function ensureSetLocaleImport(sourceText: string): string;

package/dist/src/locale_params_check/insert_locale_params.js

@@ -0,0 +1,117 @@
+const ZERO_ARG_DEFAULT_EXPORT = /export\s+default\s+(?:async\s+)?function\s+[A-Za-z_$][\w$]*\s*(?=\(\s*\))/;
+const ZERO_ARG_PARENS = /\(\s*\)/;
+function findFunctionBodyStart(sourceText) {
+    const match = /export\s+default\s+(?:async\s+)?function\s+[A-Za-z_$][\w$]*\s*\([^)]*\)[^{]*\{/.exec(sourceText);
+    if (match === null)
+        return null;
+    return match.index + match[0].length;
+}
+export function insertLocaleParamsSignature(sourceText, localeParam) {
+    const nameMatch = ZERO_ARG_DEFAULT_EXPORT.exec(sourceText);
+    if (nameMatch === null)
+        return sourceText;
+    const parensMatch = ZERO_ARG_PARENS.exec(sourceText.slice(nameMatch.index + nameMatch[0].length));
+    if (parensMatch === null)
+        return sourceText;
+    const parensStart = nameMatch.index + nameMatch[0].length + parensMatch.index;
+    const parensEnd = parensStart + parensMatch[0].length;
+    const replacement = `({ params }: {\n    params: Promise<{ ${localeParam}: Language }>;\n})`;
+    return sourceText.slice(0, parensStart) + replacement + sourceText.slice(parensEnd);
+}
+const DEFAULT_EXPORT_FUNCTION_OPEN_PAREN = /export\s+default\s+(?:async\s+)?function\s+[A-Za-z_$][\w$]*\s*\(/;
+function findMatchingBraceEnd(code, openBraceIndex) {
+    let depth = 0;
+    for (let i = openBraceIndex; i < code.length; i++) {
+        if (code[i] === '{')
+            depth++;
+        else if (code[i] === '}') {
+            depth--;
+            if (depth === 0)
+                return i + 1;
+        }
+    }
+    return null;
+}
+function findDestructuredObjectSpans(sourceText) {
+    const openParenMatch = DEFAULT_EXPORT_FUNCTION_OPEN_PAREN.exec(sourceText);
+    if (openParenMatch === null)
+        return null;
+    let i = openParenMatch.index + openParenMatch[0].length;
+    while (i < sourceText.length && /\s/.test(sourceText[i]))
+        i++;
+    if (sourceText[i] !== '{')
+        return null;
+    const keysBraceEnd = findMatchingBraceEnd(sourceText, i);
+    if (keysBraceEnd === null)
+        return null;
+    let j = keysBraceEnd;
+    while (j < sourceText.length && /\s/.test(sourceText[j]))
+        j++;
+    if (sourceText[j] !== ':')
+        return null;
+    j++;
+    while (j < sourceText.length && /\s/.test(sourceText[j]))
+        j++;
+    if (sourceText[j] !== '{')
+        return null;
+    const typeBraceEnd = findMatchingBraceEnd(sourceText, j);
+    if (typeBraceEnd === null)
+        return null;
+    return { keysStart: i + 1, keysEnd: keysBraceEnd - 1, typeStart: j + 1, typeEnd: typeBraceEnd - 1 };
+}
+export function addParamsPropToExistingDestructure(sourceText, localeParam) {
+    const spans = findDestructuredObjectSpans(sourceText);
+    if (spans === null)
+        return sourceText;
+    const { keysStart, keysEnd, typeStart, typeEnd } = spans;
+    const keys = sourceText.slice(keysStart, keysEnd);
+    const typeBody = sourceText.slice(typeStart, typeEnd);
+    const keysTrimmedEnd = keysStart + keys.replace(/\s+$/, '').length;
+    const typeTrimmedEnd = typeStart + typeBody.replace(/\s+$/, '').length;
+    const keysSeparator = keys.trim() === '' || /,\s*$/.test(sourceText.slice(keysStart, keysTrimmedEnd)) ? '' : ',';
+    const typeSeparator = typeBody.trim() === '' || /;\s*$/.test(sourceText.slice(typeStart, typeTrimmedEnd)) ? '' : ';';
+    let result = `${sourceText.slice(0, typeTrimmedEnd)}${typeSeparator} params: Promise<{ ${localeParam}: Language }>; ${sourceText.slice(typeEnd)}`;
+    result = `${result.slice(0, keysTrimmedEnd)}${keysSeparator} params ${result.slice(keysEnd)}`;
+    return result;
+}
+export function insertLocaleParamsBody(sourceText, localeParam, hasInlineDestructure) {
+    if (hasInlineDestructure) {
+        const destructureRegex = new RegExp(`(\\{[^}]*\\b${localeParam}\\b[^}]*\\}\\s*=\\s*await\\s+params\\s*;)`);
+        const destructureMatch = destructureRegex.exec(sourceText);
+        if (destructureMatch === null)
+            return sourceText;
+        const at = destructureMatch.index + destructureMatch[0].length;
+        return `${sourceText.slice(0, at)}\n    setLocale(${localeParam});${sourceText.slice(at)}`;
+    }
+    const bodyStart = findFunctionBodyStart(sourceText);
+    if (bodyStart === null)
+        return sourceText;
+    const line = `\n    const { ${localeParam} } = await params;\n    setLocale(${localeParam});\n`;
+    return sourceText.slice(0, bodyStart) + line + sourceText.slice(bodyStart);
+}
+const PARAMS_PROMISE_TYPE = /params\s*:\s*Promise<\{([^}]*)\}>/;
+export function ensureLocaleInParamsType(sourceText, localeParam) {
+    const match = PARAMS_PROMISE_TYPE.exec(sourceText);
+    if (match === null)
+        return sourceText;
+    const inner = match[1];
+    if (new RegExp(`\\b${localeParam}\\b`).test(inner))
+        return sourceText;
+    const contentStart = match.index + match[0].indexOf('{') + 1;
+    const trimmedLength = inner.replace(/\s+$/, '').length;
+    const insertAt = contentStart + trimmedLength;
+    const separator = /;\s*$/.test(inner.slice(0, trimmedLength)) || inner.trim() === '' ? '' : ';';
+    return `${sourceText.slice(0, insertAt)}${separator} ${localeParam}: Language ${sourceText.slice(insertAt + (inner.length - trimmedLength))}`;
+}
+const CLOUDFLARE_NEXT_INTL_IMPORT = /import\s*\{([^}]*)\}\s*from\s*['"]cloudflare-next-intl['"]\s*;?/;
+export function ensureSetLocaleImport(sourceText) {
+    const match = CLOUDFLARE_NEXT_INTL_IMPORT.exec(sourceText);
+    if (match === null) {
+        return `import { setLocale } from "cloudflare-next-intl";\n${sourceText}`;
+    }
+    const names = match[1];
+    if (/\bsetLocale\b/.test(names))
+        return sourceText;
+    const replacement = match[0].replace(names, `${names.replace(/\s*$/, '')}, setLocale `);
+    return sourceText.slice(0, match.index) + replacement + sourceText.slice(match.index + match[0].length);
+}

package/dist/src/vite/auto_dynamic_pages_plugin.js

@@ -1,6 +1,7 @@
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { resolve } from "node:path";
 import { checkDynamicPages } from "../dynamic_pages_check/index.js";
+import { registerBuildWriteRestore } from "./build_write_restore_stack.js";
 const RESTORABLE_ACTIONS = new Set(['added-force-dynamic', 'added-force-static']);
 export function autoDynamicPagesPlugin(options = {}) {
     let ran = false;
@@ -59,8 +60,7 @@ export function autoDynamicPagesPlugin(options = {}) {
                     if (!restorable.has(file))
                         originals.delete(file);
                 }
-                if (originals.size > 0)
-                    registerRestore(originals);
+                registerBuildWriteRestore(originals);
             }
             catch (err) {
                 console.warn("[cloudflare-next-intl] autoDynamicPages check error:", err);
@@ -68,25 +68,3 @@ export function autoDynamicPagesPlugin(options = {}) {
         },
     };
 }
-function registerRestore(originals) {
-    let restored = false;
-    const restore = () => {
-        if (restored)
-            return;
-        restored = true;
-        for (const [file, contents] of originals) {
-            try {
-                writeFileSync(file, contents, "utf8");
-            }
-            catch {
-            }
-        }
-    };
-    process.once("exit", restore);
-    for (const signal of ["SIGINT", "SIGTERM"]) {
-        process.once(signal, () => {
-            restore();
-            process.kill(process.pid, signal);
-        });
-    }
-}

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

@@ -0,0 +1,18 @@
+import type { Plugin } from "vite";
+import { type LocaleParamsCheckMode } from "../locale_params_check/check_locale_params.js";
+import type { PageLabelStyle } from "../dynamic_pages_check/derive_page_label.js";
+export interface AutoLocaleParamsPluginOptions {
+    appDir?: string;
+    mode?: LocaleParamsCheckMode;
+    localeParam?: string;
+    skip?: readonly string[];
+    overrides?: Readonly<Record<string, {
+        localeParam?: string;
+    }>>;
+    runOnDev?: boolean;
+    restoreAfterBuild?: boolean;
+    verbose?: boolean | {
+        pageLabel?: PageLabelStyle | ((file: string, appDir: string) => string);
+    };
+}
+export declare function autoLocaleParamsPlugin(options?: AutoLocaleParamsPluginOptions): Plugin;