cloudflare-next-intl 0.9.53 → 0.9.54

package/dist/src/locale_params_check/check_locale_params.js

@@ -1,10 +1,11 @@
 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 { insertLocaleParamsSignature, insertLocaleParamsBody, ensureLocaleInParamsType, addParamsPropToExistingDestructure, ensureSetLocaleImport, wrapSyncDefaultExportWithParams, extractParamsPromiseType } 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 SYNC_DEFAULT_EXPORT = /export\s+default\s+function\s+[A-Za-z_$][\w$]*\s*\(/;
 const LEGEND = '✓ Set up   + Added   ? Needs manual edit   · Skipped';
 function actionGlyph(action) {
     switch (action) {
@@ -76,6 +77,18 @@ export async function checkLocaleParams(options, io = {}) {
             reports.push({ file, action: 'would-add-locale-params' });
             continue;
         }
+        const isSyncDefaultExport = !detection.hasInlineDestructure && SYNC_DEFAULT_EXPORT.test(source);
+        if (isSyncDefaultExport && (isZeroArg || canAddParamsKey || canReuseExistingParams)) {
+            const existingParamsType = canReuseExistingParams ? extractParamsPromiseType(source) ?? undefined : undefined;
+            const wrapped = wrapSyncDefaultExportWithParams(source, localeParam, existingParamsType);
+            if (wrapped === source) {
+                reports.push({ file, action: 'needs-manual-edit' });
+                continue;
+            }
+            writeFile(file, ensureSetLocaleImport(wrapped));
+            reports.push({ file, action: 'added-locale-params' });
+            continue;
+        }
         let updated = source;
         if (isZeroArg) {
             updated = insertLocaleParamsSignature(updated, localeParam);

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

@@ -1,5 +1,7 @@
 export declare function insertLocaleParamsSignature(sourceText: string, localeParam: string): string;
+export declare function wrapSyncDefaultExportWithParams(sourceText: string, localeParam: string, existingParamsType?: 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 extractParamsPromiseType(sourceText: string): string | null;
 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

@@ -18,7 +18,134 @@ export function insertLocaleParamsSignature(sourceText, localeParam) {
     const replacement = `({ params }: {\n    params: Promise<{ ${localeParam}: Language }>;\n})`;
     return sourceText.slice(0, parensStart) + replacement + sourceText.slice(parensEnd);
 }
+const SYNC_DEFAULT_EXPORT_FUNCTION = /export\s+default\s+function\s+([A-Za-z_$][\w$]*)\s*\(/;
+function findUnusedContentName(sourceText, baseName) {
+    let candidate = `${baseName}ContentCloudflareNextIntl`;
+    let suffix = 2;
+    while (new RegExp(`\\b${candidate}\\b`).test(sourceText)) {
+        candidate = `${baseName}ContentCloudflareNextIntl${suffix}`;
+        suffix += 1;
+    }
+    return candidate;
+}
 const DEFAULT_EXPORT_FUNCTION_OPEN_PAREN = /export\s+default\s+(?:async\s+)?function\s+[A-Za-z_$][\w$]*\s*\(/;
+function findParamListSpan(sourceText) {
+    const openParenMatch = DEFAULT_EXPORT_FUNCTION_OPEN_PAREN.exec(sourceText);
+    if (openParenMatch === null)
+        return null;
+    const start = openParenMatch.index + openParenMatch[0].length - 1;
+    let depth = 0;
+    for (let i = start; i < sourceText.length; i++) {
+        if (sourceText[i] === '(')
+            depth++;
+        else if (sourceText[i] === ')') {
+            depth--;
+            if (depth === 0)
+                return { start, end: i + 1 };
+        }
+    }
+    return null;
+}
+function destructuredKeyNames(inner) {
+    const names = [];
+    let depth = 0;
+    let start = 0;
+    const parts = [];
+    for (let i = 0; i <= inner.length; i++) {
+        const char = inner[i];
+        if (i === inner.length || (char === ',' && depth === 0)) {
+            parts.push(inner.slice(start, i));
+            start = i + 1;
+            continue;
+        }
+        if (char === '{' || char === '(' || char === '[')
+            depth++;
+        else if (char === '}' || char === ')' || char === ']')
+            depth--;
+    }
+    for (const part of parts) {
+        const trimmed = part.trim();
+        if (trimmed === '' || trimmed.startsWith('...'))
+            continue;
+        const key = trimmed.split(':')[0].split('=')[0].trim();
+        if (/^[A-Za-z_$][\w$]*$/.test(key))
+            names.push(key);
+    }
+    return names;
+}
+export function wrapSyncDefaultExportWithParams(sourceText, localeParam, existingParamsType) {
+    const nameMatch = SYNC_DEFAULT_EXPORT_FUNCTION.exec(sourceText);
+    if (nameMatch === null)
+        return sourceText;
+    const name = nameMatch[1];
+    const paramList = findParamListSpan(sourceText);
+    if (paramList === null)
+        return sourceText;
+    const bodyStart = findFunctionBodyStart(sourceText);
+    if (bodyStart === null)
+        return sourceText;
+    const bodyEnd = findMatchingBraceEnd(sourceText, bodyStart - 1);
+    if (bodyEnd === null)
+        return sourceText;
+    const contentName = findUnusedContentName(sourceText, name);
+    const originalParams = sourceText.slice(paramList.start, paramList.end);
+    const originalBody = sourceText.slice(bodyStart, bodyEnd - 1);
+    let forwardKeys = [];
+    let forwardKeyTypes = [];
+    if (originalParams !== '()') {
+        const openBrace = originalParams.indexOf('{');
+        if (openBrace === -1)
+            return sourceText;
+        const keysEnd = findMatchingBraceEnd(originalParams, openBrace);
+        if (keysEnd === null)
+            return sourceText;
+        forwardKeys = destructuredKeyNames(originalParams.slice(openBrace + 1, keysEnd - 1));
+        let j = keysEnd;
+        while (j < originalParams.length && /\s/.test(originalParams[j]))
+            j++;
+        if (originalParams[j] === ':') {
+            j++;
+            while (j < originalParams.length && /\s/.test(originalParams[j]))
+                j++;
+            if (originalParams[j] === '{') {
+                const typeEnd = findMatchingBraceEnd(originalParams, j);
+                if (typeEnd !== null) {
+                    const typeBody = originalParams.slice(j + 1, typeEnd - 1).trim();
+                    forwardKeyTypes = typeBody === '' ? [] : typeBody.split(';').map((s) => s.trim()).filter(Boolean);
+                }
+            }
+        }
+    }
+    const otherForwardKeys = forwardKeys.filter((key) => key !== 'params');
+    const otherForwardKeyTypes = forwardKeyTypes.filter((type) => !/^params\s*:/.test(type));
+    const contentFunction = `function ${contentName}${originalParams} {${originalBody}}`;
+    const alreadyHasLocaleParam = existingParamsType !== undefined && new RegExp(`\\b${localeParam}\\b`).test(existingParamsType);
+    const wrapperParamsType = existingParamsType === undefined
+        ? `${localeParam}: Language`
+        : alreadyHasLocaleParam
+            ? existingParamsType
+            : `${existingParamsType.replace(/;?\s*$/, '')}; ${localeParam}: Language`;
+    const wrapperSignature = otherForwardKeys.length === 0 ? `{ params }` : `{ ${otherForwardKeys.join(', ')}, params }`;
+    const forwardedJsx = forwardKeys.map((key) => (key === 'params' ? ` params={params}` : ` ${key}={${key}}`)).join('');
+    const forwardedTypeLines = otherForwardKeyTypes.map((type) => `    ${type.replace(/;?\s*$/, '')};`);
+    const wrapperFunction = [
+        `// Auto-inserted by cloudflare-next-intl's checkLocaleParams (mode: "fix") — `
+            + `"${name}" was split into this async wrapper plus the sync "${contentName}" above `
+            + `it (see that function's own body, unchanged) so \`await params\` never lands in a `
+            + `function this scan didn't confirm was safe to make async. To opt this file out on a `
+            + `later run, pass it in checkLocaleParams' \`skip\` list instead of hand-editing here.`,
+        `export default async function ${name}(${wrapperSignature}: {`,
+        ...forwardedTypeLines,
+        `    params: Promise<{ ${wrapperParamsType} }>;`,
+        `}) {`,
+        `    const { ${localeParam} } = await params;`,
+        `    setLocale(${localeParam});`,
+        ``,
+        `    return <${contentName}${forwardedJsx} />;`,
+        `}`,
+    ].join('\n');
+    return sourceText.slice(0, nameMatch.index) + contentFunction + '\n\n' + wrapperFunction + sourceText.slice(bodyEnd);
+}
 function findMatchingBraceEnd(code, openBraceIndex) {
     let depth = 0;
     for (let i = openBraceIndex; i < code.length; i++) {
@@ -90,6 +217,9 @@ export function insertLocaleParamsBody(sourceText, localeParam, hasInlineDestruc
     return sourceText.slice(0, bodyStart) + line + sourceText.slice(bodyStart);
 }
 const PARAMS_PROMISE_TYPE = /params\s*:\s*Promise<\{([^}]*)\}>/;
+export function extractParamsPromiseType(sourceText) {
+    return PARAMS_PROMISE_TYPE.exec(sourceText)?.[1]?.trim() ?? null;
+}
 export function ensureLocaleInParamsType(sourceText, localeParam) {
     const match = PARAMS_PROMISE_TYPE.exec(sourceText);
     if (match === null)

package/package.json

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