cloudflare-next-intl 0.7.2 → 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/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/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/types/types.d.ts

@@ -515,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.2",
+  "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,