cloudflare-next-intl 0.9.53 → 0.9.55

package/dist/src/client/components/client_provider.js

@@ -3,13 +3,14 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { setLocaleCache, setMessageForLocaleCache } from "../../general/cache_variables.js";
 import { createContext, useMemo } from "react";
 import dynamic from "next/dynamic.js";
+import useLazyWrappingProvider from "./use_lazy_wrapping_provider.js";
 import config from "@intl-config";
 import installConsoleErrorOverride from "../../error_handling/install_console_error_override.js";
 import installGlobalErrorOverride from "../../error_handling/install_global_error_override.js";
 export const LocaleContext = createContext(undefined);
-const AuthUserProvider = dynamic(() => import("../../firebase_auth/client/auth_user_provider.js"));
+const loadAuthUserProvider = () => import("../../firebase_auth/client/auth_user_provider.js");
 const AutoFirebasePerformanceEvents = dynamic(() => import("../../firebase_auth/client/components/auto_firebase_performance_events.js"));
-const CookieConsentProvider = dynamic(() => import("../../cookie_consent/client/cookie_consent_provider.js"));
+const loadCookieConsentProvider = () => import("../../cookie_consent/client/cookie_consent_provider.js");
 const CookieConsentAnalytics = dynamic(() => import("../../cookie_consent/client/components/cookie_consent_analytics.js"));
 const AutoAnalyticsEvents = dynamic(() => import("../../cookie_consent/client/components/auto_analytics_events.js"));
 const CookieConsentDialog = dynamic(() => import("../../cookie_consent/client/components/cookie_consent_dialog.js"));
@@ -19,12 +20,14 @@ export default function LocationzationClientProvider({ language, messages, initi
     setMessageForLocaleCache(language, messages);
     installConsoleErrorOverride(config, true);
     installGlobalErrorOverride(config);
+    const { Provider: AuthUserProvider } = useLazyWrappingProvider(loadAuthUserProvider);
+    const { Provider: CookieConsentProvider, isReady: cookieConsentReady } = useLazyWrappingProvider(loadCookieConsentProvider);
     let providedChildren = children;
     if (config.firebaseAuth && !skipAuthProvider) {
         providedChildren = _jsxs(AuthUserProvider, { initialUser: initialAuthUser, children: [children, config.firebaseAuth.performance !== false && _jsx(AutoFirebasePerformanceEvents, {})] });
     }
     if (config.cookieConsent) {
-        providedChildren = _jsxs(CookieConsentProvider, { requiresConsent: requiresConsent, children: [providedChildren, analyticsConfig && _jsx(CookieConsentAnalytics, { config: analyticsConfig }), analyticsConfig && (analyticsConfig.googleAnalyticsId || analyticsConfig.googleAdsId) && _jsx(AutoAnalyticsEvents, { config: autoAnalyticsEventsConfig }), autoWireDialogs && _jsx(CookieConsentDialog, { ...dialogProps }), autoWireDialogs && _jsx(PrivacyPolicyUpdateDialog, { ...updateDialogProps })] });
+        providedChildren = _jsxs(CookieConsentProvider, { requiresConsent: requiresConsent, children: [providedChildren, cookieConsentReady && analyticsConfig && _jsx(CookieConsentAnalytics, { config: analyticsConfig }), cookieConsentReady && analyticsConfig && (analyticsConfig.googleAnalyticsId || analyticsConfig.googleAdsId) && _jsx(AutoAnalyticsEvents, { config: autoAnalyticsEventsConfig }), cookieConsentReady && autoWireDialogs && _jsx(CookieConsentDialog, { ...dialogProps }), cookieConsentReady && autoWireDialogs && _jsx(PrivacyPolicyUpdateDialog, { ...updateDialogProps })] });
     }
     const contextValue = useMemo(() => ({ language, messages }), [language, messages]);
     return _jsx(LocaleContext.Provider, { value: contextValue, children: providedChildren });

package/dist/src/client/components/client_provider_static.js

@@ -3,11 +3,12 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { setLocaleCache, setMessageForLocaleCache } from "../../general/cache_variables.js";
 import { createContext, useMemo } from "react";
 import dynamic from "next/dynamic.js";
+import useLazyWrappingProvider from "./use_lazy_wrapping_provider.js";
 import config from "@intl-config";
 import installConsoleErrorOverride from "../../error_handling/install_console_error_override.js";
 import installGlobalErrorOverride from "../../error_handling/install_global_error_override.js";
 export const LocaleContext = createContext(undefined);
-const CookieConsentProvider = dynamic(() => import("../../cookie_consent/client/cookie_consent_provider.js"));
+const loadCookieConsentProvider = () => import("../../cookie_consent/client/cookie_consent_provider.js");
 const CookieConsentAnalytics = dynamic(() => import("../../cookie_consent/client/components/cookie_consent_analytics.js"));
 const AutoAnalyticsEvents = dynamic(() => import("../../cookie_consent/client/components/auto_analytics_events.js"));
 const CookieConsentDialog = dynamic(() => import("../../cookie_consent/client/components/cookie_consent_dialog.js"));
@@ -17,9 +18,10 @@ export default function LocationzationClientProvider({ language, messages, analy
     setMessageForLocaleCache(language, messages);
     installConsoleErrorOverride(config, true);
     installGlobalErrorOverride(config);
+    const { Provider: CookieConsentProvider, isReady: cookieConsentReady } = useLazyWrappingProvider(loadCookieConsentProvider);
     let providedChildren = children;
     if (config.cookieConsent) {
-        providedChildren = _jsxs(CookieConsentProvider, { requiresConsent: requiresConsent, children: [providedChildren, analyticsConfig && _jsx(CookieConsentAnalytics, { config: analyticsConfig }), analyticsConfig && (analyticsConfig.googleAnalyticsId || analyticsConfig.googleAdsId) && _jsx(AutoAnalyticsEvents, { config: autoAnalyticsEventsConfig }), autoWireDialogs && _jsx(CookieConsentDialog, { ...dialogProps }), autoWireDialogs && _jsx(PrivacyPolicyUpdateDialog, { ...updateDialogProps })] });
+        providedChildren = _jsxs(CookieConsentProvider, { requiresConsent: requiresConsent, children: [providedChildren, cookieConsentReady && analyticsConfig && _jsx(CookieConsentAnalytics, { config: analyticsConfig }), cookieConsentReady && analyticsConfig && (analyticsConfig.googleAnalyticsId || analyticsConfig.googleAdsId) && _jsx(AutoAnalyticsEvents, { config: autoAnalyticsEventsConfig }), cookieConsentReady && autoWireDialogs && _jsx(CookieConsentDialog, { ...dialogProps }), cookieConsentReady && autoWireDialogs && _jsx(PrivacyPolicyUpdateDialog, { ...updateDialogProps })] });
     }
     const contextValue = useMemo(() => ({ language, messages }), [language, messages]);
     return _jsx(LocaleContext.Provider, { value: contextValue, children: providedChildren });

package/dist/src/client/components/use_lazy_wrapping_provider.d.ts

@@ -0,0 +1,12 @@
+import { type ComponentType } from "react";
+type ModuleLoader<P> = () => Promise<{
+    default: ComponentType<P>;
+}>;
+export interface LazyWrappingProviderResult<P extends Record<string, unknown>> {
+    Provider: ComponentType<P & {
+        children?: React.ReactNode;
+    }>;
+    isReady: boolean;
+}
+export default function useLazyWrappingProvider<P extends Record<string, unknown>>(loader: ModuleLoader<P>): LazyWrappingProviderResult<P>;
+export {};

package/dist/src/client/components/use_lazy_wrapping_provider.js

@@ -0,0 +1,34 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useEffect, useRef, useState } from "react";
+const settledCache = new Map();
+export default function useLazyWrappingProvider(loader) {
+    const opaqueLoader = loader;
+    const resolvedRef = useRef(settledCache.get(opaqueLoader) ?? null);
+    const [isReady, setIsReady] = useState(resolvedRef.current !== null);
+    useEffect(() => {
+        if (resolvedRef.current)
+            return;
+        let cancelled = false;
+        loader().then((mod) => {
+            if (cancelled)
+                return;
+            settledCache.set(opaqueLoader, mod.default);
+            resolvedRef.current = mod.default;
+            setIsReady(true);
+        });
+        return () => {
+            cancelled = true;
+        };
+    }, []);
+    const wrapperRef = useRef(null);
+    if (!wrapperRef.current) {
+        wrapperRef.current = function LazyWrappingProvider({ children, ...props }) {
+            const Resolved = resolvedRef.current;
+            if (!Resolved)
+                return children;
+            return _jsx(Resolved, { ...props, children: children });
+        };
+    }
+    return { Provider: wrapperRef.current, isReady };
+}

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.55",
   "description": "Optimized Next Intl Package Special for App Router and Cloudflare",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",