cloudflare-next-intl 0.9.41 → 0.9.44

package/README.md

@@ -261,7 +261,7 @@ 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 & Dev 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.
+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.
@@ -278,6 +278,7 @@ export default defineConfig({
     plugins: [
         cloudflareNextIntl({
             imageOptimizer: {                     // Image optimizer configuration (or `false` to disable)
+                dev: false,                        // Also run the scan on dev server start, not just production build (default: false)
                 maxWidth: 1920,                   // Downscale max width limit (default: 1920, or `false`)
                 formats: ["avif", "webp"],        // Target sibling formats, in browser-preference order (default: ["webp"], or `false`).
                                                    // Also supports: "png", "jpeg", "gif", "tiff", "heif", "jp2", "jxl"

package/dist/src/dynamic_pages_check/check_dynamic_pages.d.ts

@@ -1,4 +1,7 @@
+import { type DynamicApiCheck } from './detect_dynamic_usage.js';
+import { type DynamicSignal } from './trace_dynamic_usage.js';
 import { type SyncErrorReportingAuthUserReport } from './sync_error_reporting_auth_user.js';
+import { type PageLabelStyle } from './derive_page_label.js';
 import type { AliasConfig } from './resolve_local_imports.js';
 export type DynamicPagesCheckMode = 'off' | 'report' | 'fix';
 export interface CheckDynamicPagesOptions {
@@ -8,11 +11,17 @@ export interface CheckDynamicPagesOptions {
     skip?: readonly string[];
     resolveImports?: boolean;
     aliases?: readonly AliasConfig[];
+    extraChecks?: readonly DynamicApiCheck[];
     syncErrorReportingAuthUser?: boolean;
+    verbose?: boolean | {
+        pageLabel?: PageLabelStyle | ((file: string, appDir: string) => string);
+    };
 }
 export interface CheckDynamicPagesReport {
     file: string;
     action: 'added-force-dynamic' | 'would-add-force-dynamic' | 'added-force-static' | 'would-add-force-static' | 'already-declared' | 'no-dynamic-usage-detected' | 'skipped';
+    signals?: DynamicSignal[];
+    explicitValue?: 'force-static' | 'force-dynamic' | 'auto' | 'error' | null;
 }
 export interface CheckDynamicPagesIo {
     findPageFiles?: (appDir: string) => string[];

package/dist/src/dynamic_pages_check/check_dynamic_pages.js

@@ -1,10 +1,73 @@
 import { readFileSync, statSync, writeFileSync } from 'node:fs';
-import { resolve } from 'node:path';
+import { relative, resolve } from 'node:path';
 import { findPageFiles as findPageFilesImpl } from './find_page_files.js';
-import { detectDynamicUsage } from './detect_dynamic_usage.js';
+import { detectDynamicUsage, readExplicitDynamicValue } from './detect_dynamic_usage.js';
 import { traceDynamicUsage } from './trace_dynamic_usage.js';
 import { insertDynamicExport } from './insert_dynamic_export.js';
 import { syncErrorReportingAuthUser } from './sync_error_reporting_auth_user.js';
+import { deriveRoute, isApiRoute, makePageLabeler } from './derive_page_label.js';
+const LEGEND = 'λ API   ƒ Dynamic (SSR)   ○ Static (SSG)   = Already declared   - Unclear (framework decides)   · Skipped';
+function actionGlyph(report, isApi) {
+    if (isApi && report.action !== 'skipped')
+        return 'λ';
+    switch (report.action) {
+        case 'added-force-dynamic':
+        case 'would-add-force-dynamic':
+            return 'ƒ';
+        case 'added-force-static':
+        case 'would-add-force-static':
+            return '○';
+        case 'no-dynamic-usage-detected': return '-';
+        case 'skipped': return '·';
+        case 'already-declared':
+            if (report.explicitValue === 'force-dynamic')
+                return 'ƒ';
+            if (report.explicitValue === 'force-static')
+                return '○';
+            return '=';
+    }
+}
+function actionDetail(report, isApi) {
+    if (isApi && report.action !== 'skipped')
+        return 'API route';
+    switch (report.action) {
+        case 'added-force-dynamic': return 'Dynamic (SSR) — added export const dynamic = "force-dynamic"';
+        case 'would-add-force-dynamic': return 'Dynamic (SSR) — would add export const dynamic = "force-dynamic"';
+        case 'added-force-static': return 'Static (SSG) — added export const dynamic = "force-static"';
+        case 'would-add-force-static': return 'Static (SSG) — would add export const dynamic = "force-static"';
+        case 'no-dynamic-usage-detected': return 'Unclear — no dynamic-API usage detected, left to the framework';
+        case 'skipped': return 'Skipped — excluded from this scan';
+        case 'already-declared':
+            switch (report.explicitValue) {
+                case 'force-dynamic': return 'Dynamic (SSR) — export const dynamic = "force-dynamic" already set';
+                case 'force-static': return 'Static (SSG) — export const dynamic = "force-static" already set';
+                case 'auto': return 'export const dynamic = "auto" already set';
+                case 'error': return 'export const dynamic = "error" already set';
+                default: return 'export const dynamic already set';
+            }
+    }
+}
+function displayPath(file) {
+    const rel = relative(process.cwd(), file);
+    return rel === '' || rel.startsWith('..') ? file : rel;
+}
+function logReports(reports, appDir, pageLabel) {
+    console.log(`[cloudflare-next-intl] dynamic-pages check\n${LEGEND}\n`);
+    reports.forEach((report, index) => {
+        const isLast = index === reports.length - 1;
+        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 continuation = isLast ? ' ' : '│';
+        for (const signal of report.signals ?? []) {
+            const location = `${displayPath(signal.file)}:${signal.line}`;
+            const where = signal.file === report.file ? `at ${location}` : `via ${location}`;
+            console.log(`${continuation}     ↳ ${signal.api}  ${where}`);
+        }
+    });
+}
 function defaultIsFile(path) {
     try {
         return statSync(path).isFile();
@@ -27,6 +90,7 @@ export async function checkDynamicPages(options, io = {}) {
     const aliases = options.aliases ?? [
         { prefix: '@/', replacement: resolve(options.appDir, '..') },
     ];
+    const extraChecks = options.extraChecks ?? [];
     const reports = [];
     for (const file of findPageFiles(options.appDir)) {
         if (skipSet.has(file)) {
@@ -35,10 +99,13 @@ export async function checkDynamicPages(options, io = {}) {
         }
         const source = readFile(file);
         const detection = resolveImports
-            ? traceDynamicUsage(file, source, aliases, { readFile, isFile })
-            : detectDynamicUsage(source);
+            ? traceDynamicUsage(file, source, aliases, { readFile, isFile }, extraChecks)
+            : { ...detectDynamicUsage(source, extraChecks), signals: [] };
+        const signals = resolveImports
+            ? detection.signals
+            : detection.matches.map(({ name, line }) => ({ api: name, file, line }));
         if (detection.hasExplicitDynamicExport) {
-            reports.push({ file, action: 'already-declared' });
+            reports.push({ file, action: 'already-declared', explicitValue: readExplicitDynamicValue(source) });
             continue;
         }
         if (detection.detectedDynamicApis.length === 0) {
@@ -57,12 +124,17 @@ export async function checkDynamicPages(options, io = {}) {
         }
         if (mode === 'fix') {
             writeFile(file, insertDynamicExport(source, 'force-dynamic'));
-            reports.push({ file, action: 'added-force-dynamic' });
+            reports.push({ file, action: 'added-force-dynamic', signals });
         }
         else {
-            reports.push({ file, action: 'would-add-force-dynamic' });
+            reports.push({ file, action: 'would-add-force-dynamic', signals });
         }
     }
+    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);
+    }
     if (options.syncErrorReportingAuthUser === true) {
         const syncReports = await syncErrorReportingAuthUser({ appDir: options.appDir, mode: options.mode, target: options.target, skip: options.skip, aliases: options.aliases }, { findPageFiles, readFile, writeFile, isFile });
         reports.push(...syncReports);

package/dist/src/dynamic_pages_check/collect_reachable_files.js

@@ -1,5 +1,16 @@
-import { extractImportSpecifiers, resolveLocalImport } from './resolve_local_imports.js';
+import { extractImportBindings, resolveLocalImport } from './resolve_local_imports.js';
+import { stripComments, USE_CLIENT_DIRECTIVE } from './detect_dynamic_usage.js';
 export const MAX_FILES_VISITED = 300;
+function blankSpans(code, spans) {
+    let out = code;
+    for (const { start, end } of spans) {
+        out = out.slice(0, start) + [...out.slice(start, end)].map((c) => (c === '\n' ? '\n' : ' ')).join('') + out.slice(end);
+    }
+    return out;
+}
+function isWordUsed(name, text) {
+    return new RegExp(`\\b${name}\\b`).test(text);
+}
 export function collectReachableFiles(entryFile, entrySource, aliases, io) {
     const isFile = io.isFile ?? (() => false);
     const files = new Map([[entryFile, entrySource]]);
@@ -9,9 +20,17 @@ export function collectReachableFiles(entryFile, entrySource, aliases, io) {
         if (files.size >= MAX_FILES_VISITED)
             continue;
         const source = files.get(current);
-        for (const specifier of extractImportSpecifiers(source)) {
+        if (USE_CLIENT_DIRECTIVE.test(source))
+            continue;
+        const code = stripComments(source);
+        const imports = extractImportBindings(code);
+        const usageText = blankSpans(code, imports);
+        for (const { specifier, bindings, alwaysFollow } of imports) {
             if (files.size >= MAX_FILES_VISITED)
                 break;
+            if (!alwaysFollow && bindings.length > 0 && !bindings.some((name) => isWordUsed(name, usageText))) {
+                continue;
+            }
             const resolved = resolveLocalImport(specifier, current, aliases, isFile);
             if (resolved === null || files.has(resolved))
                 continue;

package/dist/src/dynamic_pages_check/derive_page_label.d.ts

@@ -0,0 +1,5 @@
+export declare function derivePageLabel(appDir: string, file: string): string;
+export declare function deriveRoute(appDir: string, file: string): string;
+export declare function isApiRoute(file: string): boolean;
+export type PageLabelStyle = 'title' | 'path';
+export declare function makePageLabeler(appDir: string, style: PageLabelStyle | ((file: string, appDir: string) => string) | undefined, displayPath: (file: string) => string): (file: string) => string;

package/dist/src/dynamic_pages_check/derive_page_label.js

@@ -0,0 +1,57 @@
+import { relative, sep } from 'node:path';
+function splitWords(segment) {
+    return segment
+        .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
+        .split(/[-_\s]+/)
+        .filter((word) => word.length > 0);
+}
+function titleCaseWords(words) {
+    return words.map((word) => word[0].toUpperCase() + word.slice(1)).join(' ');
+}
+export function derivePageLabel(appDir, file) {
+    const rel = relative(appDir, file);
+    const segments = rel.split(sep).filter((s) => s.length > 0);
+    segments.pop();
+    let literal = null;
+    let dynamicSuffix = null;
+    for (const segment of segments) {
+        const dynamicMatch = /^\[+\.{0,3}([^\]]+)\]+$/.exec(segment);
+        if (dynamicMatch) {
+            if (literal !== null)
+                dynamicSuffix = dynamicMatch[1];
+            continue;
+        }
+        if (/^\(.+\)$/.test(segment))
+            continue;
+        literal = segment;
+        dynamicSuffix = null;
+    }
+    if (literal === null)
+        return 'Home';
+    const label = titleCaseWords(splitWords(literal));
+    return dynamicSuffix ? `${label} (:${dynamicSuffix})` : label;
+}
+export function deriveRoute(appDir, file) {
+    const rel = relative(appDir, file);
+    const segments = rel.split(sep).filter((s) => s.length > 0);
+    segments.pop();
+    const urlSegments = segments
+        .filter((segment) => !/^\(.+\)$/.test(segment))
+        .map((segment) => {
+        const dynamicMatch = /^\[+(\.{3})?([^\]]+)\]+$/.exec(segment);
+        if (!dynamicMatch)
+            return segment;
+        return `:${dynamicMatch[1] ? '...' : ''}${dynamicMatch[2]}`;
+    });
+    return urlSegments.length > 0 ? `/${urlSegments.join('/')}` : '/';
+}
+export function isApiRoute(file) {
+    return /(^|[\\/])route\.(ts|js)$/.test(file);
+}
+export function makePageLabeler(appDir, style, displayPath) {
+    if (typeof style === 'function')
+        return (file) => style(file, appDir);
+    if (style === 'path')
+        return displayPath;
+    return (file) => derivePageLabel(appDir, file);
+}

package/dist/src/dynamic_pages_check/detect_dynamic_usage.d.ts

@@ -1,6 +1,17 @@
+export interface DynamicApiMatch {
+    name: string;
+    line: number;
+}
 export interface DynamicDetectionResult {
     hasExplicitDynamicExport: boolean;
     detectedDynamicApis: string[];
+    matches: DynamicApiMatch[];
+}
+export declare function stripComments(sourceText: string): string;
+export interface DynamicApiCheck {
+    name: string;
+    pattern: RegExp;
 }
-export declare function detectDynamicUsage(sourceText: string): DynamicDetectionResult;
+export declare const USE_CLIENT_DIRECTIVE: RegExp;
+export declare function detectDynamicUsage(sourceText: string, extraChecks?: readonly DynamicApiCheck[]): DynamicDetectionResult;
 export declare function readExplicitDynamicValue(sourceText: string): 'force-static' | 'force-dynamic' | 'auto' | 'error' | null;

package/dist/src/dynamic_pages_check/detect_dynamic_usage.js

@@ -1,3 +1,34 @@
+function lineOf(sourceText, index) {
+    let line = 1;
+    for (let i = 0; i < index; i++) {
+        if (sourceText.charCodeAt(i) === 10)
+            line++;
+    }
+    return line;
+}
+export function stripComments(sourceText) {
+    let out = '';
+    for (let i = 0; i < sourceText.length; i++) {
+        if (sourceText[i] === '/' && sourceText[i + 1] === '*') {
+            const end = sourceText.indexOf('*/', i + 2);
+            const commentEnd = end === -1 ? sourceText.length : end + 2;
+            for (let j = i; j < commentEnd; j++)
+                out += sourceText[j] === '\n' ? '\n' : ' ';
+            i = commentEnd - 1;
+            continue;
+        }
+        if (sourceText[i] === '/' && sourceText[i + 1] === '/' && sourceText[i - 1] !== ':') {
+            let end = sourceText.indexOf('\n', i);
+            if (end === -1)
+                end = sourceText.length;
+            out += ' '.repeat(end - i);
+            i = end - 1;
+            continue;
+        }
+        out += sourceText[i];
+    }
+    return out;
+}
 const DYNAMIC_API_CHECKS = [
     { name: 'cookies()', pattern: /\bcookies\s*\(/ },
     { name: 'headers()', pattern: /\bheaders\s*\(\s*\)/ },
@@ -10,21 +41,31 @@ const DYNAMIC_API_CHECKS = [
     { name: 'withUserDb()', pattern: /\bwithUserDb\s*\(/ },
 ];
 const USE_AUTH_USER_CALL = /\buseAuthUser\s*\(/;
-const USE_CLIENT_DIRECTIVE = /^(?:\s*['"]use \w[\w-]*['"]\s*;?\s*)*['"]use client['"]\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) {
-    const detectedDynamicApis = DYNAMIC_API_CHECKS.filter(({ pattern }) => pattern.test(sourceText)).map(({ name }) => name);
-    if (USE_AUTH_USER_CALL.test(sourceText) && !USE_CLIENT_DIRECTIVE.test(sourceText)) {
-        detectedDynamicApis.push('useAuthUser()');
+export function detectDynamicUsage(sourceText, extraChecks = []) {
+    const code = stripComments(sourceText);
+    const matches = [];
+    for (const { name, pattern } of [...DYNAMIC_API_CHECKS, ...extraChecks]) {
+        pattern.lastIndex = 0;
+        const found = pattern.exec(code);
+        if (found !== null)
+            matches.push({ name, line: lineOf(sourceText, found.index) });
+    }
+    if (!USE_CLIENT_DIRECTIVE.test(sourceText)) {
+        const found = USE_AUTH_USER_CALL.exec(code);
+        if (found !== null)
+            matches.push({ name: 'useAuthUser()', line: lineOf(sourceText, found.index) });
     }
     return {
-        hasExplicitDynamicExport: EXPLICIT_DYNAMIC_EXPORT.test(sourceText),
-        detectedDynamicApis,
+        hasExplicitDynamicExport: EXPLICIT_DYNAMIC_EXPORT.test(code),
+        detectedDynamicApis: matches.map((m) => m.name),
+        matches,
     };
 }
 const EXPLICIT_DYNAMIC_EXPORT_VALUE = /export\s+const\s+dynamic\s*=\s*['"]([^'"]+)['"]/;
 export function readExplicitDynamicValue(sourceText) {
-    const match = EXPLICIT_DYNAMIC_EXPORT_VALUE.exec(sourceText);
+    const match = EXPLICIT_DYNAMIC_EXPORT_VALUE.exec(stripComments(sourceText));
     if (match === null)
         return null;
     const value = match[1];

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

@@ -1,3 +1,6 @@
 export { checkDynamicPages, type DynamicPagesCheckMode, type CheckDynamicPagesOptions, type CheckDynamicPagesReport, type CheckDynamicPagesIo } from './check_dynamic_pages.js';
 export { findPageFiles } from './find_page_files.js';
-export { detectDynamicUsage, type DynamicDetectionResult } from './detect_dynamic_usage.js';
+export { detectDynamicUsage, stripComments, type DynamicApiCheck, type DynamicApiMatch, type DynamicDetectionResult } from './detect_dynamic_usage.js';
+export { traceDynamicUsage, type DynamicSignal, type TraceDynamicUsageResult } from './trace_dynamic_usage.js';
+export { collectReachableFiles, MAX_FILES_VISITED } from './collect_reachable_files.js';
+export { derivePageLabel, deriveRoute, isApiRoute, makePageLabeler, type PageLabelStyle } from './derive_page_label.js';

package/dist/src/dynamic_pages_check/index.js

@@ -1,3 +1,6 @@
 export { checkDynamicPages } from './check_dynamic_pages.js';
 export { findPageFiles } from './find_page_files.js';
-export { detectDynamicUsage } from './detect_dynamic_usage.js';
+export { detectDynamicUsage, stripComments } from './detect_dynamic_usage.js';
+export { traceDynamicUsage } from './trace_dynamic_usage.js';
+export { collectReachableFiles, MAX_FILES_VISITED } from './collect_reachable_files.js';
+export { derivePageLabel, deriveRoute, isApiRoute, makePageLabeler } from './derive_page_label.js';

package/dist/src/dynamic_pages_check/resolve_local_imports.d.ts

@@ -3,4 +3,12 @@ export interface AliasConfig {
     replacement: string;
 }
 export declare function extractImportSpecifiers(sourceText: string): string[];
+export interface ImportBindingInfo {
+    specifier: string;
+    bindings: string[];
+    alwaysFollow: boolean;
+    start: number;
+    end: number;
+}
+export declare function extractImportBindings(sourceText: string): ImportBindingInfo[];
 export declare function resolveLocalImport(specifier: string, fromFile: string, aliases: readonly AliasConfig[], isFile?: (file: string) => boolean): string | null;

package/dist/src/dynamic_pages_check/resolve_local_imports.js

@@ -15,6 +15,62 @@ export function extractImportSpecifiers(sourceText) {
     }
     return specifiers;
 }
+const FROM_IMPORT_STATEMENT = /\b(import|export)\s+type\s+|\b(import|export)\s+([\s\S]*?)\s*from\s*(['"])([^'"]+)\4/g;
+const BARE_IMPORT_STATEMENT = /(?:^|\n|;)\s*(import\s*(['"])([^'"]+)\2)/g;
+function bindingsFromClause(clause) {
+    const bindings = [];
+    const namespaceMatch = /^\*\s*as\s+(\w+)$/.exec(clause.trim());
+    if (namespaceMatch)
+        return [namespaceMatch[1]];
+    if (clause.trim() === '*')
+        return [];
+    const braceMatch = /\{([^}]*)\}/.exec(clause);
+    if (braceMatch) {
+        for (const rawItem of braceMatch[1].split(',')) {
+            const item = rawItem.trim().replace(/^type\s+/, '');
+            if (item.length === 0)
+                continue;
+            const asMatch = /\bas\s+(\w+)$/.exec(item);
+            bindings.push(asMatch ? asMatch[1] : item);
+        }
+    }
+    const beforeBrace = clause.slice(0, braceMatch?.index ?? clause.length).replace(/,\s*$/, '').trim();
+    if (/^\w+$/.test(beforeBrace))
+        bindings.push(beforeBrace);
+    return bindings;
+}
+export function extractImportBindings(sourceText) {
+    const results = [];
+    FROM_IMPORT_STATEMENT.lastIndex = 0;
+    let match;
+    while ((match = FROM_IMPORT_STATEMENT.exec(sourceText)) !== null) {
+        if (match[1] !== undefined || match[2] === undefined)
+            continue;
+        const keyword = match[2];
+        const clause = match[3];
+        const specifier = match[5];
+        results.push({
+            specifier,
+            bindings: keyword === 'export' ? [] : bindingsFromClause(clause),
+            alwaysFollow: keyword === 'export',
+            start: match.index,
+            end: match.index + match[0].length,
+        });
+    }
+    BARE_IMPORT_STATEMENT.lastIndex = 0;
+    while ((match = BARE_IMPORT_STATEMENT.exec(sourceText)) !== null) {
+        const statement = match[1];
+        const statementStart = match.index + match[0].indexOf(statement);
+        results.push({
+            specifier: match[3],
+            bindings: [],
+            alwaysFollow: true,
+            start: statementStart,
+            end: statementStart + statement.length,
+        });
+    }
+    return results;
+}
 const FILE_EXTENSIONS = ['.ts', '.tsx', '.js', '.jsx'];
 function defaultIsFile(path) {
     try {

package/dist/src/dynamic_pages_check/trace_dynamic_usage.d.ts

@@ -1,5 +1,13 @@
-import { type DynamicDetectionResult } from './detect_dynamic_usage.js';
+import { type DynamicApiCheck, type DynamicDetectionResult } from './detect_dynamic_usage.js';
 import { type CollectReachableFilesIo } from './collect_reachable_files.js';
 import type { AliasConfig } from './resolve_local_imports.js';
 export type TraceDynamicUsageIo = CollectReachableFilesIo;
-export declare function traceDynamicUsage(entryFile: string, entrySource: string, aliases: readonly AliasConfig[], io: TraceDynamicUsageIo): DynamicDetectionResult;
+export interface DynamicSignal {
+    api: string;
+    file: string;
+    line: number;
+}
+export interface TraceDynamicUsageResult extends DynamicDetectionResult {
+    signals: DynamicSignal[];
+}
+export declare function traceDynamicUsage(entryFile: string, entrySource: string, aliases: readonly AliasConfig[], io: TraceDynamicUsageIo, extraChecks?: readonly DynamicApiCheck[]): TraceDynamicUsageResult;

package/dist/src/dynamic_pages_check/trace_dynamic_usage.js

@@ -1,17 +1,26 @@
 import { detectDynamicUsage } from './detect_dynamic_usage.js';
 import { collectReachableFiles } from './collect_reachable_files.js';
-export function traceDynamicUsage(entryFile, entrySource, aliases, io) {
+export function traceDynamicUsage(entryFile, entrySource, aliases, io, extraChecks = []) {
     const files = collectReachableFiles(entryFile, entrySource, aliases, io);
     let hasExplicitDynamicExport = false;
     const detectedApis = new Set();
+    const signals = [];
     let first = true;
-    for (const source of files.values()) {
-        const detection = detectDynamicUsage(source);
+    for (const [file, source] of files.entries()) {
+        const detection = detectDynamicUsage(source, extraChecks);
         if (first) {
             hasExplicitDynamicExport = detection.hasExplicitDynamicExport;
             first = false;
         }
-        detection.detectedDynamicApis.forEach((api) => detectedApis.add(api));
+        detection.matches.forEach(({ name, line }) => {
+            detectedApis.add(name);
+            signals.push({ api: name, file, line });
+        });
     }
-    return { hasExplicitDynamicExport, detectedDynamicApis: [...detectedApis] };
+    return {
+        hasExplicitDynamicExport,
+        detectedDynamicApis: [...detectedApis],
+        matches: signals.map(({ api, line }) => ({ name: api, line })),
+        signals,
+    };
 }

package/dist/src/image_optimizer/types.js

@@ -15,7 +15,7 @@ export const DEFAULT_OPTIONS = {
     formats: ["webp"],
     manifest: "public/generated/images.json",
     blur: DEFAULT_BLUR_OPTIONS,
-    dev: true,
+    dev: false,
     cacheDir: "node_modules/.cache/cloudflare-next-intl/image-optimizer",
     onlyUsed: true,
     overrides: {},

package/dist/src/server/components/link.js

@@ -35,6 +35,22 @@ function CustomLinkFunction({ href, prefetch, prefetchType = 'custom', hoverPref
         }
         window.dispatchEvent(new CustomEvent(PENDING_NAVIGATION_EVENT, { detail: null }));
     }, [pathname]);
+    const openedPendingEvent = useRef(false);
+    const wasPending = useRef(false);
+    useEffect(() => {
+        if (isPending) {
+            wasPending.current = true;
+            return;
+        }
+        if (!wasPending.current)
+            return;
+        wasPending.current = false;
+        setIsNavigating(false);
+        if (!openedPendingEvent.current)
+            return;
+        openedPendingEvent.current = false;
+        window.dispatchEvent(new CustomEvent(PENDING_NAVIGATION_EVENT, { detail: null }));
+    }, [isPending]);
     useEffect(() => {
         if (!isNavigating)
             return;
@@ -99,8 +115,10 @@ function CustomLinkFunction({ href, prefetch, prefetchType = 'custom', hoverPref
         }
         if (isCustom) {
             const targetPath = typeof pathnames === 'string' ? pathnames : urlString;
-            if (pathname !== targetPath) {
+            const targetPathname = targetPath.replace(/[?#].*$/, '');
+            if (pathname !== targetPathname) {
                 setIsNavigating(true);
+                openedPendingEvent.current = true;
                 window.dispatchEvent(new CustomEvent(PENDING_NAVIGATION_EVENT, { detail: targetPath }));
             }
             startTransition(() => {

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

@@ -1,9 +1,14 @@
 import type { Plugin } from "vite";
-import { type DynamicPagesCheckMode } from "../dynamic_pages_check/index.js";
+import { type DynamicApiCheck, type DynamicPagesCheckMode, type PageLabelStyle } from "../dynamic_pages_check/index.js";
 export interface AutoDynamicPagesPluginOptions {
     appDir?: string;
     mode?: DynamicPagesCheckMode;
     target?: 'next' | 'vinext';
     syncErrorReportingAuthUser?: boolean;
+    extraChecks?: readonly DynamicApiCheck[];
+    verbose?: boolean | {
+        pageLabel?: PageLabelStyle | ((file: string, appDir: string) => string);
+    };
+    restoreAfterBuild?: boolean;
 }
 export declare function autoDynamicPagesPlugin(options?: AutoDynamicPagesPluginOptions): Plugin;

package/dist/src/vite/auto_dynamic_pages_plugin.js

@@ -1,6 +1,7 @@
-import { existsSync } from "node:fs";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { resolve } from "node:path";
 import { checkDynamicPages } from "../dynamic_pages_check/index.js";
+const RESTORABLE_ACTIONS = new Set(['added-force-dynamic', 'added-force-static']);
 export function autoDynamicPagesPlugin(options = {}) {
     let ran = false;
     return {
@@ -25,13 +26,41 @@ export function autoDynamicPagesPlugin(options = {}) {
             if (!appDir || !existsSync(appDir)) {
                 return;
             }
+            const restoreAfterBuild = options.restoreAfterBuild ?? true;
+            const originals = new Map();
             try {
-                await checkDynamicPages({
+                const reports = await checkDynamicPages({
                     appDir,
                     mode: options.mode ?? "fix",
                     target: options.target ?? "vinext",
                     syncErrorReportingAuthUser: options.syncErrorReportingAuthUser ?? false,
-                });
+                    extraChecks: options.extraChecks ?? [],
+                    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(String(report.action)))
+                    .map((report) => report.file));
+                for (const file of [...originals.keys()]) {
+                    if (!restorable.has(file))
+                        originals.delete(file);
+                }
+                if (originals.size > 0)
+                    registerRestore(originals);
             }
             catch (err) {
                 console.warn("[cloudflare-next-intl] autoDynamicPages check error:", err);
@@ -39,3 +68,25 @@ 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cloudflare-next-intl",
-  "version": "0.9.41",
+  "version": "0.9.44",
   "description": "Optimized Next Intl Package Special for App Router and Cloudflare",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",