@mohasinac/appkit 2.3.0 → 2.3.1

package/dist/features/auctions/types/index.d.ts

@@ -0,0 +1,73 @@
+import type { MediaField } from "../../media/types/index";
+export interface AuctionItem {
+    id: string;
+    title: string;
+    description?: string;
+    slug?: string;
+    mainImage?: string;
+    images?: string[];
+    media?: MediaField[];
+    currency: string;
+    /** Reserve / buy-now price */
+    price: number;
+    startingBid: number;
+    currentBid?: number;
+    bidCount: number;
+    auctionEndDate: string;
+    status: "published" | "draft" | "archived" | "sold";
+    sellerId: string;
+    storeId?: string;
+    storeSlug?: string;
+    featured: boolean;
+    isAuction: true;
+    video?: {
+        url: string;
+        thumbnailUrl?: string;
+    };
+    createdAt: string;
+    updatedAt: string;
+}
+export interface BidRecord {
+    id: string;
+    auctionId: string;
+    bidderId: string;
+    bidderDisplayName?: string;
+    amount: number;
+    currency: string;
+    placedAt: string;
+    isWinning: boolean;
+}
+export interface AuctionListResponse {
+    items: AuctionItem[];
+    total: number;
+    page: number;
+    pageSize: number;
+    totalPages: number;
+    hasMore: boolean;
+}
+export interface BidListResponse {
+    items: BidRecord[];
+    total: number;
+    hasMore: boolean;
+}
+export interface AuctionListParams {
+    storeSlug?: string;
+    page?: number;
+    pageSize?: number;
+    sort?: string;
+    filters?: string;
+    [key: string]: string | number | boolean | undefined;
+}
+export interface PublicBid {
+    id: string;
+    productId: string;
+    productTitle: string;
+    userId: string;
+    userName: string;
+    bidAmount: number;
+    currency: string;
+    status: string;
+    isWinning: boolean;
+    bidDate: Date | string;
+    autoMaxBid?: number;
+}

package/dist/features/auctions/types/index.js

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

package/dist/features/auth/actions/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./profile-actions";
+export * from "./realtime-token-actions";

package/dist/features/auth/actions/index.js

@@ -0,0 +1,2 @@
+export * from "./profile-actions";
+export * from "./realtime-token-actions";

package/dist/features/auth/actions/profile-actions.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Profile Domain Actions (appkit)
+ *
+ * Pure business functions for profile CRUD, seller stats, and session reads.
+ * Auth, rate-limiting, and Next.js specifics are handled by the consumer.
+ */
+import type { UserDocument } from "../schemas";
+export type UpdateProfileInput = {
+    displayName?: string;
+    email?: string;
+    phoneNumber?: string;
+    photoURL?: string;
+    avatarMetadata?: {
+        url: string;
+        position: {
+            x: number;
+            y: number;
+        };
+        zoom: number;
+    };
+};
+export declare function updateUserProfile(userId: string, input: UpdateProfileInput): Promise<UserDocument>;
+export declare function getUserProfile(userId: string): Promise<UserDocument | null>;
+export declare function getUserSessions(userId: string): Promise<import("..").SessionDocument[]>;
+export declare function getPublicUserProfile(userId: string): Promise<Pick<UserDocument, "id" | "displayName" | "photoURL" | "role" | "createdAt"> | null>;
+export declare function getSellerReviews(sellerId: string): Promise<import("../../reviews").ReviewDocument[]>;
+export declare function getSellerProducts(sellerId: string): Promise<import("../../products").ProductDocument[]>;

package/dist/features/auth/actions/profile-actions.js

@@ -0,0 +1,50 @@
+/**
+ * Profile Domain Actions (appkit)
+ *
+ * Pure business functions for profile CRUD, seller stats, and session reads.
+ * Auth, rate-limiting, and Next.js specifics are handled by the consumer.
+ */
+import { maskPublicReview } from "../../../security";
+import { finalizeStagedMediaField } from "../../media/finalize";
+import { userRepository } from "../repository/user.repository";
+import { sessionRepository } from "../repository/session.repository";
+import { productRepository } from "../../products/repository/products.repository";
+import { ProductStatusValues } from "../../products/schemas";
+import { reviewRepository } from "../../reviews/repository/reviews.repository";
+export async function updateUserProfile(userId, input) {
+    const finalPhotoURL = await finalizeStagedMediaField(input.photoURL);
+    const data = finalPhotoURL !== undefined ? { ...input, photoURL: finalPhotoURL } : input;
+    return userRepository.updateProfileWithVerificationReset(userId, data);
+}
+export async function getUserProfile(userId) {
+    return userRepository.findById(userId);
+}
+export async function getUserSessions(userId) {
+    return sessionRepository.findAllByUser(userId);
+}
+export async function getPublicUserProfile(userId) {
+    const user = await userRepository.findById(userId);
+    if (!user)
+        return null;
+    return {
+        id: user.id,
+        displayName: user.displayName,
+        photoURL: user.photoURL,
+        role: user.role,
+        createdAt: user.createdAt,
+    };
+}
+export async function getSellerReviews(sellerId) {
+    const products = await productRepository.findBySeller(sellerId);
+    const published = products.filter((p) => p.status === ProductStatusValues.PUBLISHED);
+    if (published.length === 0)
+        return [];
+    const batches = await Promise.all(published
+        .slice(0, 20)
+        .map((p) => reviewRepository.findApprovedByProduct(p.id).catch(() => [])));
+    return batches.flat().map(maskPublicReview);
+}
+export async function getSellerProducts(sellerId) {
+    const products = await productRepository.findBySeller(sellerId);
+    return products.filter((p) => p.status === ProductStatusValues.PUBLISHED);
+}

package/dist/features/auth/actions/realtime-token-actions.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Realtime Token Domain Actions — appkit
+ *
+ * Issues a Firebase custom auth token for Realtime Database subscriptions.
+ * Called by letitrip thin wrapper which handles auth + rate limiting.
+ */
+export interface RealtimeTokenResult {
+    customToken: string;
+    expiresAt: number;
+}
+export declare function issueRealtimeToken(userId: string, userRole: string): Promise<RealtimeTokenResult>;

package/dist/features/auth/actions/realtime-token-actions.js

@@ -0,0 +1,31 @@
+/**
+ * Realtime Token Domain Actions — appkit
+ *
+ * Issues a Firebase custom auth token for Realtime Database subscriptions.
+ * Called by letitrip thin wrapper which handles auth + rate limiting.
+ */
+import { getAdminAuth } from "../../../providers/db-firebase/index";
+import { chatRepository } from "../../admin/repository/chat.repository";
+import { serverLogger } from "../../../monitoring/index";
+export async function issueRealtimeToken(userId, userRole) {
+    let chatIds = {};
+    try {
+        const userChatIds = await chatRepository.getChatIdsForUser(userId);
+        chatIds = Object.fromEntries(userChatIds.map((id) => [id, true]));
+    }
+    catch (err) {
+        serverLogger.warn("Could not resolve chatIds for realtime token", {
+            userId,
+            err,
+        });
+    }
+    const customToken = await getAdminAuth().createCustomToken(userId, {
+        role: userRole,
+        chatIds,
+    });
+    serverLogger.info("issueRealtimeToken: token issued", {
+        userId,
+        chatCount: Object.keys(chatIds).length,
+    });
+    return { customToken, expiresAt: Date.now() + 3600000 };
+}

package/dist/features/auth/api/route.d.ts

@@ -0,0 +1,22 @@
+/**
+ * feat-auth — API route handlers
+ *
+ * GET /api/auth/me  — return the currently authenticated user's profile.
+ *
+ * Consumer project wires this as a 2-line stub:
+ *   export { authMeGET as GET } from "@mohasinac/feat-auth";
+ */
+/**
+ * Return the currently authenticated user's profile.
+ * Reads the `__session` HTTP-only cookie → verifies via ISessionProvider →
+ * fetches full profile via IAuthProvider.
+ *
+ * @example (letitrip.in stub)
+ * ```ts
+ * // src/app/api/auth/me/route.ts
+ * export { authMeGET as GET } from "@mohasinac/feat-auth";
+ * ```
+ */
+export declare const authMeGET: (request: Request, context: {
+    params: Promise<Record<string, string>>;
+}) => Promise<Response>;

package/dist/features/auth/api/route.js

@@ -0,0 +1,48 @@
+/**
+ * feat-auth — API route handlers
+ *
+ * GET /api/auth/me  — return the currently authenticated user's profile.
+ *
+ * Consumer project wires this as a 2-line stub:
+ *   export { authMeGET as GET } from "@mohasinac/feat-auth";
+ */
+import { NextResponse } from "next/server.js";
+import { createRouteHandler } from "../../../next";
+import { getProviders } from "../../../contracts";
+// --- Transform ----------------------------------------------------------------
+function toClientUser(u) {
+    return {
+        id: u.uid,
+        email: u.email ?? undefined,
+        displayName: u.displayName ?? undefined,
+        photoURL: u.photoURL ?? undefined,
+        role: u.role,
+        isEmailVerified: u.emailVerified,
+    };
+}
+// --- GET /api/auth/me ---------------------------------------------------------
+/**
+ * Return the currently authenticated user's profile.
+ * Reads the `__session` HTTP-only cookie → verifies via ISessionProvider →
+ * fetches full profile via IAuthProvider.
+ *
+ * @example (letitrip.in stub)
+ * ```ts
+ * // src/app/api/auth/me/route.ts
+ * export { authMeGET as GET } from "@mohasinac/feat-auth";
+ * ```
+ */
+export const authMeGET = createRouteHandler({
+    auth: true,
+    handler: async ({ user }) => {
+        const { auth } = getProviders();
+        if (!auth) {
+            return NextResponse.json({ success: false, error: "Auth provider not configured" }, { status: 503 });
+        }
+        const profile = await auth.getUser(user.uid);
+        if (!profile) {
+            return NextResponse.json({ success: false, error: "User not found" }, { status: 404 });
+        }
+        return NextResponse.json({ success: true, data: toClientUser(profile) });
+    },
+});

package/dist/features/auth/auth-helpers.d.ts

@@ -0,0 +1,14 @@
+import type { UserRole } from "./types";
+export interface DefaultRoleOptions {
+    adminEmails?: string[];
+    adminRole?: UserRole;
+    fallbackRole?: UserRole;
+}
+export declare function hasRole(userRole: UserRole, requiredRole: UserRole): boolean;
+export declare function hasAnyRole(userRole: UserRole, requiredRoles: UserRole[]): boolean;
+export declare function getDefaultRole(email?: string, options?: DefaultRoleOptions): UserRole;
+export declare function formatAuthProvider(provider: string): string;
+export declare function isSessionExpired(expiresAt: Date | string): boolean;
+export declare function getSessionTimeRemaining(expiresAt: Date | string): number;
+export declare function generateInitials(displayName?: string | null, email?: string | null): string;
+export declare function calculatePasswordScore(password: string): number;

package/dist/features/auth/auth-helpers.js

@@ -0,0 +1,68 @@
+import { getTokenTimeRemaining, isTokenExpired } from "./token-helpers";
+const ROLE_HIERARCHY = {
+    user: 0,
+    seller: 1,
+    moderator: 2,
+    admin: 3,
+};
+export function hasRole(userRole, requiredRole) {
+    return ROLE_HIERARCHY[userRole] >= ROLE_HIERARCHY[requiredRole];
+}
+export function hasAnyRole(userRole, requiredRoles) {
+    return requiredRoles.some((role) => hasRole(userRole, role));
+}
+export function getDefaultRole(email, options) {
+    const fallbackRole = options?.fallbackRole ?? "user";
+    const adminRole = options?.adminRole ?? "admin";
+    const adminEmails = options?.adminEmails ?? [];
+    if (email && adminEmails.includes(email)) {
+        return adminRole;
+    }
+    return fallbackRole;
+}
+export function formatAuthProvider(provider) {
+    const providerNames = {
+        password: "Email/Password",
+        "google.com": "Google",
+        "apple.com": "Apple",
+        phone: "Phone",
+    };
+    return providerNames[provider] || provider;
+}
+export function isSessionExpired(expiresAt) {
+    return isTokenExpired(expiresAt);
+}
+export function getSessionTimeRemaining(expiresAt) {
+    return getTokenTimeRemaining(expiresAt);
+}
+export function generateInitials(displayName, email) {
+    if (displayName) {
+        const parts = displayName.trim().split(" ");
+        if (parts.length >= 2) {
+            return `${parts[0][0]}${parts[parts.length - 1][0]}`.toUpperCase();
+        }
+        return displayName.substring(0, 2).toUpperCase();
+    }
+    if (email) {
+        return email.substring(0, 2).toUpperCase();
+    }
+    return "U";
+}
+export function calculatePasswordScore(password) {
+    let score = 0;
+    if (password.length >= 8)
+        score++;
+    if (password.length >= 12)
+        score++;
+    if (/[a-z]/.test(password) && /[A-Z]/.test(password))
+        score++;
+    if (/\d/.test(password))
+        score++;
+    if (/[!@#$%^&*(),.?":{}|<>]/.test(password))
+        score++;
+    if (/(.)\1{2,}/.test(password))
+        score = Math.max(0, score - 1);
+    if (/^(?:password|123456|qwerty)/i.test(password))
+        score = 0;
+    return Math.min(4, Math.max(0, score));
+}

package/dist/features/auth/components/AuthStatusPanel.d.ts

@@ -0,0 +1,10 @@
+import type { ReactNode } from "react";
+type AuthStatusTone = "success" | "error" | "loading";
+interface AuthStatusPanelProps {
+    tone: AuthStatusTone;
+    title: string;
+    message?: string;
+    actions?: ReactNode;
+}
+export declare function AuthStatusPanel({ tone, title, message, actions, }: AuthStatusPanelProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/features/auth/components/AuthStatusPanel.js

@@ -0,0 +1,22 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { Div, Heading, Text } from "../../../ui";
+import { THEME_CONSTANTS } from "../../../tokens";
+function toneClass(tone) {
+    if (tone === "success")
+        return THEME_CONSTANTS.themed.textSuccess;
+    if (tone === "error")
+        return THEME_CONSTANTS.themed.textError;
+    return "text-primary";
+}
+function iconPath(tone) {
+    if (tone === "success") {
+        return "M9 12l2 2 4-4m6 2a9 9 0 11-18 0 9 9 0 0118 0z";
+    }
+    if (tone === "error") {
+        return "M6 18L18 6M6 6l12 12";
+    }
+    return "M12 8v4l3 3m6-3a9 9 0 11-18 0 9 9 0 0118 0z";
+}
+export function AuthStatusPanel({ tone, title, message, actions, }) {
+    return (_jsxs(_Fragment, { children: [_jsx(Div, { className: `mb-4 ${toneClass(tone)}`, children: _jsx("svg", { className: "w-16 h-16 mx-auto", fill: "none", stroke: "currentColor", viewBox: "0 0 24 24", "aria-hidden": "true", children: _jsx("path", { strokeLinecap: "round", strokeLinejoin: "round", strokeWidth: 2, d: iconPath(tone) }) }) }), _jsx(Heading, { level: 2, className: "mb-2 text-xl font-semibold", children: title }), message ? (_jsx(Text, { className: "mb-6 text-sm text-zinc-600 dark:text-zinc-400", children: message })) : null, actions] }));
+}

package/dist/features/auth/components/ForgotPasswordView.d.ts

@@ -0,0 +1,18 @@
+import React from "react";
+export interface ForgotPasswordViewProps {
+    onSubmit: (email: string) => Promise<void>;
+    isLoading?: boolean;
+    error?: string | null;
+    success?: string | null;
+    labels?: {
+        title?: string;
+        description?: string;
+        emailLabel?: string;
+        emailPlaceholder?: string;
+        submitLabel?: string;
+        submittingLabel?: string;
+    };
+    renderBackLink?: () => React.ReactNode;
+    className?: string;
+}
+export declare function ForgotPasswordView({ onSubmit, isLoading, error, success, labels, renderBackLink, className, }: ForgotPasswordViewProps): import("react/jsx-runtime").JSX.Element;

package/dist/features/auth/components/ForgotPasswordView.js

@@ -0,0 +1,15 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useCallback, useState } from "react";
+import { Alert, Div, Heading, Label, Text } from "../../../ui";
+export function ForgotPasswordView({ onSubmit, isLoading = false, error, success, labels = {}, renderBackLink, className = "", }) {
+    const [email, setEmail] = useState("");
+    const handleSubmit = useCallback(async (e) => {
+        e.preventDefault();
+        await onSubmit(email);
+    }, [onSubmit, email]);
+    return (_jsx(Div, { className: `flex items-center justify-center min-h-[60vh] px-4 ${className}`, children: _jsxs(Div, { className: "max-w-md w-full space-y-6", children: [_jsxs(Div, { className: "text-center", children: [_jsx(Heading, { level: 1, className: "text-3xl font-extrabold", children: labels.title ?? "Forgot Password" }), _jsx(Text, { className: "mt-2 text-sm text-neutral-600 dark:text-zinc-400", children: labels.description ??
+                                "Enter your email and we'll send you a reset link." })] }), error && (_jsx(Alert, { variant: "error", compact: true, children: error })), success && (_jsx(Alert, { variant: "success", compact: true, children: success })), !success && (_jsxs("form", { className: "space-y-4", onSubmit: handleSubmit, noValidate: true, children: [_jsxs(Div, { children: [_jsx(Label, { htmlFor: "fp-email", className: "block text-sm font-medium mb-1", children: labels.emailLabel ?? "Email address" }), _jsx("input", { id: "fp-email", name: "email", type: "email", autoComplete: "username", required: true, placeholder: labels.emailPlaceholder ?? "you@example.com", value: email, onChange: (e) => setEmail(e.target.value), className: "w-full rounded-lg border border-neutral-300 dark:border-slate-600 bg-white dark:bg-slate-800 text-zinc-900 dark:text-zinc-100 placeholder:text-neutral-400 dark:placeholder:text-slate-500 px-3 py-2 text-sm focus:outline-none focus:ring-2 focus:ring-primary" })] }), _jsx("button", { type: "submit", disabled: isLoading, className: "w-full rounded-lg bg-primary px-4 py-2.5 text-sm font-semibold text-white disabled:opacity-60 hover:bg-primary/90 transition-colors", children: isLoading
+                                ? (labels.submittingLabel ?? "Sending…")
+                                : (labels.submitLabel ?? "Send reset link") })] })), renderBackLink && (_jsx(Div, { className: "text-center text-sm", children: renderBackLink() }))] }) }));
+}

package/dist/features/auth/components/Guards.d.ts

@@ -0,0 +1,86 @@
+import React from "react";
+import type { UserRole } from "../types";
+/**
+ * User shape for auth guards and route protection.
+ * Consumers can pass a fuller user object; only these fields are used.
+ */
+export interface AuthGuardUser {
+    id?: string;
+    role?: UserRole | string;
+    disabled?: boolean;
+    emailVerified?: boolean;
+}
+/**
+ * Route configuration for authorization redirects.
+ * Injected by the consumer to control where unauthorized users are sent.
+ */
+export interface AuthRouteConfig {
+    loginPath?: string;
+    unauthorizedPath?: string;
+    emailVerifyPath?: string;
+    defaultRedirectPath?: string;
+}
+/**
+ * RoleGate — renders children only if user role matches allowed roles.
+ * @example
+ * ```tsx
+ * <RoleGate
+ *   user={currentUser}
+ *   allowedRoles="admin"
+ *   fallback={<div data-section="guards-div-259">Not authorized</div>}
+ * >
+ *   <AdminPanel />
+ * </RoleGate>
+ * ```
+ */
+export interface RoleGateProps {
+    children: React.ReactNode;
+    user?: AuthGuardUser | null;
+    allowedRoles: UserRole | UserRole[];
+    fallback?: React.ReactNode;
+}
+export declare function RoleGate({ children, user, allowedRoles, fallback, }: RoleGateProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * ProtectedRoute — enforces authentication and authorization with redirect support.
+ *
+ * Handles:
+ * - Authentication (requireAuth)
+ * - Role-based access (requireRole)
+ * - Email verification (requireEmailVerified)
+ * - Account status (requireActiveAccount)
+ * - Redirects to injected route config
+ *
+ * @example
+ * ```tsx
+ * <ProtectedRoute
+ *   user={user}
+ *   loading={isLoading}
+ *   requireAuth
+ *   requireRole="admin"
+ *   onNavigate={(path) => router.push(path)}
+ *   routes={{ loginPath: "/auth/login", unauthorizedPath: "/errors/403" }}
+ * >
+ *   <AdminDashboard />
+ * </ProtectedRoute>
+ * ```
+ */
+export interface ProtectedRouteProps {
+    children?: React.ReactNode;
+    user?: AuthGuardUser | null;
+    loading?: boolean;
+    requireAuth?: boolean;
+    requireRole?: UserRole | UserRole[];
+    requireEmailVerified?: boolean;
+    requireActiveAccount?: boolean;
+    showUnauthorized?: boolean;
+    onNavigate?: (path: string) => void;
+    routes?: AuthRouteConfig;
+    loadingComponent?: React.ReactNode;
+    unauthorizedComponent?: React.ReactNode;
+    uiLabels?: {
+        accessDenied?: string;
+        unauthorizedDescription?: string;
+        goHome?: string;
+    };
+}
+export declare function ProtectedRoute({ children, user, loading, requireAuth, requireRole, requireEmailVerified, requireActiveAccount, showUnauthorized, onNavigate, routes, loadingComponent, unauthorizedComponent, uiLabels, }: ProtectedRouteProps): import("react/jsx-runtime").JSX.Element | null;

package/dist/features/auth/components/Guards.js

@@ -0,0 +1,91 @@
+"use client";
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useMemo } from "react";
+import { Div, Heading, Text, Button } from "../../../ui";
+export function RoleGate({ children, user, allowedRoles, fallback = null, }) {
+    if (!user?.role) {
+        return _jsx(_Fragment, { children: fallback });
+    }
+    const allowed = Array.isArray(allowedRoles) ? allowedRoles : [allowedRoles];
+    if (!allowed.some((role) => role === user.role)) {
+        return _jsx(_Fragment, { children: fallback });
+    }
+    return _jsx(_Fragment, { children: children });
+}
+export function ProtectedRoute({ children, user, loading = false, requireAuth = true, requireRole, requireEmailVerified = false, requireActiveAccount = true, showUnauthorized = false, onNavigate, routes = {}, loadingComponent, unauthorizedComponent, uiLabels = {
+    accessDenied: "Access Denied",
+    unauthorizedDescription: "You do not have permission to access this page.",
+    goHome: "Go Home",
+}, }) {
+    const { loginPath = "/auth/login", unauthorizedPath = "/errors/unauthorized", emailVerifyPath = "/auth/verify-email", defaultRedirectPath = "/", } = routes;
+    const { isAuthorized, redirectPath } = useMemo(() => {
+        // Still loading
+        if (loading)
+            return { isAuthorized: null, redirectPath: null };
+        // Check authentication
+        if (requireAuth && !user) {
+            return { isAuthorized: false, redirectPath: loginPath };
+        }
+        if (!requireAuth && !user) {
+            return { isAuthorized: true, redirectPath: null };
+        }
+        if (user) {
+            // Check account status
+            if (requireActiveAccount && user.disabled) {
+                return { isAuthorized: false, redirectPath: unauthorizedPath };
+            }
+            // Check email verification
+            if (requireEmailVerified && !user.emailVerified) {
+                return { isAuthorized: false, redirectPath: emailVerifyPath };
+            }
+            // Check role
+            if (requireRole) {
+                const roles = Array.isArray(requireRole) ? requireRole : [requireRole];
+                const userRole = user.role;
+                if (!userRole || !roles.some((role) => role === userRole)) {
+                    return { isAuthorized: false, redirectPath: unauthorizedPath };
+                }
+            }
+            return { isAuthorized: true, redirectPath: null };
+        }
+        return { isAuthorized: true, redirectPath: null };
+    }, [
+        user,
+        loading,
+        requireAuth,
+        requireRole,
+        requireEmailVerified,
+        requireActiveAccount,
+        loginPath,
+        emailVerifyPath,
+        unauthorizedPath,
+    ]);
+    // Side-effect: trigger navigation when unauthorized
+    useEffect(() => {
+        if (isAuthorized === false &&
+            redirectPath &&
+            !showUnauthorized &&
+            onNavigate) {
+            onNavigate(redirectPath);
+        }
+    }, [isAuthorized, redirectPath, showUnauthorized, onNavigate]);
+    // Loading state
+    if (loading || isAuthorized === null) {
+        if (loadingComponent) {
+            return _jsx(_Fragment, { children: loadingComponent });
+        }
+        return (_jsx(Div, { className: "flex min-h-[40vh] items-center justify-center", children: _jsx(Div, { className: "h-8 w-8 animate-spin rounded-full border-2 border-neutral-300 border-t-neutral-800" }) }));
+    }
+    // Unauthorized — show message or return null if redirecting
+    if (isAuthorized === false) {
+        if (showUnauthorized) {
+            if (unauthorizedComponent) {
+                return _jsx(_Fragment, { children: unauthorizedComponent });
+            }
+            return (_jsx(Div, { className: "flex min-h-[50vh] items-center justify-center bg-neutral-50 dark:bg-neutral-900", children: _jsxs(Div, { className: "text-center", children: [_jsx(Heading, { level: 1, className: "mb-2 text-2xl font-bold", children: uiLabels.accessDenied }), _jsx(Text, { className: "mb-6 text-neutral-600 dark:text-neutral-400", children: uiLabels.unauthorizedDescription }), _jsx(Button, { onClick: () => onNavigate?.(defaultRedirectPath), variant: "primary", children: uiLabels.goHome })] }) }));
+        }
+        return null;
+    }
+    // Authorized
+    return _jsx(_Fragment, { children: children });
+}

package/dist/features/auth/components/LoginForm.d.ts

@@ -0,0 +1,36 @@
+import React from "react";
+export interface LoginFormValues {
+    email: string;
+    password: string;
+    rememberMe?: boolean;
+}
+export interface LoginFormProps {
+    onSubmit: (values: LoginFormValues) => Promise<void>;
+    onGoogleLogin?: () => Promise<void>;
+    isLoading?: boolean;
+    error?: string | null;
+    labels?: {
+        title?: string;
+        subtitle?: string;
+        signInLink?: string;
+        emailLabel?: string;
+        emailPlaceholder?: string;
+        passwordLabel?: string;
+        passwordPlaceholder?: string;
+        rememberMe?: string;
+        forgotPasswordLabel?: string;
+        submitLabel?: string;
+        submittingLabel?: string;
+        orSeparator?: string;
+    };
+    /** Render social login buttons (e.g. Google) */
+    renderSocialButtons?: () => React.ReactNode;
+    /** Render a "create account" link */
+    renderCreateAccountLink?: () => React.ReactNode;
+    /** Render forgot password link */
+    renderForgotPasswordLink?: () => React.ReactNode;
+    /** Render submit button */
+    renderSubmitButton?: (loading: boolean, labels: LoginFormProps["labels"]) => React.ReactNode;
+    className?: string;
+}
+export declare function LoginForm({ onSubmit, onGoogleLogin, isLoading, error, labels, renderSocialButtons, renderCreateAccountLink, renderForgotPasswordLink, renderSubmitButton, className, }: LoginFormProps): import("react/jsx-runtime").JSX.Element;