cloudflare-next-intl 0.7.1 → 0.7.3

package/README.md

@@ -247,12 +247,23 @@ export async function generateMetadata({ params }) {
 
 ### Theme switcher
 
+### Firebase Auth
+
+Set `firebaseAuth` on your `RoutingConfig` to enable — `IntlProvider` then
+auto-wires `AuthUserProvider` and server-side `getAuthUser` session validation.
+
+Features include:
+- `createForgotPasswordAction(locale, actionCodeSettings?)`: Accepts optional Firebase `AuthActionCodeSettings` (e.g. `url` redirect link).
+- `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).
+
 ```tsx
 import ThemeSwitcher from "cloudflare-next-intl/ThemeSwitcher";
 
 <ThemeSwitcher lightLabelText="Light" darkLabelText="Dark" />
 ```
 
+
 ### Cookie consent
 
 Set `cookieConsent` on your `RoutingConfig` to enable — `IntlProvider` then

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

@@ -1,6 +1,6 @@
 import type { TranslationObject } from "../../types/types";
 import type { SerializedAuthUser } from "../../firebase_auth/types";
-import type { CookieConsentAnalyticsConfig } from "../../types/types";
+import type { CookieConsentAnalyticsConfig, AutoAnalyticsEventsConfig } from "../../types/types";
 import type { CookieConsentDialogProps } from "../../cookie_consent/client/components/cookie_consent_dialog";
 import type { PrivacyPolicyUpdateDialogProps } from "../../cookie_consent/client/components/privacy_policy_update_dialog";
 interface LocaleContextType {
@@ -8,7 +8,7 @@ interface LocaleContextType {
     messages: TranslationObject;
 }
 export declare const LocaleContext: import("react").Context<LocaleContextType | undefined>;
-export default function LocationzationClientProvider({ language, messages, initialAuthUser, skipAuthProvider, analyticsConfig, requiresConsent, autoWireDialogs, dialogProps, updateDialogProps, children }: {
+export default function LocationzationClientProvider({ language, messages, initialAuthUser, skipAuthProvider, analyticsConfig, autoAnalyticsEventsConfig, requiresConsent, autoWireDialogs, dialogProps, updateDialogProps, children }: {
     language: string;
     messages: TranslationObject;
     initialAuthUser?: SerializedAuthUser | null;
@@ -16,6 +16,8 @@ export default function LocationzationClientProvider({ language, messages, initi
     skipAuthProvider?: boolean;
     /** Resolved server-side from `cookieConsent.analytics`/`getAnalytics` when `autoWireAnalytics` isn't `false`. */
     analyticsConfig?: CookieConsentAnalyticsConfig;
+    /** From `cookieConsent.autoAnalyticsEvents` — forwarded as-is to the auto-wired `AutoAnalyticsEvents`. */
+    autoAnalyticsEventsConfig?: AutoAnalyticsEventsConfig;
     /**
      * Resolved server-side from `cookieConsent.getCountryCode`/`gdprCountries`.
      * `false` means the visitor's country doesn't require the consent

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

@@ -15,11 +15,13 @@ export const LocaleContext = createContext(undefined);
 // update (and a `getIdToken(true)` refresh) that causes another render —
 // an infinite loop of session-cookie writes, one per render.
 const AuthUserProvider = dynamic(() => import("../../firebase_auth/client/auth_user_provider"));
+const AutoFirebasePerformanceEvents = dynamic(() => import("../../firebase_auth/client/components/auto_firebase_performance_events"));
 const CookieConsentProvider = dynamic(() => import("../../cookie_consent/client/cookie_consent_provider"));
 const CookieConsentAnalytics = dynamic(() => import("../../cookie_consent/client/components/cookie_consent_analytics"));
+const AutoAnalyticsEvents = dynamic(() => import("../../cookie_consent/client/components/auto_analytics_events"));
 const CookieConsentDialog = dynamic(() => import("../../cookie_consent/client/components/cookie_consent_dialog"));
 const PrivacyPolicyUpdateDialog = dynamic(() => import("../../cookie_consent/client/components/privacy_policy_update_dialog"));
-export default function LocationzationClientProvider({ language, messages, initialAuthUser = null, skipAuthProvider = false, analyticsConfig, requiresConsent = true, autoWireDialogs = true, dialogProps, updateDialogProps, children }) {
+export default function LocationzationClientProvider({ language, messages, initialAuthUser = null, skipAuthProvider = false, analyticsConfig, autoAnalyticsEventsConfig, requiresConsent = true, autoWireDialogs = true, dialogProps, updateDialogProps, children }) {
     setLocaleCache(language);
     setMessageForLocaleCache(language, messages);
     installConsoleErrorOverride(config, true);
@@ -31,10 +33,10 @@ export default function LocationzationClientProvider({ language, messages, initi
     // the provider.
     let providedChildren = children;
     if (config.firebaseAuth && !skipAuthProvider) {
-        providedChildren = _jsx(AuthUserProvider, { initialUser: initialAuthUser, children: children });
+        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 }), autoWireDialogs && _jsx(CookieConsentDialog, { ...dialogProps }), autoWireDialogs && _jsx(PrivacyPolicyUpdateDialog, { ...updateDialogProps })] });
+        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 })] });
     }
     const contextValue = useMemo(() => ({ language, messages }), [language, messages]);
     return _jsx(LocaleContext.Provider, { value: contextValue, children: providedChildren });

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

@@ -1,5 +1,5 @@
 import type { TranslationObject } from "../../types/types";
-import type { CookieConsentAnalyticsConfig } from "../../types/types";
+import type { CookieConsentAnalyticsConfig, AutoAnalyticsEventsConfig } from "../../types/types";
 import type { CookieConsentDialogProps } from "../../cookie_consent/client/components/cookie_consent_dialog";
 import type { PrivacyPolicyUpdateDialogProps } from "../../cookie_consent/client/components/privacy_policy_update_dialog";
 interface LocaleContextType {
@@ -7,11 +7,13 @@ interface LocaleContextType {
     messages: TranslationObject;
 }
 export declare const LocaleContext: import("react").Context<LocaleContextType | undefined>;
-export default function LocationzationClientProvider({ language, messages, analyticsConfig, requiresConsent, autoWireDialogs, dialogProps, updateDialogProps, children }: {
+export default function LocationzationClientProvider({ language, messages, analyticsConfig, autoAnalyticsEventsConfig, requiresConsent, autoWireDialogs, dialogProps, updateDialogProps, children }: {
     language: string;
     messages: TranslationObject;
     /** Resolved server-side from `cookieConsent.analytics`/`getAnalytics` when `autoWireAnalytics` isn't `false`. */
     analyticsConfig?: CookieConsentAnalyticsConfig;
+    /** From `cookieConsent.autoAnalyticsEvents` — forwarded as-is to the auto-wired `AutoAnalyticsEvents`. */
+    autoAnalyticsEventsConfig?: AutoAnalyticsEventsConfig;
     /**
      * Resolved server-side from `cookieConsent.getCountryCode`/`gdprCountries`.
      * `false` means the visitor's country doesn't require the consent

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

@@ -17,16 +17,17 @@ export const LocaleContext = createContext(undefined);
 // for the full explanation.
 const CookieConsentProvider = dynamic(() => import("../../cookie_consent/client/cookie_consent_provider"));
 const CookieConsentAnalytics = dynamic(() => import("../../cookie_consent/client/components/cookie_consent_analytics"));
+const AutoAnalyticsEvents = dynamic(() => import("../../cookie_consent/client/components/auto_analytics_events"));
 const CookieConsentDialog = dynamic(() => import("../../cookie_consent/client/components/cookie_consent_dialog"));
 const PrivacyPolicyUpdateDialog = dynamic(() => import("../../cookie_consent/client/components/privacy_policy_update_dialog"));
-export default function LocationzationClientProvider({ language, messages, analyticsConfig, requiresConsent = true, autoWireDialogs = true, dialogProps, updateDialogProps, children }) {
+export default function LocationzationClientProvider({ language, messages, analyticsConfig, autoAnalyticsEventsConfig, requiresConsent = true, autoWireDialogs = true, dialogProps, updateDialogProps, children }) {
     setLocaleCache(language);
     setMessageForLocaleCache(language, messages);
     installConsoleErrorOverride(config, true);
     installGlobalErrorOverride(config);
     let providedChildren = children;
     if (config.cookieConsent) {
-        providedChildren = _jsxs(CookieConsentProvider, { requiresConsent: requiresConsent, children: [providedChildren, analyticsConfig && _jsx(CookieConsentAnalytics, { config: analyticsConfig }), autoWireDialogs && _jsx(CookieConsentDialog, { ...dialogProps }), autoWireDialogs && _jsx(PrivacyPolicyUpdateDialog, { ...updateDialogProps })] });
+        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 })] });
     }
     const contextValue = useMemo(() => ({ language, messages }), [language, messages]);
     return _jsx(LocaleContext.Provider, { value: contextValue, children: providedChildren });

package/dist/src/cookie_consent/client/components/auto_analytics_events.d.ts

@@ -0,0 +1,12 @@
+import type { AutoAnalyticsEventsConfig } from '../../../types/types';
+/**
+ * Auto-rendered alongside `CookieConsentAnalytics` when Google Analytics/Ads
+ * is configured — sends `screen_view` on route change and one
+ * `gtag('event', ...)` per Web Vitals metric. Gated on consent the same way
+ * as the other analytics scripts (no-ops until `gtag` exists on `window`).
+ * See `CookieConsentRoutingConfig.autoAnalyticsEvents` to disable specific
+ * events or customize `screen_name`.
+ */
+export default function AutoAnalyticsEvents({ config }: {
+    config?: AutoAnalyticsEventsConfig;
+}): React.ReactElement | null;

package/dist/src/cookie_consent/client/components/auto_analytics_events.js

@@ -0,0 +1,58 @@
+'use client';
+import { usePathname } from 'next/navigation';
+import { useReportWebVitals } from 'next/web-vitals';
+import { useEffect } from 'react';
+import useCookieConsent from '../use_cookie_consent';
+const metricEventNames = {
+    CLS: 'web_cls',
+    FCP: 'web_fcp',
+    FID: 'web_fid',
+    LCP: 'web_lcp',
+    TTFB: 'web_ttfb',
+    INP: 'web_inp',
+};
+const formatMetricValue = (name, value) => Math.round(name === 'CLS' ? value * 1000 : value);
+function gtagEvent(name, params) {
+    const w = window;
+    if (typeof w.gtag !== 'function')
+        return;
+    w.gtag('event', name, params);
+}
+/**
+ * Auto-rendered alongside `CookieConsentAnalytics` when Google Analytics/Ads
+ * is configured — sends `screen_view` on route change and one
+ * `gtag('event', ...)` per Web Vitals metric. Gated on consent the same way
+ * as the other analytics scripts (no-ops until `gtag` exists on `window`).
+ * See `CookieConsentRoutingConfig.autoAnalyticsEvents` to disable specific
+ * events or customize `screen_name`.
+ */
+export default function AutoAnalyticsEvents({ config }) {
+    const { consent, requiresConsent } = useCookieConsent();
+    const granted = consent === true || !requiresConsent;
+    const path = usePathname();
+    const screenName = config?.getScreenName ? config.getScreenName(path) : path;
+    const enabledEvents = config?.events;
+    const isEnabled = (event) => !enabledEvents || enabledEvents.includes(event);
+    useEffect(() => {
+        if (!granted)
+            return;
+        if (!isEnabled('screen_view'))
+            return;
+        gtagEvent('screen_view', { screen_name: screenName, page_path: path });
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [path, screenName, granted]);
+    useReportWebVitals((metric) => {
+        if (!granted)
+            return;
+        const eventName = metricEventNames[metric.name];
+        if (!isEnabled(eventName))
+            return;
+        gtagEvent(eventName, {
+            value: formatMetricValue(metric.name, metric.value),
+            metric_rating: metric.rating,
+            screen_name: screenName,
+            page_path: path,
+        });
+    });
+    return null;
+}

package/dist/src/firebase_auth/client/auth_actions.d.ts

@@ -1,4 +1,4 @@
-import type { AuthActionMessages, AuthFormState } from '../types';
+import type { AuthActionCodeSettings, AuthActionMessages, AuthFormState } from '../types';
 /**
  * Builds a login server action for React's `useActionState` form hook.
  * The returned function has the `(prevState, formData) => Promise<AuthFormState>`
@@ -37,10 +37,10 @@ export declare function createSignUpAction(locale: string, messages: AuthActionM
  * `formData` must contain an `email` field.
  *
  * @param locale Used to localize the returned error message.
- * @param messages Localized action messages (currently unused by this action).
+ * @param actionCodeSettings Optional settings for action email (continue URL, etc.).
  * @returns A form action: `{ success: true }` on success, `{ error }` on failure.
  * @example
- * const [state, action] = useActionState(createForgotPasswordAction(locale, messages), {});
+ * const [state, action] = useActionState(createForgotPasswordAction(locale), {});
  * <form action={action}>...</form>
  */
-export declare function createForgotPasswordAction(locale: string, messages: AuthActionMessages): (_prevState: AuthFormState, formData: FormData) => Promise<AuthFormState>;
+export declare function createForgotPasswordAction(locale: string, actionCodeSettings?: AuthActionCodeSettings): (_prevState: AuthFormState, formData: FormData) => Promise<AuthFormState>;

package/dist/src/firebase_auth/client/auth_actions.js

@@ -79,20 +79,20 @@ export function createSignUpAction(locale, messages) {
  * `formData` must contain an `email` field.
  *
  * @param locale Used to localize the returned error message.
- * @param messages Localized action messages (currently unused by this action).
+ * @param actionCodeSettings Optional settings for action email (continue URL, etc.).
  * @returns A form action: `{ success: true }` on success, `{ error }` on failure.
  * @example
- * const [state, action] = useActionState(createForgotPasswordAction(locale, messages), {});
+ * const [state, action] = useActionState(createForgotPasswordAction(locale), {});
  * <form action={action}>...</form>
  */
-export function createForgotPasswordAction(locale, messages) {
+export function createForgotPasswordAction(locale, actionCodeSettings) {
     return async function forgotPasswordAction(_prevState, formData) {
         requireFirebaseAuthConfig(config.firebaseAuth);
         const { auth } = await getFirebaseAuthClient();
         const { sendPasswordResetEmail } = await getFirebaseAuthModule();
         const email = (formData.get('email')?.toString() ?? '').trim();
         try {
-            await sendPasswordResetEmail(auth, email);
+            await sendPasswordResetEmail(auth, email, actionCodeSettings);
             return { success: true };
         }
         catch (e) {

package/dist/src/firebase_auth/client/auth_user_provider.d.ts

@@ -1,4 +1,4 @@
-import type { AuthUser, SerializedAuthUser } from '../types';
+import type { AuthActionCodeSettings, AuthUser, SerializedAuthUser } from '../types';
 export interface AuthUserContextType {
     /** Current Firebase user, or `null` if signed out (or not yet resolved while `loading`). */
     user: AuthUser | null;
@@ -7,7 +7,7 @@ export interface AuthUserContextType {
     /** Force-refreshes the current user's ID token/claims and re-syncs the session cookie. */
     reloadUser: () => Promise<void>;
     /** Sends a verification email to the currently signed-in user. */
-    sendVerificationEmail: () => Promise<void>;
+    sendVerificationEmail: (actionCodeSettings?: AuthActionCodeSettings) => Promise<void>;
     /** Signs out, clears the session cookie, and redirects to `firebaseAuth.redirectAuthPath`. */
     logout: () => Promise<void>;
 }

package/dist/src/firebase_auth/client/auth_user_provider.js

@@ -311,13 +311,13 @@ export default function AuthUserProvider({ initialUser = null, children }) {
             console.error('AuthUserProvider: reloadUser failed', e);
         }
     }, []);
-    const sendVerificationEmail = useCallback(async () => {
+    const sendVerificationEmail = useCallback(async (actionCodeSettings) => {
         const { auth } = await getFirebaseAuthClient();
         const user = auth.currentUser;
         if (!user)
             return;
         const { sendEmailVerification } = await getFirebaseAuthModule();
-        await sendEmailVerification(user);
+        await sendEmailVerification(user, actionCodeSettings);
     }, []);
     const logout = useCallback(async () => {
         try {

package/dist/src/firebase_auth/client/components/auto_firebase_performance_events.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Auto-rendered alongside `FirebaseAuthClientProvider` when
+ * `firebaseAuth.performance` isn't `false` — records Firebase Performance
+ * custom traces for Web Vitals metrics (`web_cls`, `web_fcp`, `web_fid`,
+ * `web_lcp`, `web_ttfb`, `web_inp`) and SPA route changes (`route_change`),
+ * alongside Firebase Performance's own automatic page-load/network traces.
+ * No-ops if `firebaseAuth.performance` is disabled (`getFirebasePerformanceSync`
+ * never resolves an instance).
+ */
+export default function AutoFirebasePerformanceEvents(): null;

package/dist/src/firebase_auth/client/components/auto_firebase_performance_events.js

@@ -0,0 +1,111 @@
+'use client';
+import { usePathname } from 'next/navigation';
+import { useReportWebVitals } from 'next/web-vitals';
+import { useEffect, useRef } from 'react';
+import reportError from '../../../error_handling/report_error';
+import { getFirebaseAuthClient, getFirebasePerformanceSync } from '../firebase_client';
+/**
+ * Records a Firebase Performance custom trace with a real duration, so
+ * Firebase's own duration histograms/percentiles are meaningful. No-ops if
+ * `firebaseAuth.performance` is disabled (`getFirebasePerformanceSync` never
+ * resolves an instance).
+ */
+async function recordFirebaseTrace(name, durationMs, attributes, metrics) {
+    try {
+        await getFirebaseAuthClient();
+        const performance = getFirebasePerformanceSync();
+        if (!performance)
+            return;
+        const { trace } = await import('firebase/performance');
+        const duration = Math.max(Math.round(durationMs), 1);
+        trace(performance, name).record(Date.now() - duration, duration, { attributes, metrics });
+    }
+    catch (error) {
+        void reportError(undefined, {
+            error,
+            classOrMethodName: 'recordFirebaseTrace',
+            isClient: true,
+        });
+    }
+}
+const SLOW_RESOURCE_THRESHOLD_MS = 1000;
+/**
+ * Auto-rendered alongside `FirebaseAuthClientProvider` when
+ * `firebaseAuth.performance` isn't `false` — records Firebase Performance
+ * custom traces for Web Vitals metrics (`web_cls`, `web_fcp`, `web_fid`,
+ * `web_lcp`, `web_ttfb`, `web_inp`) and SPA route changes (`route_change`),
+ * alongside Firebase Performance's own automatic page-load/network traces.
+ * No-ops if `firebaseAuth.performance` is disabled (`getFirebasePerformanceSync`
+ * never resolves an instance).
+ */
+export default function AutoFirebasePerformanceEvents() {
+    useReportWebVitals((metric) => {
+        const value = Math.round(metric.name === 'CLS' ? metric.value * 1000 : metric.value);
+        void recordFirebaseTrace(`web_${metric.name.toLowerCase()}`, value, { rating: metric.rating });
+    });
+    const path = usePathname();
+    const isFirstRoute = useRef(true);
+    const lastRouteChangeRef = useRef(Date.now());
+    const longTaskStats = useRef({ count: 0, totalDuration: 0 });
+    // Mount-only: registers a PerformanceObserver for long tasks (main-thread
+    // blocks >= 50ms). Not all browsers support the 'longtask' entry type, so
+    // this is a best-effort signal. The final route's tail of accumulated
+    // long tasks between the last route change and unmount is intentionally
+    // dropped rather than flushed here — this is a monitoring signal, not a
+    // billing metric, and an occasional dropped tail sample is acceptable.
+    useEffect(() => {
+        if (typeof PerformanceObserver === 'undefined' || !PerformanceObserver.supportedEntryTypes?.includes('longtask'))
+            return;
+        const observer = new PerformanceObserver((list) => {
+            for (const entry of list.getEntries()) {
+                longTaskStats.current.count += 1;
+                longTaskStats.current.totalDuration += entry.duration;
+            }
+        });
+        observer.observe({ type: 'longtask', buffered: true });
+        return () => observer.disconnect();
+    }, []);
+    // Mount-only: registers a PerformanceObserver for slow non-fetch/XHR
+    // resources (scripts, images, stylesheets, fonts, etc). Firebase
+    // Performance's own automatic network monitoring already instruments
+    // fetch/XHR, so those are skipped here to avoid duplicate signals.
+    // `buffered: true` also catches resources that loaded before this
+    // component mounted (it only mounts after `AuthUserProvider`).
+    useEffect(() => {
+        if (typeof PerformanceObserver === 'undefined' || !PerformanceObserver.supportedEntryTypes?.includes('resource'))
+            return;
+        const observer = new PerformanceObserver((list) => {
+            for (const entry of list.getEntries()) {
+                if (entry.initiatorType === 'fetch' || entry.initiatorType === 'xmlhttprequest')
+                    continue;
+                if (entry.duration < SLOW_RESOURCE_THRESHOLD_MS)
+                    continue;
+                void recordFirebaseTrace('slow_resource', entry.duration, {
+                    initiator_type: entry.initiatorType,
+                    resource: entry.name.slice(-100),
+                }, { transfer_size_bytes: Math.round(entry.transferSize ?? 0) });
+            }
+        });
+        observer.observe({ type: 'resource', buffered: true });
+        return () => observer.disconnect();
+    }, []);
+    useEffect(() => {
+        const now = Date.now();
+        const duration = now - lastRouteChangeRef.current;
+        lastRouteChangeRef.current = now;
+        if (isFirstRoute.current) {
+            isFirstRoute.current = false;
+            return;
+        }
+        // Approximates navigation duration as time between path-change commits —
+        // App Router exposes no public "navigation start" event this package
+        // can hook into, so this is not a precise navigation timing.
+        void recordFirebaseTrace('route_change', duration, { path: path.slice(-100) });
+        const { count, totalDuration } = longTaskStats.current;
+        longTaskStats.current = { count: 0, totalDuration: 0 };
+        if (count > 0) {
+            void recordFirebaseTrace('route_long_tasks', totalDuration, { path: path.slice(-100) }, { long_task_count: count });
+        }
+    }, [path]);
+    return null;
+}

package/dist/src/firebase_auth/client/firebase_client.d.ts

@@ -1,5 +1,6 @@
 import type { FirebaseApp } from 'firebase/app';
 import type { Auth } from 'firebase/auth';
+import type { FirebasePerformance } from 'firebase/performance';
 /**
  * Current App Check token, or `undefined` if `appCheck` isn't configured or
  * hasn't initialized yet. Forces a refresh only when the cached token is
@@ -24,5 +25,7 @@ export declare function getFirebaseAuthClientSync(): {
     app: FirebaseApp;
     auth: Auth;
 } | undefined;
+/** Synchronous read of the cached `FirebasePerformance` instance, or `undefined` if `performance` isn't enabled or hasn't initialized yet. */
+export declare function getFirebasePerformanceSync(): FirebasePerformance | undefined;
 /** Memoized `import('firebase/auth')` — see {@link getFirebaseAuthClient} for why this is worth caching. */
 export declare function getFirebaseAuthModule(): Promise<typeof import('firebase/auth')>;

package/dist/src/firebase_auth/client/firebase_client.js

@@ -2,6 +2,7 @@
 import config from '@intl-config';
 import requireFirebaseAuthConfig from '../require_config';
 let cachedAppCheck;
+let cachedPerformance;
 async function initializeFirebaseAppCheck(app, appCheckConfig) {
     const { initializeAppCheck, ReCaptchaV3Provider, ReCaptchaEnterpriseProvider } = await import('firebase/app-check');
     if (appCheckConfig.debugToken) {
@@ -45,7 +46,12 @@ export async function getFirebaseAuthClient() {
         return cached;
     if (!cachedPromise) {
         const fa = config.firebaseAuth;
-        cachedPromise = Promise.all([import('firebase/app'), import('firebase/auth')]).then(async ([{ getApp, getApps, initializeApp }, { getAuth }]) => {
+        const isPerformanceEnabled = fa.performance !== false && typeof window !== 'undefined';
+        cachedPromise = Promise.all([
+            import('firebase/app'),
+            import('firebase/auth'),
+            isPerformanceEnabled ? import('firebase/performance') : Promise.resolve(null),
+        ]).then(async ([{ getApp, getApps, initializeApp }, { getAuth }, perfModule]) => {
             const firebaseConfig = {
                 apiKey: fa.apiKey,
                 authDomain: fa.authDomain,
@@ -59,6 +65,9 @@ export async function getFirebaseAuthClient() {
             if (fa.appCheck) {
                 cachedAppCheck = await initializeFirebaseAppCheck(app, fa.appCheck);
             }
+            if (perfModule) {
+                cachedPerformance = perfModule.getPerformance(app);
+            }
             const auth = getAuth(app);
             cached = { app, auth };
             return cached;
@@ -70,6 +79,10 @@ export async function getFirebaseAuthClient() {
 export function getFirebaseAuthClientSync() {
     return cached;
 }
+/** Synchronous read of the cached `FirebasePerformance` instance, or `undefined` if `performance` isn't enabled or hasn't initialized yet. */
+export function getFirebasePerformanceSync() {
+    return cachedPerformance;
+}
 let cachedAuthModule;
 /** Memoized `import('firebase/auth')` — see {@link getFirebaseAuthClient} for why this is worth caching. */
 export function getFirebaseAuthModule() {

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

@@ -5,6 +5,6 @@ export { default as useFirebaseAuthUserServer } from './server/use_auth_user_ser
 export { createLoginAction, createSignUpAction, createForgotPasswordAction } from './client/auth_actions';
 export { default as clearFirebaseAuthSession } from './server/clear_session_action';
 export { default as updateFirebaseAuthSession, defaultSessionCookieName as firebaseAuthSessionCookieName } from './middleware/update_session';
-export { getFirebaseAuthClient } from './client/firebase_client';
+export { getFirebaseAuthClient, getFirebasePerformanceSync } from './client/firebase_client';
 export type { SerializedAuthUser, AuthFormState, AuthActionMessages, AuthUser } from './types';
 export type { FirebaseAuthRoutingConfig } from '../types/types';

package/dist/src/firebase_auth/index.js

@@ -11,4 +11,4 @@ export { default as useFirebaseAuthUserServer } from './server/use_auth_user_ser
 export { createLoginAction, createSignUpAction, createForgotPasswordAction } from './client/auth_actions';
 export { default as clearFirebaseAuthSession } from './server/clear_session_action';
 export { default as updateFirebaseAuthSession, defaultSessionCookieName as firebaseAuthSessionCookieName } from './middleware/update_session';
-export { getFirebaseAuthClient } from './client/firebase_client';
+export { getFirebaseAuthClient, getFirebasePerformanceSync } from './client/firebase_client';

package/dist/src/firebase_auth/middleware/update_session.js

@@ -240,7 +240,37 @@ export default async function updateSession(request, baseResponse, locale, rebui
     if (fa.actionLinkRedirectEnabled !== false && isEligibleActionPath) {
         const mode = request.nextUrl.searchParams.get('mode');
         if (mode) {
-            const target = resolveActionModePaths(fa)[mode];
+            let target = resolveActionModePaths(fa)[mode];
+            if (fa.followSameOriginContinueUrl !== false) {
+                const continueUrl = request.nextUrl.searchParams.get('continueUrl');
+                if (continueUrl) {
+                    try {
+                        const parsed = new URL(continueUrl, request.url);
+                        if (parsed.origin === request.nextUrl.origin) {
+                            let continuePath = parsed.pathname;
+                            if (locale !== config.defaultLocale) {
+                                if (continuePath.startsWith(`/${locale}/`)) {
+                                    continuePath = continuePath.slice(locale.length + 1);
+                                }
+                                else if (continuePath === `/${locale}`) {
+                                    continuePath = '/';
+                                }
+                            }
+                            if (continuePath !== '/') {
+                                target = continuePath;
+                            }
+                        }
+                        else {
+                            // External continueUrl: redirect directly to the full external URL
+                            parsed.search = request.nextUrl.search;
+                            return buildRedirect(baseResponse, parsed);
+                        }
+                    }
+                    catch {
+                        // Invalid continueUrl format — fall back to resolved mode target
+                    }
+                }
+            }
             // Skip when already on the destination — the forward sets the same
             // `?mode=` it matched on, so redirecting again would loop forever.
             if (target && target !== path) {

package/dist/src/firebase_auth/types.d.ts

@@ -20,3 +20,18 @@ export interface AuthActionMessages {
     mismatch?: string;
 }
 export type AuthUser = User | SerializedAuthUser;
+/** Settings for configuring action code emails (password reset, email verification). */
+export interface AuthActionCodeSettings {
+    url: string;
+    handleCodeInApp?: boolean;
+    iOS?: {
+        bundleId: string;
+    };
+    android?: {
+        packageName: string;
+        installApp?: boolean;
+        minimumVersion?: string;
+    };
+    dynamicLinkDomain?: string;
+    linkDomain?: string;
+}

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

@@ -161,5 +161,5 @@ export default async function LocationzationProvider({ language, messages, stati
             }
         }
     }
-    return _jsx(LocationzationClientProvider, { language: language, messages: messagesValue, initialAuthUser: initialAuthUser, skipAuthProvider: !autoWireClientProvider, analyticsConfig: analyticsConfig, requiresConsent: requiresConsent, autoWireDialogs: config.cookieConsent?.autoWireDialogs !== false, dialogProps: config.cookieConsent?.dialogProps, updateDialogProps: config.cookieConsent?.updateDialogProps, children: children });
+    return _jsx(LocationzationClientProvider, { language: language, messages: messagesValue, initialAuthUser: initialAuthUser, skipAuthProvider: !autoWireClientProvider, analyticsConfig: analyticsConfig, autoAnalyticsEventsConfig: config.cookieConsent?.autoAnalyticsEvents, requiresConsent: requiresConsent, autoWireDialogs: config.cookieConsent?.autoWireDialogs !== false, dialogProps: config.cookieConsent?.dialogProps, updateDialogProps: config.cookieConsent?.updateDialogProps, children: children });
 }

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

@@ -104,5 +104,5 @@ export default async function LocationzationProvider({ language, messages, child
             }
         }
     }
-    return _jsx(LocationzationClientProvider, { language: language, messages: messagesValue, analyticsConfig: analyticsConfig, requiresConsent: requiresConsent, autoWireDialogs: config.cookieConsent?.autoWireDialogs !== false, dialogProps: config.cookieConsent?.dialogProps, updateDialogProps: config.cookieConsent?.updateDialogProps, children: children });
+    return _jsx(LocationzationClientProvider, { language: language, messages: messagesValue, analyticsConfig: analyticsConfig, autoAnalyticsEventsConfig: config.cookieConsent?.autoAnalyticsEvents, requiresConsent: requiresConsent, autoWireDialogs: config.cookieConsent?.autoWireDialogs !== false, dialogProps: config.cookieConsent?.dialogProps, updateDialogProps: config.cookieConsent?.updateDialogProps, children: children });
 }

package/dist/src/types/types.d.ts

@@ -308,6 +308,16 @@ export interface CookieConsentRoutingConfig {
      * `undefined` in the returned object disables that provider's script.
      */
     getAnalytics?: () => CookieConsentAnalyticsConfig | Promise<CookieConsentAnalyticsConfig>;
+    /**
+     * Configures automatic `screen_view` (on route change) and Web Vitals
+     * (`web_cls`/`web_fcp`/`web_fid`/`web_lcp`/`web_ttfb`/`web_inp`)
+     * `gtag('event', ...)` tracking. Auto-rendered alongside
+     * `CookieConsentAnalytics` whenever Google Analytics/Ads is configured
+     * and `autoWireAnalytics` isn't `false` — no manual wiring needed. Omit
+     * to keep all events enabled with default screen names (raw pathname);
+     * set `events` to a narrower array to disable specific ones.
+     */
+    autoAnalyticsEvents?: AutoAnalyticsEventsConfig;
     /**
      * Resolves the visitor's country code directly (ISO 3166-1 alpha-2,
      * e.g. `"DE"`) — the simplest option when you already have it from
@@ -389,6 +399,20 @@ export interface CookieConsentGetCloudflareContext {
         async: false;
     }): CookieConsentCloudflareContext | null;
 }
+/** Auto-tracked event names — `screen_view` on route change, plus one per Web Vitals metric. All enabled by default. */
+export type AutoAnalyticsEventName = 'screen_view' | 'web_cls' | 'web_fcp' | 'web_fid' | 'web_lcp' | 'web_ttfb' | 'web_inp';
+export interface AutoAnalyticsEventsConfig {
+    /**
+     * Which auto-tracked events to send via `gtag('event', ...)`. Defaults
+     * to all of {@link AutoAnalyticsEventName}. Pass a narrower array to
+     * disable specific events (e.g. omit `'web_cls'`) while keeping the
+     * rest. Only takes effect once `gtag` is available (i.e. Google
+     * Analytics/Ads is configured and consent is granted).
+     */
+    events?: readonly AutoAnalyticsEventName[];
+    /** Maps a locale-stripped pathname to a human-readable screen name for `screen_view`'s `screen_name` param. Defaults to the raw pathname. */
+    getScreenName?: (path: string) => string;
+}
 export interface CookieConsentAnalyticsConfig {
     /** Cloudflare Web Analytics beacon token, e.g. `'{"token": "..."}'` (the raw `data-cf-beacon` attribute value). */
     cloudflareBeaconToken?: string;
@@ -440,6 +464,12 @@ export interface FirebaseAuthRoutingConfig {
     appId: string;
     /** Firebase Analytics measurement ID. */
     measurementId?: string;
+    /**
+     * Whether Firebase Performance Monitoring is initialized on the client.
+     * Enabled (`true`) by default when `firebaseAuth` is configured.
+     * Set `false` to disable Performance Monitoring initialization.
+     */
+    performance?: boolean;
     /**
      * Enables Firebase App Check on the client. Omit to leave App Check
      * uninitialized — required if App Check enforcement is turned on for
@@ -485,6 +515,12 @@ export interface FirebaseAuthRoutingConfig {
      * Defaults to `true`.
      */
     actionLinkRedirectEnabled?: boolean;
+    /**
+     * When `true` (the default), if an emailed-action-link carries a `continueUrl` query parameter
+     * matching the request's origin (same domain/app), the middleware will redirect to `continueUrl`'s
+     * path instead of the static mode path (e.g. `resetPasswordPath`). Set `false` to disable.
+     */
+    followSameOriginContinueUrl?: boolean;
     /**
      * Restricts the emailed-action-link forward (see {@link resetPasswordPath})
      * to this exact static path — set this to whatever path your Firebase

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "cloudflare-next-intl",
-  "version": "0.7.1",
+  "version": "0.7.3",
   "description": "Optimized Next Intl Package Special for App Router and Cloudflare",
+
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "sideEffects": false,