cloudflare-next-intl 0.9.13 → 0.9.14

package/README.md

@@ -256,7 +256,11 @@ export default defineConfig({
 ```
 
 ##### What `cloudflareNextIntl()` Does
-1. **Auto Dynamic Pages for SSG (`autoDynamicPages`)**: Automatically scans your Next.js/Vinext App Router pages during Vite configuration (`configResolved`) and inserts `export const dynamic = "force-static"` for all static pages that do not access dynamic APIs. This ensures Vinext builds all public marketing and static pages into SSG HTML automatically without extra build scripts or manually writing `export const dynamic = "force-static"`.
+1. **Auto Dynamic Pages for SSG (`autoDynamicPages`)**: Automatically scans your Next.js/Vinext App Router pages during Vite configuration (`configResolved`) and inserts `export const dynamic = "force-static"` for all static pages that do not access dynamic APIs, or `export const dynamic = "force-dynamic"` for pages that do. This ensures Vinext builds all public marketing and static pages into SSG HTML automatically without extra build scripts or manually writing `export const dynamic`.
+
+   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. 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). 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.
 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.
 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).
@@ -475,6 +479,7 @@ Features include:
 - `sendVerificationEmail(actionCodeSettings?)` on `useAuthUser()`: Custom action email settings when resending email verification.
 - `followSameOriginContinueUrl`: Automatically forwards emailed action links with `continueUrl` to the specified path (or external URL) directly from `intlMiddleware` (default `true`; set `false` on `firebaseAuth` config to disable). If `continueUrl` points to home root (`/`), it resolves to `actionLinkPath` (if set) or the mode target path (e.g. `/reset-password`).
 - `appCheck`: Firebase App Check integration supporting reCAPTCHA Enterprise (`recaptchaEnterpriseSiteKey`) and reCAPTCHA v3 (`recaptchaV3SiteKey`). For reCAPTCHA v3, defaults to a `CustomProvider` using `IntlHelperScript`'s explicit script tag to avoid iframe/webworker CDN integrity issues in private windows (`useExplicitRecaptchaScript: false` to opt out). Supports server-side token minting via service accounts.
+- `resolveOptionalAuthUser()` (`cloudflare-next-intl/resolveOptionalAuthUser`): best-effort variant of `getAuthUser()` for callers that want to *attach* the current user when one happens to be known — error/telemetry reporting, analytics, logging — without failing or changing behavior when no request/session context is available. Swallows every failure and resolves `{ user: null }` instead of throwing. Use `getAuthUser()` (not this) whenever your own output actually depends on who's signed in — `checkDynamicPages` (below) treats `getAuthUser()`/`useAuthUser()`/`withUserDb()` as page-blocking dynamic-API signals but does not follow into this helper, so it's also the way to read "whoever's signed in, if anyone" from a page or a module it imports without forcing that page dynamic.
 
 ```tsx
 import ThemeSwitcher from "cloudflare-next-intl/ThemeSwitcher";

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

@@ -1,9 +1,12 @@
+import type { AliasConfig } from './resolve_local_imports.js';
 export type DynamicPagesCheckMode = 'off' | 'report' | 'fix';
 export interface CheckDynamicPagesOptions {
     appDir: string;
     mode?: DynamicPagesCheckMode;
     target?: 'next' | 'vinext';
     skip?: readonly string[];
+    resolveImports?: boolean;
+    aliases?: readonly AliasConfig[];
 }
 export interface CheckDynamicPagesReport {
     file: string;
@@ -13,5 +16,6 @@ export interface CheckDynamicPagesIo {
     findPageFiles?: (appDir: string) => string[];
     readFile?: (file: string) => string;
     writeFile?: (file: string, contents: string) => void;
+    isFile?: (file: string) => boolean;
 }
 export declare function checkDynamicPages(options: CheckDynamicPagesOptions, io?: CheckDynamicPagesIo): Promise<CheckDynamicPagesReport[]>;

package/dist/src/dynamic_pages_check/check_dynamic_pages.js

@@ -1,16 +1,31 @@
-import { readFileSync, writeFileSync } from 'node:fs';
+import { readFileSync, statSync, writeFileSync } from 'node:fs';
+import { resolve } from 'node:path';
 import { findPageFiles as findPageFilesImpl } from './find_page_files.js';
 import { detectDynamicUsage } from './detect_dynamic_usage.js';
+import { traceDynamicUsage } from './trace_dynamic_usage.js';
 import { insertDynamicExport } from './insert_dynamic_export.js';
+function defaultIsFile(path) {
+    try {
+        return statSync(path).isFile();
+    }
+    catch {
+        return false;
+    }
+}
 export async function checkDynamicPages(options, io = {}) {
     const mode = options.mode ?? 'report';
     if (mode === 'off')
         return [];
     const target = options.target ?? 'next';
+    const resolveImports = options.resolveImports ?? true;
     const findPageFiles = io.findPageFiles ?? findPageFilesImpl;
     const readFile = io.readFile ?? ((file) => readFileSync(file, 'utf8'));
     const writeFile = io.writeFile ?? ((file, contents) => writeFileSync(file, contents, 'utf8'));
+    const isFile = io.isFile ?? defaultIsFile;
     const skipSet = new Set(options.skip ?? []);
+    const aliases = options.aliases ?? [
+        { prefix: '@/', replacement: resolve(options.appDir, '..') },
+    ];
     const reports = [];
     for (const file of findPageFiles(options.appDir)) {
         if (skipSet.has(file)) {
@@ -18,7 +33,9 @@ export async function checkDynamicPages(options, io = {}) {
             continue;
         }
         const source = readFile(file);
-        const detection = detectDynamicUsage(source);
+        const detection = resolveImports
+            ? traceDynamicUsage(file, source, aliases, { readFile, isFile })
+            : detectDynamicUsage(source);
         if (detection.hasExplicitDynamicExport) {
             reports.push({ file, action: 'already-declared' });
             continue;

package/dist/src/dynamic_pages_check/detect_dynamic_usage.js

@@ -6,6 +6,9 @@ const DYNAMIC_API_CHECKS = [
     { name: 'connection()', pattern: /\bconnection\s*\(\s*\)/ },
     { name: 'cache: "no-store"', pattern: /cache:\s*['"]no-store['"]/ },
     { name: 'next: { revalidate: 0 }', pattern: /next:\s*\{\s*revalidate:\s*0\s*[,}]/ },
+    { name: 'getAuthUser()', pattern: /\bgetAuthUser\s*\(/ },
+    { name: 'useAuthUser()', pattern: /\buseAuthUser\s*\(/ },
+    { name: 'withUserDb()', pattern: /\bwithUserDb\s*\(/ },
 ];
 const EXPLICIT_DYNAMIC_EXPORT = /export\s+const\s+dynamic\s*=/;
 export function detectDynamicUsage(sourceText) {

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

@@ -0,0 +1,6 @@
+export interface AliasConfig {
+    prefix: string;
+    replacement: string;
+}
+export declare function extractImportSpecifiers(sourceText: string): string[];
+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

@@ -0,0 +1,55 @@
+import { statSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+const FROM_SPECIFIER = /\bfrom\s*['"]([^'"]+)['"]/g;
+const BARE_IMPORT_SPECIFIER = /(?:^|\n|;)\s*import\s*['"]([^'"]+)['"]/g;
+export function extractImportSpecifiers(sourceText) {
+    const specifiers = [];
+    FROM_SPECIFIER.lastIndex = 0;
+    let match;
+    while ((match = FROM_SPECIFIER.exec(sourceText)) !== null) {
+        specifiers.push(match[1]);
+    }
+    BARE_IMPORT_SPECIFIER.lastIndex = 0;
+    while ((match = BARE_IMPORT_SPECIFIER.exec(sourceText)) !== null) {
+        specifiers.push(match[1]);
+    }
+    return specifiers;
+}
+const FILE_EXTENSIONS = ['.ts', '.tsx', '.js', '.jsx'];
+function defaultIsFile(path) {
+    try {
+        return statSync(path).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+export function resolveLocalImport(specifier, fromFile, aliases, isFile = defaultIsFile) {
+    let base = null;
+    if (specifier.startsWith('./') || specifier.startsWith('../')) {
+        base = resolve(dirname(fromFile), specifier);
+    }
+    else {
+        for (const alias of aliases) {
+            if (specifier.startsWith(alias.prefix)) {
+                base = join(alias.replacement, specifier.slice(alias.prefix.length));
+                break;
+            }
+        }
+    }
+    if (base === null)
+        return null;
+    if (isFile(base))
+        return base;
+    for (const ext of FILE_EXTENSIONS) {
+        const candidate = `${base}${ext}`;
+        if (isFile(candidate))
+            return candidate;
+    }
+    for (const ext of FILE_EXTENSIONS) {
+        const candidate = join(base, `index${ext}`);
+        if (isFile(candidate))
+            return candidate;
+    }
+    return null;
+}

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

@@ -0,0 +1,7 @@
+import { type DynamicDetectionResult } from './detect_dynamic_usage.js';
+import { type AliasConfig } from './resolve_local_imports.js';
+export interface TraceDynamicUsageIo {
+    readFile: (file: string) => string;
+    isFile?: (file: string) => boolean;
+}
+export declare function traceDynamicUsage(entryFile: string, entrySource: string, aliases: readonly AliasConfig[], io: TraceDynamicUsageIo): DynamicDetectionResult;

package/dist/src/dynamic_pages_check/trace_dynamic_usage.js

@@ -0,0 +1,39 @@
+import { detectDynamicUsage } from './detect_dynamic_usage.js';
+import { extractImportSpecifiers, resolveLocalImport } from './resolve_local_imports.js';
+const MAX_FILES_VISITED = 300;
+export function traceDynamicUsage(entryFile, entrySource, aliases, io) {
+    const isFile = io.isFile ?? (() => false);
+    const visited = new Set([entryFile]);
+    const queue = [{ file: entryFile, source: entrySource }];
+    let hasExplicitDynamicExport = false;
+    const detectedApis = new Set();
+    let first = true;
+    while (queue.length > 0) {
+        const current = queue.shift();
+        const detection = detectDynamicUsage(current.source);
+        if (first) {
+            hasExplicitDynamicExport = detection.hasExplicitDynamicExport;
+            first = false;
+        }
+        detection.detectedDynamicApis.forEach((api) => detectedApis.add(api));
+        if (visited.size >= MAX_FILES_VISITED)
+            continue;
+        for (const specifier of extractImportSpecifiers(current.source)) {
+            if (visited.size >= MAX_FILES_VISITED)
+                break;
+            const resolved = resolveLocalImport(specifier, current.file, aliases, isFile);
+            if (resolved === null || visited.has(resolved))
+                continue;
+            visited.add(resolved);
+            let importedSource;
+            try {
+                importedSource = io.readFile(resolved);
+            }
+            catch {
+                continue;
+            }
+            queue.push({ file: resolved, source: importedSource });
+        }
+    }
+    return { hasExplicitDynamicExport, detectedDynamicApis: [...detectedApis] };
+}

package/dist/src/firebase_auth/server/resolve_optional_auth_user.d.ts

@@ -0,0 +1,4 @@
+import type { User } from '@firebase/auth';
+export default function resolveOptionalAuthUser(): Promise<{
+    user: User | null;
+}>;

package/dist/src/firebase_auth/server/resolve_optional_auth_user.js

@@ -0,0 +1,10 @@
+import { getAuthUser } from './use_auth_user_server.js';
+export default async function resolveOptionalAuthUser() {
+    try {
+        const { user } = await getAuthUser();
+        return { user };
+    }
+    catch {
+        return { user: null };
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cloudflare-next-intl",
-  "version": "0.9.13",
+  "version": "0.9.14",
   "description": "Optimized Next Intl Package Special for App Router and Cloudflare",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -142,6 +142,10 @@
       "types": "./dist/src/firebase_auth/server/use_auth_user_server.d.ts",
       "import": "./dist/src/firebase_auth/server/use_auth_user_server.js"
     },
+    "./resolveOptionalAuthUser": {
+      "types": "./dist/src/firebase_auth/server/resolve_optional_auth_user.d.ts",
+      "import": "./dist/src/firebase_auth/server/resolve_optional_auth_user.js"
+    },
     "./firebaseAuthActions": {
       "types": "./dist/src/firebase_auth/client/auth_actions.d.ts",
       "import": "./dist/src/firebase_auth/client/auth_actions.js"