cloudflare-next-intl 0.10.4 → 0.10.6

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

@@ -12,6 +12,7 @@ export interface DynamicApiCheck {
     name: string;
     pattern: RegExp;
 }
+export declare function hasSetLocaleCall(sourceText: string): boolean;
 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

@@ -32,7 +32,6 @@ export function stripComments(sourceText) {
 const DYNAMIC_API_CHECKS = [
     { name: 'cookies()', pattern: /\bcookies\s*\(/ },
     { name: 'headers()', pattern: /\bheaders\s*\(\s*\)/ },
-    { name: 'searchParams', pattern: /\bsearchParams\b/ },
     { name: 'unstable_noStore()', pattern: /\bunstable_noStore\s*\(/ },
     { name: 'connection()', pattern: /\bconnection\s*\(\s*\)/ },
     { name: 'cache: "no-store"', pattern: /cache:\s*['"]no-store['"]/ },
@@ -41,8 +40,12 @@ const DYNAMIC_API_CHECKS = [
     { name: 'withUserDb()', pattern: /\bwithUserDb\s*\(/ },
 ];
 const USE_AUTH_USER_CALL = /\buseAuthUser\s*\(/;
+const SEARCH_PARAMS_IDENTIFIER = /\bsearchParams\b/;
 const TRANSLATIONS_CALL_NO_LOCALE = /\b(?:getTranslations|useTranslations)\s*\(\s*(?:['"][^'"]*['"]|[A-Za-z_$][\w$]*)\s*\)/;
 const SET_LOCALE_CALL = /\bsetLocale(?:Async)?\s*\(/;
+export function hasSetLocaleCall(sourceText) {
+    return SET_LOCALE_CALL.test(stripComments(sourceText));
+}
 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 = []) {
@@ -59,7 +62,12 @@ export function detectDynamicUsage(sourceText, extraChecks = []) {
         if (found !== null)
             matches.push({ name: 'useAuthUser()', line: lineOf(sourceText, found.index) });
     }
-    if (!SET_LOCALE_CALL.test(code)) {
+    if (!USE_CLIENT_DIRECTIVE.test(sourceText)) {
+        const found = SEARCH_PARAMS_IDENTIFIER.exec(code);
+        if (found !== null)
+            matches.push({ name: 'searchParams', line: lineOf(sourceText, found.index) });
+    }
+    if (!USE_CLIENT_DIRECTIVE.test(sourceText) && !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) });

package/dist/src/dynamic_pages_check/find_report_error_calls.js

@@ -20,8 +20,8 @@ function parseCallArgs(sourceText, start) {
             continue;
         }
         if (ch === '/' && sourceText[i + 1] === '/') {
-            const nextNewline = sourceText.indexOf('\n', i);
-            i = nextNewline === -1 ? sourceText.length : nextNewline;
+            const nextNewline = sourceText.indexOf('\n', i + 2);
+            i = nextNewline === -1 ? sourceText.length : nextNewline + 1;
             continue;
         }
         if (ch === '/' && sourceText[i + 1] === '*') {

package/dist/src/dynamic_pages_check/trace_dynamic_usage.js

@@ -1,7 +1,8 @@
-import { detectDynamicUsage } from './detect_dynamic_usage.js';
+import { detectDynamicUsage, hasSetLocaleCall } from './detect_dynamic_usage.js';
 import { collectReachableFiles } from './collect_reachable_files.js';
 export function traceDynamicUsage(entryFile, entrySource, aliases, io, extraChecks = []) {
     const files = collectReachableFiles(entryFile, entrySource, aliases, io);
+    const entryHasSetLocale = hasSetLocaleCall(entrySource);
     let hasExplicitDynamicExport = false;
     const detectedApis = new Set();
     const signals = [];
@@ -13,6 +14,9 @@ export function traceDynamicUsage(entryFile, entrySource, aliases, io, extraChec
             first = false;
         }
         detection.matches.forEach(({ name, line }) => {
+            if (entryHasSetLocale && file !== entryFile && name === 'getTranslations()/useTranslations() (cookie-derived locale)') {
+                return;
+            }
             detectedApis.add(name);
             signals.push({ api: name, file, line });
         });

package/dist/src/firebase_auth_check/check_firebase_auth_config.js

@@ -1,4 +1,5 @@
 import { existsSync, readFileSync } from "node:fs";
+import { dirname, resolve as resolvePath } from "node:path";
 const REQUIRED_AUTH_FIELDS = [
     "apiKey",
     "authDomain",
@@ -9,16 +10,7 @@ const REQUIRED_AUTH_FIELDS = [
 ];
 const REQUIRED_APP_CHECK_FIELDS = ["clientEmail", "appId"];
 const OAUTH_TRIPLE = ["oauthClientId", "oauthClientSecret", "oauthRefreshToken"];
-export function extractObjectLiteral(source, key) {
-    const keyMatch = new RegExp(`(^|[\\s{,])${key}\\s*:`).exec(source);
-    if (!keyMatch)
-        return null;
-    const afterKey = keyMatch.index + keyMatch[0].length;
-    const open = source.indexOf("{", afterKey);
-    if (open === -1)
-        return null;
-    if (/[,;]/.test(source.slice(afterKey, open)))
-        return null;
+function matchBraceLiteral(source, open) {
     let depth = 0;
     let index = open;
     let quote = null;
@@ -66,8 +58,286 @@ export function extractObjectLiteral(source, key) {
     }
     return null;
 }
+function maskCommentsAndStrings(text) {
+    let result = "";
+    let quote = null;
+    let comment = null;
+    for (let index = 0; index < text.length; index += 1) {
+        const char = text[index];
+        const next = text[index + 1];
+        if (comment === "line") {
+            result += char === "\n" ? "\n" : " ";
+            if (char === "\n")
+                comment = null;
+        }
+        else if (comment === "block") {
+            if (char === "*" && next === "/") {
+                result += "  ";
+                comment = null;
+                index += 1;
+            }
+            else {
+                result += char === "\n" ? "\n" : " ";
+            }
+        }
+        else if (quote) {
+            if (char === "\\") {
+                result += "  ";
+                index += 1;
+            }
+            else {
+                result += char === "\n" ? "\n" : " ";
+                if (char === quote)
+                    quote = null;
+            }
+        }
+        else if (char === "/" && next === "/") {
+            comment = "line";
+            result += "  ";
+            index += 1;
+        }
+        else if (char === "/" && next === "*") {
+            comment = "block";
+            result += "  ";
+            index += 1;
+        }
+        else if (char === '"' || char === "'" || char === "`") {
+            quote = char;
+            result += " ";
+        }
+        else {
+            result += char;
+        }
+    }
+    return result;
+}
+export function extractObjectLiteral(source, key) {
+    const masked = maskCommentsAndStrings(source);
+    const keyMatch = new RegExp(`(^|[\\s{,])${key}\\s*:`).exec(masked);
+    if (!keyMatch)
+        return null;
+    const afterKey = keyMatch.index + keyMatch[0].length;
+    const open = masked.indexOf("{", afterKey);
+    if (open === -1)
+        return null;
+    if (/[,;]/.test(masked.slice(afterKey, open)))
+        return null;
+    return matchBraceLiteral(source, open);
+}
+function extractAssignedObjectLiteral(source, name) {
+    const masked = maskCommentsAndStrings(source);
+    const declMatch = new RegExp(`(?:^|[\\s;}])(?:export\\s+)?(?:const|let|var)\\s+${name}\\b[^=;]*=`).exec(masked);
+    if (!declMatch)
+        return null;
+    const afterEq = declMatch.index + declMatch[0].length;
+    const open = masked.indexOf("{", afterEq);
+    if (open === -1)
+        return null;
+    if (/[;\n]\S/.test(masked.slice(afterEq, open)))
+        return null;
+    return matchBraceLiteral(source, open);
+}
+function findTopLevelSpreadNames(body) {
+    const names = [];
+    let depth = 0;
+    let quote = null;
+    let comment = null;
+    for (let index = 0; index < body.length; index += 1) {
+        const char = body[index];
+        const next = body[index + 1];
+        if (comment === "line") {
+            if (char === "\n")
+                comment = null;
+        }
+        else if (comment === "block") {
+            if (char === "*" && next === "/") {
+                comment = null;
+                index += 1;
+            }
+        }
+        else if (quote) {
+            if (char === "\\")
+                index += 1;
+            else if (char === quote)
+                quote = null;
+        }
+        else if (char === "/" && next === "/") {
+            comment = "line";
+            index += 1;
+        }
+        else if (char === "/" && next === "*") {
+            comment = "block";
+            index += 1;
+        }
+        else if (char === '"' || char === "'" || char === "`") {
+            quote = char;
+        }
+        else if (char === "{" || char === "[" || char === "(") {
+            depth += 1;
+        }
+        else if (char === "}" || char === "]" || char === ")") {
+            depth -= 1;
+        }
+        else if (depth === 0 && char === "." && next === "." && body[index + 2] === ".") {
+            const nameMatch = /^([A-Za-z_$][\w$]*)/.exec(body.slice(index + 3));
+            if (nameMatch)
+                names.push(nameMatch[1]);
+            index += 2;
+        }
+    }
+    return names;
+}
+const RESOLVE_EXTENSIONS = [".ts", ".tsx", ".mts", ".js", ".jsx", ".mjs"];
+const tsconfigAliasCache = new Map();
+function stripJsonComments(text) {
+    let stripped = "";
+    let inString = false;
+    for (let index = 0; index < text.length; index += 1) {
+        const char = text[index];
+        const next = text[index + 1];
+        if (inString) {
+            stripped += char;
+            if (char === "\\") {
+                stripped += next ?? "";
+                index += 1;
+            }
+            else if (char === '"') {
+                inString = false;
+            }
+            continue;
+        }
+        if (char === '"') {
+            inString = true;
+            stripped += char;
+        }
+        else if (char === "/" && next === "/") {
+            while (index < text.length && text[index] !== "\n")
+                index += 1;
+            stripped += "\n";
+        }
+        else if (char === "/" && next === "*") {
+            index += 2;
+            while (index < text.length && !(text[index] === "*" && text[index + 1] === "/"))
+                index += 1;
+            index += 1;
+        }
+        else {
+            stripped += char;
+        }
+    }
+    return stripped.replace(/,(\s*[}\]])/g, "$1");
+}
+function findTsconfigAliases(fromDir) {
+    if (tsconfigAliasCache.has(fromDir))
+        return tsconfigAliasCache.get(fromDir);
+    let dir = fromDir;
+    let result = null;
+    for (let depth = 0; depth < 12; depth += 1) {
+        const candidate = resolvePath(dir, "tsconfig.json");
+        if (existsSync(candidate)) {
+            try {
+                const parsed = JSON.parse(stripJsonComments(readFileSync(candidate, "utf8")));
+                const paths = parsed?.compilerOptions?.paths;
+                if (paths && typeof paths === "object") {
+                    result = { baseDir: resolvePath(dir, parsed?.compilerOptions?.baseUrl ?? "."), paths };
+                }
+            }
+            catch {
+                result = null;
+            }
+            break;
+        }
+        const parent = dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    tsconfigAliasCache.set(fromDir, result);
+    return result;
+}
+function resolveAliasSpecifier(fromFile, specifier) {
+    const aliases = findTsconfigAliases(dirname(fromFile));
+    if (!aliases)
+        return null;
+    for (const [pattern, targets] of Object.entries(aliases.paths)) {
+        const target = targets[0];
+        if (!target)
+            continue;
+        if (pattern.endsWith("/*") && specifier.startsWith(pattern.slice(0, -1))) {
+            return resolvePath(aliases.baseDir, target.slice(0, -1) + specifier.slice(pattern.length - 1));
+        }
+        if (pattern === specifier) {
+            return resolvePath(aliases.baseDir, target);
+        }
+    }
+    return null;
+}
+function resolveModuleFile(fromFile, specifier) {
+    const target = specifier.startsWith(".")
+        ? resolvePath(dirname(fromFile), specifier)
+        : resolveAliasSpecifier(fromFile, specifier);
+    if (!target)
+        return null;
+    for (const candidate of [target, ...RESOLVE_EXTENSIONS.map((ext) => target + ext)]) {
+        if (existsSync(candidate))
+            return candidate;
+    }
+    return null;
+}
+function findNamedImportSpecifier(source, localName) {
+    const importRegex = /import\s*\{([^}]*)\}\s*from\s*["']([^"']+)["']/g;
+    let match;
+    while ((match = importRegex.exec(source)) !== null) {
+        for (const raw of match[1].split(",")) {
+            const spec = raw.trim();
+            if (!spec)
+                continue;
+            const asMatch = /^([A-Za-z_$][\w$]*)\s+as\s+([A-Za-z_$][\w$]*)$/.exec(spec);
+            const imported = asMatch ? asMatch[1] : spec;
+            const local = asMatch ? asMatch[2] : spec;
+            if (local === localName)
+                return { imported, from: match[2] };
+        }
+    }
+    return null;
+}
+function resolveSpreadBody(name, source, fromFile, cache) {
+    const cacheKey = `${fromFile ?? ""}::${name}`;
+    if (cache.has(cacheKey))
+        return cache.get(cacheKey);
+    let result = extractAssignedObjectLiteral(source, name)?.body ?? null;
+    if (result === null && fromFile) {
+        const namedImport = findNamedImportSpecifier(source, name);
+        if (namedImport) {
+            const file = resolveModuleFile(fromFile, namedImport.from);
+            if (file) {
+                try {
+                    const fileSource = readFileSync(file, "utf8");
+                    result = extractAssignedObjectLiteral(fileSource, namedImport.imported)?.body ?? null;
+                }
+                catch {
+                    result = null;
+                }
+            }
+        }
+    }
+    cache.set(cacheKey, result);
+    return result;
+}
+function resolveSpreadBodies(mainBody, source, fromFile, cache) {
+    const bodies = [mainBody];
+    let hasUnresolvedSpread = false;
+    for (const name of findTopLevelSpreadNames(mainBody)) {
+        const resolved = resolveSpreadBody(name, source, fromFile, cache);
+        if (resolved !== null)
+            bodies.push(resolved);
+        else
+            hasUnresolvedSpread = true;
+    }
+    return { bodies, hasUnresolvedSpread };
+}
 export function extractFieldValue(body, key) {
-    const keyMatch = new RegExp(`(^|[\\s{,])${key}\\s*:`).exec(body);
+    const keyMatch = new RegExp(`(^|[\\s{,])${key}\\s*:`).exec(maskCommentsAndStrings(body));
     if (!keyMatch)
         return null;
     const start = keyMatch.index + keyMatch[0].length;
@@ -139,10 +409,20 @@ function evaluateValue(value, env) {
     }
     return { ok: true };
 }
-function checkField(body, path, key, severity, env, baseLine) {
+function checkField(bodies, hasUnresolvedSpread, path, key, severity, env, baseLine) {
     const field = `${path}.${key}`;
-    const found = extractFieldValue(body, key);
+    let found = null;
+    let fromMainBody = false;
+    for (let index = 0; index < bodies.length; index += 1) {
+        found = extractFieldValue(bodies[index], key);
+        if (found) {
+            fromMainBody = index === 0;
+            break;
+        }
+    }
     if (!found) {
+        if (hasUnresolvedSpread)
+            return null;
         return { field, severity, reason: "missing from the config" };
     }
     const verdict = evaluateValue(found.value, env);
@@ -153,7 +433,7 @@ function checkField(body, path, key, severity, env, baseLine) {
         severity,
         reason: verdict.reason,
         ...(verdict.envVar ? { envVar: verdict.envVar } : {}),
-        lineNumber: baseLine + found.lineNumber - 1,
+        ...(fromMainBody ? { lineNumber: baseLine + found.lineNumber - 1 } : {}),
     };
 }
 export function formatFirebaseAuthConfigMessage(issues, intlConfigPath) {
@@ -209,23 +489,26 @@ export function checkFirebaseAuthConfig(options = {}) {
     }
     const baseLine = source.slice(0, firebaseAuth.start).split("\n").length;
     const issues = [];
+    const resolveCache = new Map();
+    const { bodies: authBodies, hasUnresolvedSpread: authHasUnresolvedSpread } = resolveSpreadBodies(firebaseAuth.body, source, options.intlConfigPath, resolveCache);
     for (const key of REQUIRED_AUTH_FIELDS) {
-        const issue = checkField(firebaseAuth.body, "firebaseAuth", key, "error", env, baseLine);
+        const issue = checkField(authBodies, authHasUnresolvedSpread, "firebaseAuth", key, "error", env, baseLine);
         if (issue)
             issues.push(issue);
     }
     const appCheck = extractObjectLiteral(firebaseAuth.body, "appCheck");
     if (appCheck) {
         const appCheckLine = baseLine + firebaseAuth.body.slice(0, appCheck.start).split("\n").length - 1;
-        const optedOut = /reportMissingServerCredentials\s*:\s*false/.test(appCheck.body);
+        const optedOut = /reportMissingServerCredentials\s*:\s*false/.test(maskCommentsAndStrings(appCheck.body));
+        const { bodies: appCheckBodies, hasUnresolvedSpread: appCheckHasUnresolvedSpread } = resolveSpreadBodies(appCheck.body, source, options.intlConfigPath, resolveCache);
         if (!optedOut) {
             for (const key of REQUIRED_APP_CHECK_FIELDS) {
-                const issue = checkField(appCheck.body, "firebaseAuth.appCheck", key, "warning", env, appCheckLine);
+                const issue = checkField(appCheckBodies, appCheckHasUnresolvedSpread, "firebaseAuth.appCheck", key, "warning", env, appCheckLine);
                 if (issue)
                     issues.push(issue);
             }
-            const privateKey = checkField(appCheck.body, "firebaseAuth.appCheck", "privateKey", "warning", env, appCheckLine);
-            const triple = OAUTH_TRIPLE.map((key) => checkField(appCheck.body, "firebaseAuth.appCheck", key, "warning", env, appCheckLine));
+            const privateKey = checkField(appCheckBodies, appCheckHasUnresolvedSpread, "firebaseAuth.appCheck", "privateKey", "warning", env, appCheckLine);
+            const triple = OAUTH_TRIPLE.map((key) => checkField(appCheckBodies, appCheckHasUnresolvedSpread, "firebaseAuth.appCheck", key, "warning", env, appCheckLine));
             if (privateKey && triple.some((issue) => issue !== null)) {
                 const partialTriple = triple.some((issue) => issue === null);
                 if (partialTriple) {

package/dist/src/vite/firebase_auth_check_plugin.js

@@ -27,7 +27,7 @@ export function firebaseAuthCheckPlugin(options = {}) {
             if (report.issues.length === 0)
                 return;
             console.warn(report.formattedMessage);
-            if (!report.valid && options.strict) {
+            if (!report.valid && options.strict !== false) {
                 throw new Error("[cloudflare-next-intl] Build failed: `firebaseAuth` config is incomplete. See details above.");
             }
         },

package/package.json

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