cloudflare-next-intl 0.2.2 → 0.3.0

package/README.md

@@ -65,9 +65,8 @@ const nextConfig: NextConfig = {
 export default nextConfig;
 ```
 
-If this alias is missing, `cloudflare-next-intl/middleware` throws
-`Please set config file and set path to it in next.config as in the example`
-at startup.
+If this alias is missing, any import from `cloudflare-next-intl` throws an
+error naming the missing `@intl-config` alias at startup.
 
 ### 3. Wire up the middleware
 

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

@@ -1,12 +1,14 @@
 import type { TranslationObject } from "../../types/types";
+import type { SerializedAuthUser } from "../../firebase_auth/types";
 interface LocaleContextType {
     language: string;
     messages: TranslationObject;
 }
 export declare const LocaleContext: import("react").Context<LocaleContextType | undefined>;
-export default function LocationzationClientProvider({ language, messages, children }: {
+export default function LocationzationClientProvider({ language, messages, initialAuthUser, children }: {
     language: string;
     messages: TranslationObject;
+    initialAuthUser?: SerializedAuthUser | null;
     children: React.ReactNode;
 }): Component;
 export {};

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

@@ -1,10 +1,23 @@
 "use client";
 import { jsx as _jsx } from "react/jsx-runtime";
 import { setLocaleCache, setMessageForLocaleCache } from "../../general/cache_variables";
-import { createContext } from "react";
+import { createContext, useMemo } from "react";
+import dynamic from "next/dynamic";
+import config from "@intl-config";
 export const LocaleContext = createContext(undefined);
-export default function LocationzationClientProvider({ language, messages, children }) {
+export default function LocationzationClientProvider({ language, messages, initialAuthUser = null, children }) {
     setLocaleCache(language);
     setMessageForLocaleCache(language, messages);
-    return _jsx(LocaleContext.Provider, { value: { language, messages }, children: children });
+    // `LocaleContext.Provider` stays the outermost element here — the
+    // client `AuthUserProvider` (and its descendants calling
+    // usePathname()/useLocale()) must render as a CHILD of it, not a
+    // sibling wrapping it, or those hooks would throw for running outside
+    // the provider.
+    let providedChildren = children;
+    if (config.firebaseAuth) {
+        const AuthUserProvider = dynamic(() => import("../../firebase_auth/client/auth_user_provider"));
+        providedChildren = _jsx(AuthUserProvider, { initialUser: initialAuthUser, children: children });
+    }
+    const contextValue = useMemo(() => ({ language, messages }), [language, messages]);
+    return _jsx(LocaleContext.Provider, { value: contextValue, children: providedChildren });
 }

package/dist/src/client/functions/get_cookie.bench.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/client/functions/get_cookie.bench.js

@@ -0,0 +1,11 @@
+import { bench, describe } from 'vitest';
+import getCookie from './get_cookie';
+describe('getCookie', () => {
+    document.cookie = 'bench-cookie=bar%20baz';
+    bench('reads and decodes an existing cookie', () => {
+        getCookie('bench-cookie');
+    });
+    bench('returns null for a missing cookie', () => {
+        getCookie('missing-cookie');
+    });
+});

package/dist/src/client/functions/set_cookie.bench.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/client/functions/set_cookie.bench.js

@@ -0,0 +1,10 @@
+import { bench, describe } from 'vitest';
+import setCookie from './set_cookie';
+describe('setCookie', () => {
+    bench('writes a cookie with the default maxAge', () => {
+        setCookie({ name: 'theme', value: 'dark' });
+    });
+    bench('writes a cookie with a custom maxAge', () => {
+        setCookie({ name: 'theme', value: 'light', maxAge: 60 });
+    });
+});

package/dist/src/client/functions/set_cookie.d.ts

@@ -6,7 +6,9 @@
  *
  * @param name   Cookie name.
  * @param value  Cookie value; stringified via template literal (no encoding
- *   applied — avoid values containing `;`).
+ *   applied — avoid values containing `;`). Must be a primitive
+ *   (`string`/`number`/`boolean`) — objects would silently serialize to
+ *   `"[object Object]"`.
  * @param maxAge Seconds until expiry. Defaults to 1 year.
  *
  * Always `path=/; SameSite=Lax`. Swallows errors (e.g. in restrictive
@@ -14,6 +16,6 @@
  */
 export default function setCookie({ name, value, maxAge }: {
     name: string;
-    value: unknown;
+    value: string | number | boolean;
     maxAge?: number;
 }): void;

package/dist/src/client/functions/set_cookie.js

@@ -7,7 +7,9 @@
  *
  * @param name   Cookie name.
  * @param value  Cookie value; stringified via template literal (no encoding
- *   applied — avoid values containing `;`).
+ *   applied — avoid values containing `;`). Must be a primitive
+ *   (`string`/`number`/`boolean`) — objects would silently serialize to
+ *   `"[object Object]"`.
  * @param maxAge Seconds until expiry. Defaults to 1 year.
  *
  * Always `path=/; SameSite=Lax`. Swallows errors (e.g. in restrictive

package/dist/src/client/hooks/client_hooks.d.ts

@@ -9,6 +9,8 @@ import type { TranslatorReturnType } from "../../types/types";
  *
  * @returns The current locale (e.g. `"en"`).
  * @throws If rendered outside `IntlProvider`.
+ * @example
+ * const locale = useLocale(); // "en"
  */
 export declare function useLocale(): string;
 /**
@@ -19,5 +21,8 @@ export declare function useLocale(): string;
  * @returns A `(key: string) => string` translation function, memoized on
  *   `[language, messages, namespace]`.
  * @throws If rendered outside `IntlProvider`.
+ * @example
+ * const t = useTranslations("Index");
+ * return <h1>{t("title")}</h1>;
  */
 export declare function useTranslations(namespace: string): TranslatorReturnType;

package/dist/src/client/hooks/client_hooks.js

@@ -12,11 +12,13 @@ import { getTranslationsImpl } from "../../general/general_functions";
  *
  * @returns The current locale (e.g. `"en"`).
  * @throws If rendered outside `IntlProvider`.
+ * @example
+ * const locale = useLocale(); // "en"
  */
 export function useLocale() {
     const context = useContext(LocaleContext);
     if (context === undefined) {
-        throw new Error('useLocale must be used within a LocaleContext');
+        throw new Error('useLocale must be used within an IntlProvider');
     }
     return context.language;
 }
@@ -28,11 +30,14 @@ export function useLocale() {
  * @returns A `(key: string) => string` translation function, memoized on
  *   `[language, messages, namespace]`.
  * @throws If rendered outside `IntlProvider`.
+ * @example
+ * const t = useTranslations("Index");
+ * return <h1>{t("title")}</h1>;
  */
 export function useTranslations(namespace) {
     const context = useContext(LocaleContext);
     if (context === undefined) {
-        throw new Error('useTranslations must be used within a LocaleContext');
+        throw new Error('useTranslations must be used within an IntlProvider');
     }
     const { language, messages } = context;
     return useMemo(() => getTranslationsImpl(language, messages, namespace), [language, messages, namespace]);

package/dist/src/client/index.js

@@ -2,4 +2,7 @@ export { default as LocaleLink } from './components/locale_link';
 export { default as usePathname } from './hooks/use_path_name';
 export { default as setCookieClient } from './functions/set_cookie';
 export { default as getCookieClient } from './functions/get_cookie';
+// Intentionally not re-exported here: useLocale/useTranslations are public
+// via the "cloudflare-next-intl/use" subpath instead, which resolves to the
+// react-server or client implementation automatically via export conditions.
 // export { useLocale, useTranslations } from './hooks/client_hooks';

package/dist/src/config/cookie_key.bench.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/config/cookie_key.bench.js

@@ -0,0 +1,9 @@
+import { bench, describe } from 'vitest';
+import { localeCookieName, isBotCookieKey, isDarkCookieKey } from './cookie_key';
+describe('cookie_key constants', () => {
+    bench('reads the exported constant references', () => {
+        void localeCookieName;
+        void isBotCookieKey;
+        void isDarkCookieKey;
+    });
+});

package/dist/src/config/init_config.bench.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/config/init_config.bench.js

@@ -0,0 +1,7 @@
+import { bench, describe } from 'vitest';
+import { setIntlConfig } from './init_config';
+describe('setIntlConfig', () => {
+    bench('identity pass-through of a routing config object', () => {
+        setIntlConfig({ locales: ['en', 'fr'], defaultLocale: 'en' });
+    });
+});

package/dist/src/config/intl_config.js

@@ -5,7 +5,10 @@ function getConfig() {
         return intlConfig;
     }
     else {
-        throw Error('Please set config file and set path to it in next.config as in the example');
+        throw Error('cloudflare-next-intl: the `@intl-config` alias is not set. ' +
+            'Create a config file (e.g. `src/i18n/intl_config.ts`) that default-exports ' +
+            'your `RoutingConfig` (see `setIntlConfig`), then point `@intl-config` at it via ' +
+            'your bundler/tsconfig path alias — see the README "Setup" section, step 2.');
     }
 }
 const config = getConfig();

package/dist/src/config/intl_sitemap.bench.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/config/intl_sitemap.bench.js

@@ -0,0 +1,18 @@
+import { bench, describe } from 'vitest';
+import generateIntlSitemap from './intl_sitemap';
+const smallRoutes = [
+    { link: '/about', lastModified: '2024-01-01' },
+    { link: '/contact', lastModified: '2024-01-01' },
+];
+const largeRoutes = Array.from({ length: 100 }, (_, i) => ({
+    link: `/route-${i}`,
+    lastModified: '2024-01-01',
+}));
+describe('generateIntlSitemap', () => {
+    bench('small site: 2 routes x 2 locales', () => {
+        generateIntlSitemap({ intlSitemap: smallRoutes, url: `https://example.com/${Math.random()}` });
+    });
+    bench('large site: 100 routes x 2 locales', () => {
+        generateIntlSitemap({ intlSitemap: largeRoutes, url: `https://example.com/${Math.random()}` });
+    });
+});

package/dist/src/config/intl_sitemap.js

@@ -21,7 +21,7 @@ function generateIntlSitemapIml({ intlSitemap, url }) {
             });
         }
     }
-    sitemap.sort((a, b) => a.url.localeCompare(b.url));
+    sitemap.sort((a, b) => (a.url < b.url ? -1 : a.url > b.url ? 1 : 0));
     return sitemap;
 }
 const generateIntlSitemap = cache(generateIntlSitemapIml);

package/dist/src/config/middleware.bench.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/config/middleware.bench.js

@@ -0,0 +1,34 @@
+// @vitest-environment node
+import { bench, describe, vi } from 'vitest';
+import intlMiddleware from './middleware';
+import { makeTestRequest } from '../test_utils/mock_next_server';
+describe('intlMiddleware', () => {
+    bench('warm path: valid locale cookie present', async () => {
+        const req = makeTestRequest('https://example.com/en/page', { cookies: { __user_locale_key__: 'en' } });
+        await intlMiddleware(req);
+    });
+    bench('cold path: no locale cookie, accept-language parsing', async () => {
+        const req = makeTestRequest('https://example.com/page', { headers: { 'accept-language': 'de-DE,de;q=0.9' } });
+        await intlMiddleware(req);
+    });
+});
+vi.doMock('./intl_config', () => ({
+    default: {
+        locales: ['en'],
+        defaultLocale: 'en',
+        firebaseAuth: { middlewareEnabled: true, redirectAuthPath: '/login', homePath: '/', isAuthPath: () => true },
+    },
+}));
+describe('intlMiddleware with firebaseAuth configured', () => {
+    bench('first call: pays the dynamic import of update_session.ts', async () => {
+        vi.resetModules();
+        const { default: freshIntlMiddleware } = await import('./middleware');
+        const req = makeTestRequest('https://example.com/en/page', { cookies: { __user_locale_key__: 'en' } });
+        await freshIntlMiddleware(req);
+    });
+    bench('repeat call: memoized dynamic import (no re-import cost)', async () => {
+        const { default: intlMiddlewareWithAuth } = await import('./middleware');
+        const req = makeTestRequest('https://example.com/en/page', { cookies: { __user_locale_key__: 'en' } });
+        await intlMiddlewareWithAuth(req);
+    });
+});

package/dist/src/config/middleware.js

@@ -19,6 +19,12 @@ async function getIsBotValue(userAgent) {
 }
 const getIsBotValueCache = cache(getIsBotValue);
 export const localesSet = new Set(config.locales);
+// Memoized after the first call — `import()` is not free even when the
+// module is already in the runtime's module cache (a microtask round-trip
+// plus a Promise allocation), and this middleware runs on every request.
+// Still fully lazy: consumers who never set `config.firebaseAuth` never
+// reach the branch that assigns this, so they never pay the import at all.
+let updateSessionModule;
 /**
  * This middleware function runs for every incoming request. Handles locale
  * detection/routing, then optionally defers to your own custom logic.
@@ -50,15 +56,23 @@ export default async function intlMiddleware(request, options) {
         const { pathname, search, hash } = request.nextUrl;
         let urlLocale;
         let pathWithoutLocale;
-        const pathSegments = pathname.split('/').filter(Boolean); // e.g., ['', 'en', 'about'] -> ['en', 'about']
-        const firstSegment = pathSegments[0];
-        const languageValue = firstSegment;
+        // Avoids split('/').filter(Boolean) array allocation on every request:
+        // scan for the first segment's bounds directly.
+        const segmentStart = pathname.charCodeAt(0) === 47 /* '/' */ ? 1 : 0;
+        let segmentEnd = pathname.indexOf('/', segmentStart);
+        if (segmentEnd === -1)
+            segmentEnd = pathname.length;
+        const languageValue = pathname.slice(segmentStart, segmentEnd);
         // Check if the first segment of the path is one of the supported locales
-        if (pathSegments.length > 0 && localesSet.has(languageValue)) {
+        if (languageValue && localesSet.has(languageValue)) {
             urlLocale = languageValue;
-            pathWithoutLocale = '/' + pathSegments.slice(1).join('/'); // Remove the locale segment
-            if (pathWithoutLocale === '')
-                pathWithoutLocale = '/'; // Ensure it's '/' for root after removing locale
+            let rest = pathname.slice(segmentEnd);
+            if (rest.endsWith('/'))
+                rest = rest.slice(0, -1);
+            if (rest.includes('//')) {
+                rest = '/' + rest.split('/').filter(Boolean).join('/');
+            }
+            pathWithoutLocale = rest || '/';
         }
         else {
             // No locale prefix in the URL. The actual pathname is the full original pathname.
@@ -106,10 +120,27 @@ export default async function intlMiddleware(request, options) {
             }
         }
         response.headers.set('Content-Language', effectiveLocaleForRequest);
+        response.headers.set('x-pathname', pathWithoutLocale);
+        // Auto-wires the firebase_auth submodule's redirect/session-refresh
+        // logic when `firebaseAuth` is configured — dynamic import so this
+        // file never pulls in firebase_auth/** (and transitively firebase/*)
+        // for consumers who never set `firebaseAuth` at all. Runs last, so
+        // it composes onto (rather than discards) the locale cookie, bot
+        // cookie, and Content-Language header already finalized above.
+        // Skipped entirely when a locale redirect is already happening
+        // (`isRedirect`) — the locale redirect itself is the response, same
+        // as `middlewareHandler` is also skipped on this path by default.
+        if (!isRedirect && config.firebaseAuth && config.firebaseAuth.middlewareEnabled !== false) {
+            if (!updateSessionModule) {
+                updateSessionModule = await import('../firebase_auth/middleware/update_session');
+            }
+            response = await updateSessionModule.default(request, response, effectiveLocaleForRequest);
+        }
         return response;
     }
     catch (e) {
-        console.error(`Middleware Error ${e}`);
+        console.error('[cloudflare-next-intl] intlMiddleware failed and fell back to passing the request through unmodified ' +
+            '(no locale rewrite/redirect, no firebase_auth session refresh). Underlying error:', e);
         return NextResponse.next({
             request,
         });

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,36 @@
+import { bench, describe, vi } from 'vitest';
+const fa = {
+    apiKey: 'key',
+    authDomain: 'domain',
+    projectId: 'proj',
+    appId: 'app',
+    redirectAuthPath: '/login',
+    homePath: '/',
+    isAuthPath: () => false,
+};
+vi.mock('@intl-config', () => ({ default: { firebaseAuth: fa } }));
+vi.mock('./firebase_client', () => ({
+    getFirebaseAuthClient: vi.fn(async () => ({ auth: {} })),
+}));
+vi.mock('../error_messages/firebase_auth_error_helper', () => ({
+    default: vi.fn(() => 'translated error'),
+}));
+const signInWithEmailAndPassword = vi.fn(async (_auth, _email, _password) => undefined);
+vi.mock('firebase/auth', () => ({
+    signInWithEmailAndPassword: (auth, email, password) => signInWithEmailAndPassword(auth, email, password),
+    createUserWithEmailAndPassword: vi.fn(async () => undefined),
+    sendPasswordResetEmail: vi.fn(async () => undefined),
+}));
+function makeFormData(fields) {
+    const fd = new FormData();
+    for (const [key, value] of Object.entries(fields))
+        fd.set(key, value);
+    return fd;
+}
+describe('createLoginAction', () => {
+    bench('creates and invokes a login action (successful sign-in)', async () => {
+        const { createLoginAction } = await import('./auth_actions');
+        const action = createLoginAction('en', {});
+        await action({}, makeFormData({ email: 'a@b.com', password: 'pw' }));
+    });
+});

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

@@ -0,0 +1,46 @@
+import type { AuthActionMessages, AuthFormState } from '../types';
+/**
+ * Builds a login server action for React's `useActionState` form hook.
+ * The returned function has the `(prevState, formData) => Promise<AuthFormState>`
+ * shape `useActionState` expects — pass it directly as the action.
+ *
+ * `formData` must contain `email` and `password` fields.
+ *
+ * @param locale Used to localize the returned error message.
+ * @param messages Localized action messages (currently unused by this action).
+ * @returns A form action: `{ success: true }` on success, `{ error }` on failure.
+ * @example
+ * const [state, action] = useActionState(createLoginAction(locale, messages), {});
+ * <form action={action}>...</form>
+ */
+export declare function createLoginAction(locale: string, messages: AuthActionMessages): (_prevState: AuthFormState, formData: FormData) => Promise<AuthFormState>;
+/**
+ * Builds a sign-up server action for React's `useActionState` form hook.
+ * Same shape as {@link createLoginAction}.
+ *
+ * `formData` must contain `email`, `password`, and `confirmPassword` fields.
+ *
+ * @param locale Used to localize the returned error message.
+ * @param messages `messages.mismatch` is returned as the error if
+ *   `password` !== `confirmPassword`; other fields on `AuthActionMessages`
+ *   are not read by this action.
+ * @returns A form action: `{ success: true }` on success, `{ error }` on failure.
+ * @example
+ * const [state, action] = useActionState(createSignUpAction(locale, messages), {});
+ * <form action={action}>...</form>
+ */
+export declare function createSignUpAction(locale: string, messages: AuthActionMessages): (_prevState: AuthFormState, formData: FormData) => Promise<AuthFormState>;
+/**
+ * Builds a forgot-password server action for React's `useActionState` form
+ * hook. Same shape as {@link createLoginAction}.
+ *
+ * `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).
+ * @returns A form action: `{ success: true }` on success, `{ error }` on failure.
+ * @example
+ * const [state, action] = useActionState(createForgotPasswordAction(locale, messages), {});
+ * <form action={action}>...</form>
+ */
+export declare function createForgotPasswordAction(locale: string, messages: AuthActionMessages): (_prevState: AuthFormState, formData: FormData) => Promise<AuthFormState>;

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

@@ -0,0 +1,102 @@
+'use client';
+import config from '@intl-config';
+import requireFirebaseAuthConfig from '../require_config';
+import { getFirebaseAuthClient } from './firebase_client';
+import firebaseAuthErrorMessage from '../error_messages/firebase_auth_error_helper';
+function readCredentials(formData) {
+    return {
+        email: (formData.get('email')?.toString() ?? '').trim(),
+        password: (formData.get('password')?.toString() ?? '').trim(),
+    };
+}
+/**
+ * Builds a login server action for React's `useActionState` form hook.
+ * The returned function has the `(prevState, formData) => Promise<AuthFormState>`
+ * shape `useActionState` expects — pass it directly as the action.
+ *
+ * `formData` must contain `email` and `password` fields.
+ *
+ * @param locale Used to localize the returned error message.
+ * @param messages Localized action messages (currently unused by this action).
+ * @returns A form action: `{ success: true }` on success, `{ error }` on failure.
+ * @example
+ * const [state, action] = useActionState(createLoginAction(locale, messages), {});
+ * <form action={action}>...</form>
+ */
+export function createLoginAction(locale, messages) {
+    return async function loginAction(_prevState, formData) {
+        requireFirebaseAuthConfig(config.firebaseAuth);
+        const { auth } = await getFirebaseAuthClient();
+        const { signInWithEmailAndPassword } = await import('firebase/auth');
+        const { email, password } = readCredentials(formData);
+        try {
+            await signInWithEmailAndPassword(auth, email, password);
+            return { success: true };
+        }
+        catch (e) {
+            return { error: firebaseAuthErrorMessage(locale, e) };
+        }
+    };
+}
+/**
+ * Builds a sign-up server action for React's `useActionState` form hook.
+ * Same shape as {@link createLoginAction}.
+ *
+ * `formData` must contain `email`, `password`, and `confirmPassword` fields.
+ *
+ * @param locale Used to localize the returned error message.
+ * @param messages `messages.mismatch` is returned as the error if
+ *   `password` !== `confirmPassword`; other fields on `AuthActionMessages`
+ *   are not read by this action.
+ * @returns A form action: `{ success: true }` on success, `{ error }` on failure.
+ * @example
+ * const [state, action] = useActionState(createSignUpAction(locale, messages), {});
+ * <form action={action}>...</form>
+ */
+export function createSignUpAction(locale, messages) {
+    return async function signUpAction(_prevState, formData) {
+        requireFirebaseAuthConfig(config.firebaseAuth);
+        const { auth } = await getFirebaseAuthClient();
+        const { createUserWithEmailAndPassword } = await import('firebase/auth');
+        const { email, password } = readCredentials(formData);
+        const confirmPassword = (formData.get('confirmPassword')?.toString() ?? '').trim();
+        if (messages.mismatch && password !== confirmPassword) {
+            return { error: messages.mismatch };
+        }
+        try {
+            await createUserWithEmailAndPassword(auth, email, password);
+            return { success: true };
+        }
+        catch (e) {
+            return { error: firebaseAuthErrorMessage(locale, e) };
+        }
+    };
+}
+/**
+ * Builds a forgot-password server action for React's `useActionState` form
+ * hook. Same shape as {@link createLoginAction}.
+ *
+ * `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).
+ * @returns A form action: `{ success: true }` on success, `{ error }` on failure.
+ * @example
+ * const [state, action] = useActionState(createForgotPasswordAction(locale, messages), {});
+ * <form action={action}>...</form>
+ */
+export function createForgotPasswordAction(locale, messages) {
+    return async function forgotPasswordAction(_prevState, formData) {
+        requireFirebaseAuthConfig(config.firebaseAuth);
+        const { auth } = await getFirebaseAuthClient();
+        const { sendPasswordResetEmail } = await import('firebase/auth');
+        const email = (formData.get('email')?.toString() ?? '').trim();
+        try {
+            await sendPasswordResetEmail(auth, email);
+            return { success: true };
+        }
+        catch (e) {
+            return { error: firebaseAuthErrorMessage(locale, e) };
+        }
+    };
+}

package/dist/src/firebase_auth/client/auth_user_cache.bench.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/firebase_auth/client/auth_user_cache.bench.js

@@ -0,0 +1,11 @@
+import { bench, describe } from 'vitest';
+import { setAuthUserCache, getAuthUserCache, isAuthUserLoadingCache } from './auth_user_cache';
+describe('auth_user_cache', () => {
+    bench('setAuthUserCache + getAuthUserCache round-trip', () => {
+        setAuthUserCache({ uid: 'bench-user' });
+        getAuthUserCache();
+    });
+    bench('isAuthUserLoadingCache read', () => {
+        isAuthUserLoadingCache();
+    });
+});

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

@@ -0,0 +1,4 @@
+import type { AuthUser } from '../types';
+export declare function setAuthUserCache(user: AuthUser | null): void;
+export declare function getAuthUserCache(): AuthUser | null;
+export declare function isAuthUserLoadingCache(): boolean;

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

@@ -0,0 +1,14 @@
+// Module-scope cache so non-React code can read the current client auth
+// user synchronously, without needing to be inside AuthUserProvider's tree.
+let cachedUser = null;
+let cachedLoading = true;
+export function setAuthUserCache(user) {
+    cachedUser = user;
+    cachedLoading = false;
+}
+export function getAuthUserCache() {
+    return cachedUser;
+}
+export function isAuthUserLoadingCache() {
+    return cachedLoading;
+}

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

@@ -0,0 +1,36 @@
+import type { AuthUser, SerializedAuthUser } from '../types';
+export interface AuthUserContextType {
+    /** Current Firebase user, or `null` if signed out (or not yet resolved while `loading`). */
+    user: AuthUser | null;
+    /** `true` until the initial auth state has resolved on the client. */
+    loading: boolean;
+    /** 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>;
+    /** Signs out, clears the session cookie, and redirects to `firebaseAuth.redirectAuthPath`. */
+    logout: () => Promise<void>;
+}
+export declare const AuthUserContext: import("react").Context<AuthUserContextType | null>;
+/**
+ * Client-side auth-state provider for `firebase_auth`. Wrap your root layout
+ * (or a client boundary below it) with this to make `useAuthUser()`
+ * (`cloudflare-next-intl/useFirebaseAuthUser`, client variant) resolve
+ * `{ user, loading }` from the live Firebase `onIdTokenChanged` listener,
+ * and to get automatic session-cookie sync + redirect-on-sign-out/verify
+ * behavior driven by `firebaseAuth.isAuthPath` / `whiteListPaths` /
+ * `redirectAuthPath` / `verifyEmailPath` on your `RoutingConfig`.
+ *
+ * Requires `firebaseAuth` to be set on the config passed to `setIntlConfig`
+ * — throws via {@link requireFirebaseAuthConfig} otherwise.
+ *
+ * @param initialUser Server-resolved user (e.g. from
+ *   `useFirebaseAuthUser`'s `react-server` variant) to avoid a
+ *   loading flash on first paint; pass `null`/omit if unavailable.
+ * @example
+ * <AuthUserProvider initialUser={initialUser}>{children}</AuthUserProvider>
+ */
+export default function AuthUserProvider({ initialUser, children }: {
+    initialUser?: SerializedAuthUser | null;
+    children: React.ReactNode;
+}): import("react").JSX.Element;