cloudflare-next-intl 0.7.1 → 0.7.2

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/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/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

package/package.json

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