cloudflare-next-intl 0.6.2 → 0.6.4

package/dist/types/cookie_consent/types.d.ts

@@ -0,0 +1,57 @@
+/** Consent value: `true` accepted, `false` necessary-only, `null` not yet decided. */
+export type ConsentValue = boolean | null;
+/** Context value returned by `useCookieConsent()`. */
+export interface CookieConsentContextType {
+    /** Current consent value; `null` until the visitor decides. */
+    consent: ConsentValue;
+    /**
+     * `false` until the client has read the stored consent/date cookies once
+     * (always `false` during SSR and the first client render, to avoid a
+     * hydration mismatch). The default dialog components render nothing
+     * until this is `true`, so a returning visitor's decided consent never
+     * flashes the banner before disappearing.
+     */
+    isMounted: boolean;
+    /**
+     * `true` once a privacy-policy update has been detected (stored consent
+     * predates `cookieConsent.privacyPolicyDate`) and hasn't been
+     * acknowledged yet. Always `false` when `privacyPolicyDate` is unset.
+     */
+    privacyPolicyUpdated: boolean;
+    /**
+     * Accepts (or rejects, with `false`) cookie consent and persists it.
+     * Pass `null` to clear the stored decision and reset `consent` back to
+     * `null`, so the default `CookieConsentDialog` banner reappears (e.g.
+     * for a "cookie settings" button).
+     */
+    setConsent: (value: ConsentValue) => void;
+    /** Acknowledges the privacy-policy update banner and persists the new date. */
+    acknowledgePrivacyPolicyUpdate: () => void;
+    /**
+     * Resolved from `cookieConsent.privacyPolicyPath` (defaults to
+     * `'/privacy-policy'`; `false` disables it). Used by the default
+     * dialog components to render a privacy-policy link automatically
+     * when their `link` prop is omitted.
+     */
+    privacyPolicyPath: string | false;
+}
+/** Slot-level style/class overrides accepted by the default dialog components. */
+export interface CookieDialogClassNames {
+    root?: string;
+    message?: string;
+    link?: string;
+    actions?: string;
+    acceptButton?: string;
+    declineButton?: string;
+    closeButton?: string;
+}
+/** Slot-level inline-style overrides accepted by the default dialog components. */
+export interface CookieDialogStyles {
+    root?: React.CSSProperties;
+    message?: React.CSSProperties;
+    link?: React.CSSProperties;
+    actions?: React.CSSProperties;
+    acceptButton?: React.CSSProperties;
+    declineButton?: React.CSSProperties;
+    closeButton?: React.CSSProperties;
+}

package/dist/types/error_handling/create_server_error_action.d.ts

@@ -0,0 +1,19 @@
+import type { ErrorHandlingParams } from '../types/types';
+import { type ReportErrorConfig } from './report_error';
+/**
+ * Creates a `"use server"` action that reports a client-originated error via
+ * `reportError`, so `config` (and anything it closes over — secrets,
+ * `Secrets.telegramBotToken`-style env reads inside your `onError`) never
+ * has to be imported into client-side code. Call this once (server-side,
+ * e.g. next to your `RoutingConfig`) and pass the returned function to
+ * client components that need to report an error — they only ever handle
+ * the error value itself, never `config`.
+ *
+ * The error is stringified before crossing the client→server action
+ * boundary (Next.js server actions serialize arguments; an `Error` instance
+ * doesn't survive that intact) and `isClient: true` is set automatically.
+ *
+ * @param config Pass the relevant slices of your `RoutingConfig` directly —
+ *   `{ errorHandling: config.errorHandling, generate: config.generate }`.
+ */
+export default function createServerErrorAction(config: ReportErrorConfig | undefined): (error: unknown, classOrMethodName: string, params?: ErrorHandlingParams["params"]) => Promise<void>;

package/dist/types/error_handling/create_server_error_action.test.d.ts

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

package/dist/types/error_handling/default_ignored_console_errors.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Firebase Auth error codes this package's own `createLoginAction`/
+ * `createSignUpAction`/`createForgotPasswordAction` already catch and
+ * translate into a localized message (see
+ * `firebase_auth/error_messages/firebase_auth_error_helper.ts`) — expected
+ * user-input failures (wrong password, email already in use, etc.), not
+ * bugs. They never reach `console.error`/`reportError` through this
+ * package's own code; this list exists as defense-in-depth for consumers
+ * whose own code logs one of these codes directly. Passing your own
+ * `ignoreConsoleError` array replaces this default entirely — pass `[]` to
+ * report everything.
+ */
+export declare const defaultIgnoredConsoleErrors: readonly string[];

package/dist/types/error_handling/default_ignored_console_errors.test.d.ts

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

package/dist/types/error_handling/format_error_message.d.ts

@@ -0,0 +1,9 @@
+import type { ErrorHandlingParams } from '../types/types';
+/**
+ * Builds a human-readable one-string summary of an `ErrorHandlingParams` —
+ * `[classOrMethodName] Error: <message>` followed by non-empty `Params`/
+ * `IsClient` sections. Never throws (`stringifyUnknown` is safe). Used as
+ * `ErrorHandlingParams.formattedMessage` — read this instead of `error`/
+ * `params` directly when you just want something printable.
+ */
+export default function formatErrorMessage(params: ErrorHandlingParams): string;

package/dist/types/error_handling/format_error_message.test.d.ts

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

package/dist/types/error_handling/index.d.ts

@@ -0,0 +1,9 @@
+export { default as withErrorHandling } from './with_error_handling';
+export type { WithErrorHandlingOptions } from './with_error_handling';
+export { default as reportError } from './report_error';
+export type { ReportErrorConfig } from './report_error';
+export { default as installConsoleErrorOverride } from './install_console_error_override';
+export { default as stringifyUnknown } from './stringify_unknown';
+export { default as formatErrorMessage } from './format_error_message';
+export { defaultIgnoredConsoleErrors } from './default_ignored_console_errors';
+export type { ErrorHandlingParams, ErrorHandlingRoutingConfig } from '../types/types';

package/dist/types/error_handling/install_console_error_override.bench.d.ts

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

package/dist/types/error_handling/install_console_error_override.d.ts

@@ -0,0 +1,29 @@
+import { type ReportErrorConfig } from './report_error';
+/**
+ * Replaces the global `console.error` so every `console.error(...)` call is
+ * also routed through `config.errorHandling.onError`/`reportError` — the
+ * original `console.error` still runs afterwards, nothing is swallowed.
+ * Safe to call more than once (a no-op after the first call in this JS
+ * realm — call it separately on the server and on the client, each has its
+ * own `console`). Only takes effect when `config.errorHandling.overrideConsoleError`
+ * is `true`.
+ *
+ * A component stuck in a render-error loop calls `console.error` on every
+ * render — `reportError`'s own dedup/cap (on by default, see
+ * `errorHandling.dedup`/`maxReports`) is what stops that from reporting
+ * unboundedly; this function does not duplicate that cap itself.
+ *
+ * `config.errorHandling.ignoreConsoleErrors` (default
+ * `defaultIgnoredConsoleErrors` — this package's own Firebase Auth error
+ * codes for expected user-input failures) and `ignoreConsoleError` both
+ * skip reporting a matching call while still logging it normally.
+ *
+ * @param config Pass the relevant slices of your `RoutingConfig` directly —
+ *   `{ errorHandling: config.errorHandling, generate: config.generate }`.
+ * @param isClient Passed through to every report's `ErrorHandlingParams.isClient`
+ *   — set `true` when installing from client-side code (e.g. the client
+ *   `LocationzationClientProvider`), omit/`false` on the server. There's no
+ *   `getCloudflareContext`/`ctx.waitUntil` available in the browser, so
+ *   client-side reports always await `onError` directly.
+ */
+export default function installConsoleErrorOverride(config: ReportErrorConfig | undefined, isClient?: boolean): void;

package/dist/types/error_handling/install_console_error_override.perf.test.d.ts

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

package/dist/types/error_handling/install_console_error_override.test.d.ts

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

package/dist/types/error_handling/report_error.bench.d.ts

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

package/dist/types/error_handling/report_error.d.ts

@@ -0,0 +1,40 @@
+import type { ErrorHandlingParams, ErrorHandlingRoutingConfig, GenerateRoutingConfig } from '../types/types';
+export interface ReportErrorConfig {
+    errorHandling?: ErrorHandlingRoutingConfig;
+    generate?: GenerateRoutingConfig;
+}
+/**
+ * Reports `params` via `config.errorHandling.onError` (default
+ * `console.error(params.formattedMessage)`), unless
+ * `config.errorHandling.enable === false`, `params.consent` is set and not
+ * `true` (reporting to a third party without cookie consent can itself be
+ * GDPR-relevant), or dedup throttles it (on by default — see
+ * `errorHandling.dedup`/`throttleMs`/`resetDedup`). Never throws — a broken
+ * reporter must not mask the original error.
+ *
+ * Always overwrites `params.formattedMessage` with a fresh
+ * `formatErrorMessage(params)` before reporting — a human-readable one-line
+ * summary (`[classOrMethodName] Error: <message>` plus non-empty sections)
+ * instead of the raw `error`/`params` object, for a default reporter (or a
+ * simple `onError`) to print directly.
+ *
+ * When `config.generate?.getCloudflareContext` is set, `waitUntil` is called
+ * SYNCHRONOUSLY, in the same tick, with the `callOnError(...)` promise —
+ * Cloudflare Workers only extends the request's lifetime for work already
+ * registered with `waitUntil` by the time the handler returns; deferring
+ * that call through an extra microtask (e.g. `Promise.resolve().then(...)`)
+ * risks the isolate tearing down the request before `waitUntil` is ever
+ * actually invoked, silently dropping the report. Falls back to awaiting
+ * `onError` directly when `getCloudflareContext`/`ctx.waitUntil` is unset or
+ * unavailable (e.g. outside a Cloudflare Worker).
+ *
+ * Passing `params.error` as `null`/`undefined` with `errorHandling.resetDedup: true`
+ * and nothing else is a valid "reset-only" call: the dedup state clears and
+ * `reportError` returns immediately, without calling `onError` — useful to
+ * clear dedup state once at the very start of a request/cron tick, before
+ * any handler that might call `reportError` for a real error runs.
+ *
+ * @param config Pass the relevant slices of your `RoutingConfig` directly —
+ *   `{ errorHandling: config.errorHandling, generate: config.generate }`.
+ */
+export default function reportError(config: ReportErrorConfig | undefined, params: ErrorHandlingParams): Promise<void>;

package/dist/types/error_handling/report_error.perf.test.d.ts

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

package/dist/types/error_handling/report_error.test.d.ts

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

package/dist/types/error_handling/stringify_unknown.bench.d.ts

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

package/dist/types/error_handling/stringify_unknown.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Safely converts an `unknown` value (typically `ErrorHandlingParams.error`)
+ * into a string, for logging/dedup-keying/display — never throws.
+ *
+ * @param isClient Skips resolving function-wrapped/lazy error values on the
+ *   client (matches `ErrorHandlingParams.isClient`) — running arbitrary
+ *   caught functions client-side isn't safe the way it is on the server.
+ * @param isNested Set when stringifying a value nested inside another
+ *   object/array — falls back to a plain `JSON.stringify` (no pretty-print)
+ *   so a single unserializable nested value can't crash the whole report.
+ */
+export default function stringifyUnknown(value: unknown, isClient?: boolean, isNested?: boolean): string;

package/dist/types/error_handling/stringify_unknown.test.d.ts

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

package/dist/types/error_handling/with_error_handling.d.ts

@@ -0,0 +1,15 @@
+import type { ConsentValue } from '../cookie_consent/types';
+import { type ReportErrorConfig } from './report_error';
+export interface WithErrorHandlingOptions {
+    /** Pass the relevant slices of your `RoutingConfig` directly — `{ errorHandling: config.errorHandling, generate: config.generate }`. */
+    config?: ReportErrorConfig;
+    params?: unknown;
+    isClient?: boolean;
+    consent?: ConsentValue;
+}
+/**
+ * Wraps `fn`, reporting (via `options.config`) then rethrowing any error it
+ * throws or rejects with. Never swallows — callers keep their own
+ * catch/fallback behavior, this only adds reporting on top.
+ */
+export default function withErrorHandling<Args extends unknown[], Result>(fn: (...args: Args) => Result | Promise<Result>, classOrMethodName: string, options?: WithErrorHandlingOptions): (...args: Args) => Promise<Result>;

package/dist/types/error_handling/with_error_handling.test.d.ts

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

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

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

package/dist/types/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/types/firebase_auth/client/auth_actions.test.d.ts

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

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

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

package/dist/types/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/types/firebase_auth/client/auth_user_cache.test.d.ts

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

package/dist/types/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;

package/dist/types/firebase_auth/client/firebase_client.bench.d.ts

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

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

@@ -0,0 +1,20 @@
+import type { FirebaseApp } from 'firebase/app';
+import type { Auth } from 'firebase/auth';
+/**
+ * Lazily loads and initializes `firebase/app`/`firebase/auth` — a dynamic
+ * import, not a static one, so consumers who never call a firebase_auth
+ * export never pull these packages into their bundle or runtime at all.
+ * Throws if `firebaseAuth` is missing from `RoutingConfig` (see
+ * `require_config.ts`) instead of silently no-op'ing.
+ */
+export declare function getFirebaseAuthClient(): Promise<{
+    app: FirebaseApp;
+    auth: Auth;
+}>;
+/** Synchronous read of the cached client, or `undefined` before the first `getFirebaseAuthClient()` resolves. */
+export declare function getFirebaseAuthClientSync(): {
+    app: FirebaseApp;
+    auth: Auth;
+} | 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/types/firebase_auth/client/firebase_client.test.d.ts

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

package/dist/types/firebase_auth/client/use_auth_user.bench.d.ts

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

package/dist/types/firebase_auth/client/use_auth_user.d.ts

@@ -0,0 +1,12 @@
+import { type AuthUserContextType } from './auth_user_provider';
+/**
+ * Reads the current Firebase auth user and its actions from
+ * `AuthUserProvider`'s context.
+ *
+ * @throws If called without an `AuthUserProvider` above it in the tree.
+ * @example
+ * const { user, loading, logout } = useAuthUser();
+ * if (loading) return null;
+ * return user ? <button onClick={logout}>Log out</button> : null;
+ */
+export default function useAuthUser(): AuthUserContextType;

package/dist/types/firebase_auth/error_messages/default_messages.en.bench.d.ts

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

package/dist/types/firebase_auth/error_messages/default_messages.en.d.ts

@@ -0,0 +1 @@
+export declare const DEFAULT_MESSAGES_EN: Record<string, string>;

package/dist/types/firebase_auth/error_messages/default_messages.en.test.d.ts

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

package/dist/types/firebase_auth/error_messages/firebase_auth_error_helper.bench.d.ts

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

package/dist/types/firebase_auth/error_messages/firebase_auth_error_helper.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Resolves a Firebase auth error to a user-facing message. If the consumer's
+ * locale messages have a `firebaseAuth` namespace with a matching key, that
+ * translation is used; otherwise falls back to the bundled English default.
+ */
+export default function firebaseAuthErrorMessage(locale: string, error: unknown): string;

package/dist/types/firebase_auth/error_messages/firebase_auth_error_helper.test.d.ts

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

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

@@ -0,0 +1,9 @@
+export { default as FirebaseAuthClientProvider } from './client/auth_user_provider';
+export { default as FirebaseAuthServerProvider } from './server/auth_user_server_provider';
+export { default as useFirebaseAuthUserClient } from './client/use_auth_user';
+export { default as useFirebaseAuthUserServer } from './server/use_auth_user_server';
+export { createLoginAction, createSignUpAction, createForgotPasswordAction } from './client/auth_actions';
+export { default as updateFirebaseAuthSession, defaultSessionCookieName as firebaseAuthSessionCookieName } from './middleware/update_session';
+export { getFirebaseAuthClient } from './client/firebase_client';
+export type { SerializedAuthUser, AuthFormState, AuthActionMessages, AuthUser } from './types';
+export type { FirebaseAuthRoutingConfig } from '../types/types';

package/dist/types/firebase_auth/middleware/update_session.bench.d.ts

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

package/dist/types/firebase_auth/middleware/update_session.d.ts

@@ -0,0 +1,22 @@
+import { NextResponse, type NextRequest } from 'next/server';
+export declare const defaultSessionCookieName = "__fa_session__";
+export declare const defaultRefreshTokenCookieName = "__fa_refresh_token__";
+/**
+ * Layers Firebase session-cookie validation/refresh and auth redirects onto
+ * an already-built middleware response. Called internally by `intlMiddleware`
+ * (via dynamic import) when `config.firebaseAuth` is set and
+ * `middlewareEnabled !== false` — not intended to be called directly unless
+ * that auto-wiring is opted out of.
+ *
+ * @param baseResponse The response `intlMiddleware` already produced for
+ *   locale routing (its own next()/rewrite()/redirect(), with the locale
+ *   cookie / bot cookie / `Content-Language` header already set). On the
+ *   pass-through path this function returns `baseResponse` itself (with
+ *   Firebase cookies layered on) so none of that is dropped; on the
+ *   guest/auth-page redirect paths it returns a NEW response instead, since
+ *   a redirect response can't also carry forward a rewrite/next decision —
+ *   its cookies/headers are copied across from `baseResponse` so locale
+ *   state still survives the redirect.
+ * @param locale The effective locale `intlMiddleware` resolved for this request.
+ */
+export default function updateSession(request: NextRequest, baseResponse: NextResponse, locale: string): Promise<NextResponse>;

package/dist/types/firebase_auth/middleware/update_session.test.d.ts

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

package/dist/types/firebase_auth/require_config.bench.d.ts

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

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

@@ -0,0 +1,8 @@
+import type { FirebaseAuthRoutingConfig } from '../types/types';
+/**
+ * Every firebase_auth export calls this before touching `firebase/*`. Throws
+ * instead of silently no-op'ing so a consumer who calls e.g. `useAuthUser()`
+ * without setting `firebaseAuth` on their `RoutingConfig` gets an immediate,
+ * actionable error rather than a silent null/undefined.
+ */
+export default function requireFirebaseAuthConfig(fa: FirebaseAuthRoutingConfig | undefined): asserts fa is FirebaseAuthRoutingConfig;

package/dist/types/firebase_auth/require_config.test.d.ts

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

package/dist/types/firebase_auth/server/auth_user_server_provider.d.ts

@@ -0,0 +1,29 @@
+import type { SerializedAuthUser } from '../types';
+/**
+ * Resolves the signed-in user from the session cookie and performs the
+ * authoritative pre-render redirect (guest→`redirectAuthPath`, signed-in→
+ * `homePath` on auth pages) — middleware only checks cookie *presence*, not
+ * validity; a forged, expired, or otherwise invalid-but-present cookie
+ * sails through it. Only this function's token validation
+ * (`getAuthenticatedAppForUser`) catches that, so this redirect must happen
+ * here, before any HTML is sent — relying solely on the client
+ * `AuthUserProvider` effect to redirect afterwards produces a visible
+ * flash (page renders signed-in, then bounces). Plain async function, not
+ * a component: callers decide where/how to use the resolved user relative
+ * to their own component tree (see `AuthUserServerProvider` below for the
+ * simple case, and `IntlProvider`'s auto-wiring for the case where ordering
+ * against `LocaleContext` matters).
+ */
+export declare function resolveAuthUserAndRedirect(): Promise<SerializedAuthUser | null>;
+/**
+ * Convenience component for the manual-override path
+ * (`firebaseAuth.middlewareEnabled: false`-style manual wiring): resolves +
+ * redirects, then wraps `children` in the client `AuthUserProvider`
+ * directly. NOT used by the default auto-wiring path — `IntlProvider`/
+ * `LocationzationClientProvider` call `resolveAuthUserAndRedirect` and the
+ * client `AuthUserProvider` separately instead, so the client provider can
+ * render inside `LocaleContext.Provider` rather than outside it.
+ */
+export default function AuthUserServerProvider({ children }: {
+    children: React.ReactNode;
+}): Promise<import("react").JSX.Element>;

package/dist/types/firebase_auth/server/firebase_server.bench.d.ts

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

package/dist/types/firebase_auth/server/firebase_server.d.ts

@@ -0,0 +1,15 @@
+import type { FirebaseApp } from 'firebase/app';
+import type { User } from 'firebase/auth';
+/**
+ * Resolves the signed-in user on the server from the session cookie.
+ * `initializeServerApp` validates the token with the Auth service, so a
+ * missing, expired, or forged token yields `currentUser === null`.
+ * Wrapped in React's `cache()` so multiple server components in one request
+ * share a single Auth service lookup. Lazily imports `firebase/app`/
+ * `firebase/auth` — never touched unless this is actually called, and
+ * throws if `firebaseAuth` is missing from `RoutingConfig`.
+ */
+export declare const getAuthenticatedAppForUser: () => Promise<{
+    firebaseServerApp: FirebaseApp | null;
+    currentUser: User | null;
+}>;

package/dist/types/firebase_auth/server/firebase_server.perf.test.d.ts

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

package/dist/types/firebase_auth/server/firebase_server.test.d.ts

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

package/dist/types/firebase_auth/server/use_auth_user_server.bench.d.ts

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

package/dist/types/firebase_auth/server/use_auth_user_server.d.ts

@@ -0,0 +1,39 @@
+import type { User } from 'firebase/auth';
+/**
+ * Resolves the current request's authenticated Firebase user.
+ * @returns `{ user, loading: false }` — `loading` is always `false` here;
+ *   server resolution is synchronous with respect to the awaited call.
+ */
+declare function iGetAuthUser(): Promise<{
+    user: User | null;
+    loading: false;
+}>;
+/**
+ * Server Component/Action only: resolves the current request's
+ * authenticated Firebase user, same style as {@link getLocale}/
+ * {@link getTranslations} — an unconditional, always-`async` export
+ * (`cloudflare-next-intl/getFirebaseAuthUser`), so the `await` requirement
+ * is visible from the type itself in every editor.
+ *
+ * Returns the same `{ user, loading }` shape the client `useAuthUser()`
+ * hook's context exposes, so `const { user } = await getAuthUser()`
+ * generalizes correctly from `const { user } = useAuthUser()` on the client.
+ *
+ * @example
+ * ```tsx
+ * const { user } = await getAuthUser();
+ * ```
+ */
+export declare const getAuthUser: typeof iGetAuthUser;
+/**
+ * Server Component counterpart of the client `useAuthUser()` hook, reached
+ * via `cloudflare-next-intl/useFirebaseAuthUser`'s `react-server` condition
+ * (resolved automatically — not meant to be imported directly by name).
+ * Prefer {@link getAuthUser} for an unconditional, editor-typed-as-async
+ * equivalent.
+ */
+export default function useAuthUser(): Promise<{
+    user: User | null;
+    loading: false;
+}>;
+export {};

package/dist/types/firebase_auth/server/use_auth_user_server.test.d.ts

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

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

@@ -0,0 +1,22 @@
+import type { User } from 'firebase/auth';
+/**
+ * Plain, RSC-serializable projection of `firebase/auth`'s `User` — enough
+ * for first paint on the server; superseded by the real `User` once the
+ * client's `onIdTokenChanged` listener fires.
+ */
+export interface SerializedAuthUser {
+    uid: string;
+    email: string | null;
+    emailVerified: boolean;
+    displayName: string | null;
+}
+export type AuthFormState = {
+    error?: string;
+    success?: boolean;
+};
+/** Overrides for the default English auth error/status messages. */
+export interface AuthActionMessages {
+    success?: string;
+    mismatch?: string;
+}
+export type AuthUser = User | SerializedAuthUser;

package/dist/types/general/cache_variables.bench.d.ts

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