@abpjs/account 0.7.6

package/dist/index.mjs

@@ -0,0 +1,552 @@
+// src/providers/AccountProvider.tsx
+import { createContext, useContext, useMemo } from "react";
+import { jsx } from "react/jsx-runtime";
+var DEFAULT_OPTIONS = {
+  redirectUrl: "/"
+};
+var AccountContext = createContext(null);
+function AccountProvider({ children, options }) {
+  const mergedOptions = useMemo(
+    () => ({
+      ...DEFAULT_OPTIONS,
+      ...options
+    }),
+    [options]
+  );
+  const value = useMemo(
+    () => ({
+      options: mergedOptions
+    }),
+    [mergedOptions]
+  );
+  return /* @__PURE__ */ jsx(AccountContext.Provider, { value, children });
+}
+function useAccountContext() {
+  const context = useContext(AccountContext);
+  if (!context) {
+    throw new Error("useAccountContext must be used within an AccountProvider");
+  }
+  return context;
+}
+function useAccountOptions() {
+  const context = useContext(AccountContext);
+  return context?.options ?? DEFAULT_OPTIONS;
+}
+
+// src/hooks/usePasswordFlow.ts
+import { useState, useCallback } from "react";
+import { useAbp, useConfig, configActions } from "@abpjs/core";
+import { useNavigate } from "react-router-dom";
+function usePasswordFlow() {
+  const { store, axiosInstance, applicationConfigurationService, userManager } = useAbp();
+  const config = useConfig();
+  const options = useAccountOptions();
+  const navigate = useNavigate();
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const getTokenEndpoint = useCallback(() => {
+    const oAuthConfig = config.environment.oAuthConfig;
+    if (oAuthConfig?.authority) {
+      const authority = oAuthConfig.authority.replace(/\/+$/, "");
+      return `${authority}/connect/token`;
+    }
+    throw new Error("OAuth authority not configured");
+  }, [config.environment.oAuthConfig]);
+  const login = useCallback(
+    async (username, password, flowOptions) => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        const oAuthConfig = config.environment.oAuthConfig;
+        if (!oAuthConfig?.client_id) {
+          throw new Error("OAuth client_id not configured");
+        }
+        const tokenEndpoint = getTokenEndpoint();
+        const formData = new URLSearchParams();
+        formData.append("grant_type", "password");
+        formData.append("username", username);
+        formData.append("password", password);
+        formData.append("client_id", oAuthConfig.client_id);
+        if (oAuthConfig.scope) {
+          formData.append("scope", oAuthConfig.scope);
+        }
+        const response = await axiosInstance.post(
+          tokenEndpoint,
+          formData.toString(),
+          {
+            headers: {
+              "Content-Type": "application/x-www-form-urlencoded"
+            }
+          }
+        );
+        const tokenData = response.data;
+        const storage = flowOptions?.remember ? localStorage : sessionStorage;
+        const storageKey = `oidc.user:${oAuthConfig.authority}:${oAuthConfig.client_id}`;
+        const userData = {
+          access_token: tokenData.access_token,
+          token_type: tokenData.token_type,
+          expires_at: Math.floor(Date.now() / 1e3) + tokenData.expires_in,
+          refresh_token: tokenData.refresh_token,
+          scope: tokenData.scope,
+          profile: {}
+          // Will be filled after config fetch
+        };
+        storage.setItem(storageKey, JSON.stringify(userData));
+        const oidcKey = `oidc.user:${oAuthConfig.authority}:${oAuthConfig.client_id}`;
+        storage.setItem(oidcKey, JSON.stringify(userData));
+        if (userManager) {
+          const loadedUser = await userManager.getUser();
+          if (loadedUser) {
+            userManager.events.load(loadedUser);
+          }
+        }
+        const appConfig = await applicationConfigurationService.getConfiguration();
+        store.dispatch(configActions.setApplicationConfiguration(appConfig));
+        const redirectUrl = window.history.state?.redirectUrl || options.redirectUrl;
+        navigate(redirectUrl);
+        setIsLoading(false);
+        return { success: true };
+      } catch (err) {
+        const errorMessage = err.response?.data?.error_description || err.response?.data?.error || err.message || "Login failed";
+        setError(errorMessage);
+        setIsLoading(false);
+        console.error("Password flow error:", errorMessage);
+        return { success: false, error: errorMessage };
+      }
+    },
+    [
+      config.environment.oAuthConfig,
+      getTokenEndpoint,
+      axiosInstance,
+      applicationConfigurationService,
+      store,
+      options.redirectUrl,
+      navigate,
+      userManager
+    ]
+  );
+  const clearError = useCallback(() => {
+    setError(null);
+  }, []);
+  return {
+    login,
+    isLoading,
+    error,
+    clearError
+  };
+}
+
+// src/components/TenantBox/TenantBox.tsx
+import { useState as useState2, useCallback as useCallback2 } from "react";
+import { useForm } from "react-hook-form";
+import { useLocalization } from "@abpjs/core";
+import { Modal, Button, FormField } from "@abpjs/theme-shared";
+import { Box, Text, Link, Input, VStack } from "@chakra-ui/react";
+import { Fragment, jsx as jsx2, jsxs } from "react/jsx-runtime";
+function TenantBox({ containerStyle }) {
+  const { t } = useLocalization();
+  const [selected, setSelected] = useState2(null);
+  const [modalVisible, setModalVisible] = useState2(false);
+  const { register, handleSubmit, reset } = useForm({
+    defaultValues: {
+      name: ""
+    }
+  });
+  const openModal = useCallback2(() => {
+    reset({ name: selected?.name || "" });
+    setModalVisible(true);
+  }, [selected, reset]);
+  const onSwitch = useCallback2(() => {
+    setSelected(null);
+    openModal();
+  }, [openModal]);
+  const onSave = useCallback2((data) => {
+    setSelected(data.name ? data : null);
+    setModalVisible(false);
+  }, []);
+  const onClose = useCallback2(() => {
+    setModalVisible(false);
+  }, []);
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsxs(
+      Box,
+      {
+        className: "tenant-switch-box",
+        bg: "gray.100",
+        mb: 5,
+        color: "black",
+        p: 2.5,
+        textAlign: "center",
+        borderRadius: "md",
+        style: containerStyle,
+        children: [
+          /* @__PURE__ */ jsxs(Text, { as: "span", color: "gray.600", children: [
+            t("AbpUiMultiTenancy::Tenant"),
+            ":",
+            " "
+          ] }),
+          /* @__PURE__ */ jsx2(Text, { as: "strong", children: /* @__PURE__ */ jsx2(Text, { as: "i", children: selected?.name || t("AbpUiMultiTenancy::NotSelected") }) }),
+          " (",
+          /* @__PURE__ */ jsx2(
+            Link,
+            {
+              id: "abp-tenant-switch-link",
+              color: "gray.700",
+              cursor: "pointer",
+              onClick: onSwitch,
+              _hover: { textDecoration: "underline" },
+              children: t("AbpUiMultiTenancy::Switch")
+            }
+          ),
+          ")"
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsx2(
+      Modal,
+      {
+        visible: modalVisible,
+        onVisibleChange: setModalVisible,
+        size: "md",
+        header: t("AbpUiMultiTenancy::SwitchTenant") || "Switch Tenant",
+        footer: /* @__PURE__ */ jsxs(Fragment, { children: [
+          /* @__PURE__ */ jsx2(Button, { variant: "ghost", colorPalette: "gray", onClick: onClose, children: t("AbpTenantManagement::Cancel") }),
+          /* @__PURE__ */ jsxs(Button, { colorPalette: "blue", onClick: handleSubmit(onSave), children: [
+            /* @__PURE__ */ jsx2(CheckIcon, {}),
+            t("AbpTenantManagement::Save")
+          ] })
+        ] }),
+        children: /* @__PURE__ */ jsx2("form", { onSubmit: handleSubmit(onSave), children: /* @__PURE__ */ jsxs(VStack, { gap: 4, align: "stretch", children: [
+          /* @__PURE__ */ jsx2(FormField, { label: t("AbpUiMultiTenancy::Name"), htmlFor: "tenant-name", children: /* @__PURE__ */ jsx2(Input, { id: "tenant-name", type: "text", ...register("name") }) }),
+          /* @__PURE__ */ jsx2(Text, { fontSize: "sm", color: "gray.600", children: t("AbpUiMultiTenancy::SwitchTenantHint") })
+        ] }) })
+      }
+    )
+  ] });
+}
+function CheckIcon() {
+  return /* @__PURE__ */ jsx2(
+    "svg",
+    {
+      xmlns: "http://www.w3.org/2000/svg",
+      width: "16",
+      height: "16",
+      viewBox: "0 0 24 24",
+      fill: "none",
+      stroke: "currentColor",
+      strokeWidth: "2",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      children: /* @__PURE__ */ jsx2("polyline", { points: "20 6 9 17 4 12" })
+    }
+  );
+}
+
+// src/components/LoginForm/LoginForm.tsx
+import { useForm as useForm2 } from "react-hook-form";
+import { zodResolver } from "@hookform/resolvers/zod";
+import { z } from "zod";
+import { Link as RouterLink } from "react-router-dom";
+import { useLocalization as useLocalization2 } from "@abpjs/core";
+import { Alert, Button as Button2, Checkbox } from "@abpjs/theme-shared";
+import { Box as Box2, Heading, Input as Input2, Link as Link2, HStack, Show } from "@chakra-ui/react";
+import {
+  Card,
+  Container,
+  Field,
+  Flex,
+  InputGroup,
+  Stack,
+  Text as Text2
+} from "@chakra-ui/react";
+import { LuLock, LuMail } from "react-icons/lu";
+import { jsx as jsx3, jsxs as jsxs2 } from "react/jsx-runtime";
+var loginSchema = z.object({
+  username: z.string().min(1, "Username is required").max(255, "Username must be at most 255 characters"),
+  password: z.string().min(1, "Password is required").max(32, "Password must be at most 32 characters"),
+  remember: z.boolean().default(false)
+});
+function LoginForm({
+  showTenantBox = true,
+  showRegisterLink = true,
+  registerUrl = "/account/register",
+  onLoginSuccess,
+  onLoginError
+}) {
+  const { t } = useLocalization2();
+  const { login, isLoading, error, clearError } = usePasswordFlow();
+  const {
+    register,
+    handleSubmit,
+    formState: { errors, isSubmitting }
+  } = useForm2({
+    resolver: zodResolver(loginSchema),
+    defaultValues: {
+      username: "",
+      password: "",
+      remember: false
+    }
+  });
+  const onSubmit = async (data) => {
+    clearError();
+    const result = await login(data.username, data.password, {
+      remember: data.remember
+    });
+    if (result.success) {
+      onLoginSuccess?.();
+    } else if (result.error) {
+      onLoginError?.(result.error);
+    }
+  };
+  const isFormLoading = isLoading || isSubmitting;
+  return /* @__PURE__ */ jsx3(Flex, { height: "full", flex: "1", children: /* @__PURE__ */ jsx3(Box2, { flex: "1.5", py: { base: "24", md: "32" }, children: /* @__PURE__ */ jsx3(Container, { maxW: "md", children: /* @__PURE__ */ jsxs2(Stack, { gap: "8", children: [
+    /* @__PURE__ */ jsx3(Show, { when: showTenantBox, children: /* @__PURE__ */ jsx3(TenantBox, {}) }),
+    /* @__PURE__ */ jsx3(Stack, { gap: { base: "2", md: "3" }, textAlign: "center", children: /* @__PURE__ */ jsx3(Heading, { size: { base: "2xl", md: "3xl" }, children: t("AbpAccount::Login") }) }),
+    error && /* @__PURE__ */ jsx3(Alert, { status: "error", children: error }),
+    /* @__PURE__ */ jsx3("form", { onSubmit: handleSubmit(onSubmit), noValidate: true, children: /* @__PURE__ */ jsxs2(Stack, { gap: "6", children: [
+      /* @__PURE__ */ jsxs2(Stack, { gap: "5", children: [
+        /* @__PURE__ */ jsxs2(Field.Root, { invalid: !!errors.username, children: [
+          /* @__PURE__ */ jsx3(Field.Label, { children: t("AbpAccount::UserNameOrEmailAddress") }),
+          /* @__PURE__ */ jsx3(InputGroup, { startElement: /* @__PURE__ */ jsx3(LuMail, {}), width: "full", children: /* @__PURE__ */ jsx3(
+            Input2,
+            {
+              id: "login-input-user-name-or-email-address",
+              type: "text",
+              autoComplete: "username",
+              placeholder: "me@example.com",
+              ...register("username")
+            }
+          ) }),
+          errors.username && /* @__PURE__ */ jsx3(Field.ErrorText, { children: errors.username.message })
+        ] }),
+        /* @__PURE__ */ jsxs2(Field.Root, { invalid: !!errors.password, children: [
+          /* @__PURE__ */ jsx3(Field.Label, { children: t("AbpAccount::Password") }),
+          /* @__PURE__ */ jsx3(InputGroup, { startElement: /* @__PURE__ */ jsx3(LuLock, {}), width: "full", children: /* @__PURE__ */ jsx3(
+            Input2,
+            {
+              id: "login-input-password",
+              type: "password",
+              autoComplete: "current-password",
+              placeholder: "\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022",
+              ...register("password")
+            }
+          ) }),
+          errors.password && /* @__PURE__ */ jsx3(Field.ErrorText, { children: errors.password.message })
+        ] }),
+        /* @__PURE__ */ jsx3(Checkbox, { id: "login-input-remember-me", ...register("remember"), children: t("AbpAccount::RememberMe") }),
+        /* @__PURE__ */ jsx3(
+          Button2,
+          {
+            type: "submit",
+            colorPalette: "blue",
+            loading: isFormLoading,
+            loadingText: t("AbpAccount::Login"),
+            children: t("AbpAccount::Login")
+          }
+        ),
+        /* @__PURE__ */ jsx3(Link2, { variant: "plain", children: t("AbpAccount::ForgotPassword") })
+      ] }),
+      /* @__PURE__ */ jsx3(Show, { when: showRegisterLink, children: /* @__PURE__ */ jsx3(Card.Root, { size: "sm", mt: "10", children: /* @__PURE__ */ jsx3(Card.Body, { children: /* @__PURE__ */ jsxs2(HStack, { textStyle: "sm", children: [
+        /* @__PURE__ */ jsx3(Text2, { children: t("AbpAccount::AreYouANewUser") }),
+        /* @__PURE__ */ jsx3(Link2, { asChild: true, variant: "underline", fontWeight: "semibold", children: /* @__PURE__ */ jsx3(RouterLink, { to: registerUrl, children: t("AbpAccount::Register") }) })
+      ] }) }) }) })
+    ] }) })
+  ] }) }) }) });
+}
+
+// src/components/RegisterForm/RegisterForm.tsx
+import { useForm as useForm3 } from "react-hook-form";
+import { zodResolver as zodResolver2 } from "@hookform/resolvers/zod";
+import { z as z2 } from "zod";
+import { Link as RouterLink2 } from "react-router-dom";
+import { useLocalization as useLocalization3 } from "@abpjs/core";
+import { Button as Button3 } from "@abpjs/theme-shared";
+import { Box as Box3, Heading as Heading2, Input as Input3, Link as Link3, HStack as HStack2, Show as Show2 } from "@chakra-ui/react";
+import {
+  Card as Card2,
+  Container as Container2,
+  Field as Field2,
+  Flex as Flex2,
+  InputGroup as InputGroup2,
+  Stack as Stack2,
+  Text as Text3
+} from "@chakra-ui/react";
+import { LuLock as LuLock2, LuMail as LuMail2, LuUser } from "react-icons/lu";
+import { jsx as jsx4, jsxs as jsxs3 } from "react/jsx-runtime";
+var passwordValidation = {
+  hasLowercase: /[a-z]/,
+  hasUppercase: /[A-Z]/,
+  hasNumber: /[0-9]/,
+  hasSpecial: /[!@#$%^&*(),.?":{}|<>]/
+};
+var registerSchema = z2.object({
+  username: z2.string().min(1, "Username is required").max(255, "Username must be at most 255 characters"),
+  email: z2.string().min(1, "Email is required").email("Please enter a valid email address"),
+  password: z2.string().min(6, "Password must be at least 6 characters").max(32, "Password must be at most 32 characters").refine(
+    (val) => passwordValidation.hasLowercase.test(val),
+    "Password must contain at least one lowercase letter"
+  ).refine(
+    (val) => passwordValidation.hasUppercase.test(val),
+    "Password must contain at least one uppercase letter"
+  ).refine(
+    (val) => passwordValidation.hasNumber.test(val),
+    "Password must contain at least one number"
+  ).refine(
+    (val) => passwordValidation.hasSpecial.test(val),
+    "Password must contain at least one special character"
+  )
+});
+function RegisterForm({
+  showTenantBox = true,
+  showLoginLink = true,
+  loginUrl = "/account/login",
+  onRegisterSuccess,
+  // Note: onRegisterError will be used when registration API is implemented
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  onRegisterError: _onRegisterError
+}) {
+  const { t } = useLocalization3();
+  const {
+    register,
+    handleSubmit,
+    formState: { errors, isSubmitting }
+  } = useForm3({
+    resolver: zodResolver2(registerSchema),
+    defaultValues: {
+      username: "",
+      email: "",
+      password: ""
+    }
+  });
+  const onSubmit = async (data) => {
+    console.log("Register form submitted (no API call in v0.7.6):", data);
+    onRegisterSuccess?.();
+  };
+  return /* @__PURE__ */ jsx4(Flex2, { height: "full", flex: "1", children: /* @__PURE__ */ jsx4(Box3, { flex: "1.5", py: { base: "24", md: "32" }, children: /* @__PURE__ */ jsx4(Container2, { maxW: "md", children: /* @__PURE__ */ jsxs3(Stack2, { gap: "8", children: [
+    /* @__PURE__ */ jsx4(Show2, { when: showTenantBox, children: /* @__PURE__ */ jsx4(TenantBox, {}) }),
+    /* @__PURE__ */ jsx4(Stack2, { gap: { base: "2", md: "3" }, textAlign: "center", children: /* @__PURE__ */ jsx4(Heading2, { size: { base: "2xl", md: "3xl" }, children: t("AbpAccount::Register") }) }),
+    /* @__PURE__ */ jsx4("form", { onSubmit: handleSubmit(onSubmit), noValidate: true, children: /* @__PURE__ */ jsxs3(Stack2, { gap: "6", children: [
+      /* @__PURE__ */ jsxs3(Stack2, { gap: "5", children: [
+        /* @__PURE__ */ jsxs3(Field2.Root, { invalid: !!errors.username, children: [
+          /* @__PURE__ */ jsx4(Field2.Label, { children: t("AbpAccount::UserName") }),
+          /* @__PURE__ */ jsx4(InputGroup2, { startElement: /* @__PURE__ */ jsx4(LuUser, {}), width: "full", children: /* @__PURE__ */ jsx4(
+            Input3,
+            {
+              id: "input-user-name",
+              type: "text",
+              autoFocus: true,
+              autoComplete: "username",
+              placeholder: "johndoe",
+              ...register("username")
+            }
+          ) }),
+          errors.username && /* @__PURE__ */ jsx4(Field2.ErrorText, { children: errors.username.message })
+        ] }),
+        /* @__PURE__ */ jsxs3(Field2.Root, { invalid: !!errors.email, children: [
+          /* @__PURE__ */ jsx4(Field2.Label, { children: t("AbpAccount::EmailAddress") }),
+          /* @__PURE__ */ jsx4(InputGroup2, { startElement: /* @__PURE__ */ jsx4(LuMail2, {}), width: "full", children: /* @__PURE__ */ jsx4(
+            Input3,
+            {
+              id: "input-email-address",
+              type: "email",
+              autoComplete: "email",
+              placeholder: "me@example.com",
+              ...register("email")
+            }
+          ) }),
+          errors.email && /* @__PURE__ */ jsx4(Field2.ErrorText, { children: errors.email.message })
+        ] }),
+        /* @__PURE__ */ jsxs3(Field2.Root, { invalid: !!errors.password, children: [
+          /* @__PURE__ */ jsx4(Field2.Label, { children: t("AbpAccount::Password") }),
+          /* @__PURE__ */ jsx4(InputGroup2, { startElement: /* @__PURE__ */ jsx4(LuLock2, {}), width: "full", children: /* @__PURE__ */ jsx4(
+            Input3,
+            {
+              id: "input-password",
+              type: "password",
+              autoComplete: "new-password",
+              placeholder: "\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022",
+              ...register("password")
+            }
+          ) }),
+          errors.password && /* @__PURE__ */ jsx4(Field2.ErrorText, { children: errors.password.message })
+        ] }),
+        /* @__PURE__ */ jsx4(
+          Button3,
+          {
+            type: "submit",
+            colorPalette: "blue",
+            loading: isSubmitting,
+            loadingText: t("AbpAccount::Register"),
+            children: t("AbpAccount::Register")
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsx4(Show2, { when: showLoginLink, children: /* @__PURE__ */ jsx4(Card2.Root, { size: "sm", mt: "10", children: /* @__PURE__ */ jsx4(Card2.Body, { children: /* @__PURE__ */ jsxs3(HStack2, { textStyle: "sm", children: [
+        /* @__PURE__ */ jsx4(Text3, { children: t("AbpAccount::AlreadyRegistered") }),
+        /* @__PURE__ */ jsx4(Link3, { asChild: true, variant: "underline", fontWeight: "semibold", children: /* @__PURE__ */ jsx4(RouterLink2, { to: loginUrl, children: t("AbpAccount::Login") }) })
+      ] }) }) }) })
+    ] }) })
+  ] }) }) }) });
+}
+
+// src/pages/LoginPage.tsx
+import { Container as Container3, Center } from "@chakra-ui/react";
+import { jsx as jsx5 } from "react/jsx-runtime";
+function LoginPage({
+  maxWidth = "container.sm",
+  ...loginFormProps
+}) {
+  return /* @__PURE__ */ jsx5(Container3, { maxW: maxWidth, py: 10, children: /* @__PURE__ */ jsx5(Center, { children: /* @__PURE__ */ jsx5(LoginForm, { ...loginFormProps }) }) });
+}
+
+// src/pages/RegisterPage.tsx
+import { Container as Container4, Center as Center2 } from "@chakra-ui/react";
+import { jsx as jsx6 } from "react/jsx-runtime";
+function RegisterPage({
+  maxWidth = "container.sm",
+  ...registerFormProps
+}) {
+  return /* @__PURE__ */ jsx6(Container4, { maxW: maxWidth, py: 10, children: /* @__PURE__ */ jsx6(Center2, { children: /* @__PURE__ */ jsx6(RegisterForm, { ...registerFormProps }) }) });
+}
+
+// src/routes/index.ts
+import { eLayoutType } from "@abpjs/core";
+var ACCOUNT_ROUTES = [
+  {
+    name: "Account",
+    path: "account",
+    invisible: true,
+    layout: eLayoutType.application,
+    children: [
+      {
+        path: "login",
+        name: "Login",
+        order: 1
+      },
+      {
+        path: "register",
+        name: "Register",
+        order: 2
+      }
+    ]
+  }
+];
+var DEFAULT_REDIRECT_URL = "/";
+var ACCOUNT_PATHS = {
+  login: "/account/login",
+  register: "/account/register"
+};
+export {
+  ACCOUNT_PATHS,
+  ACCOUNT_ROUTES,
+  AccountProvider,
+  DEFAULT_REDIRECT_URL,
+  LoginForm,
+  LoginPage,
+  RegisterForm,
+  RegisterPage,
+  TenantBox,
+  useAccountContext,
+  useAccountOptions,
+  usePasswordFlow
+};

package/dist/models/index.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Account module type definitions
+ */
+/**
+ * Account module configuration options
+ */
+export interface AccountOptions {
+    /**
+     * URL to redirect to after successful login
+     * @default '/'
+     */
+    redirectUrl?: string;
+}
+/**
+ * Login form data structure
+ */
+export interface LoginFormData {
+    username: string;
+    password: string;
+    remember: boolean;
+}
+/**
+ * Register form data structure
+ */
+export interface RegisterFormData {
+    username: string;
+    email: string;
+    password: string;
+}
+/**
+ * Tenant selection data
+ */
+export interface TenantInfo {
+    name: string;
+}
+/**
+ * Password flow result
+ */
+export interface PasswordFlowResult {
+    success: boolean;
+    error?: string;
+}

package/dist/pages/LoginPage.d.ts

@@ -0,0 +1,25 @@
+import { type LoginFormProps } from '../components';
+/**
+ * Props for LoginPage component
+ */
+export interface LoginPageProps extends LoginFormProps {
+    /**
+     * Maximum width of the container
+     * @default 'container.sm'
+     */
+    maxWidth?: string;
+}
+/**
+ * LoginPage - Page wrapper for the login form
+ *
+ * This component wraps LoginForm with proper layout and spacing.
+ * It's designed to be used as a route component.
+ *
+ * @example
+ * ```tsx
+ * // In your routes configuration
+ * <Route path="/account/login" element={<LoginPage />} />
+ * ```
+ */
+export declare function LoginPage({ maxWidth, ...loginFormProps }: LoginPageProps): import("react/jsx-runtime").JSX.Element;
+export default LoginPage;

package/dist/pages/RegisterPage.d.ts

@@ -0,0 +1,25 @@
+import { type RegisterFormProps } from '../components';
+/**
+ * Props for RegisterPage component
+ */
+export interface RegisterPageProps extends RegisterFormProps {
+    /**
+     * Maximum width of the container
+     * @default 'container.sm'
+     */
+    maxWidth?: string;
+}
+/**
+ * RegisterPage - Page wrapper for the registration form
+ *
+ * This component wraps RegisterForm with proper layout and spacing.
+ * It's designed to be used as a route component.
+ *
+ * @example
+ * ```tsx
+ * // In your routes configuration
+ * <Route path="/account/register" element={<RegisterPage />} />
+ * ```
+ */
+export declare function RegisterPage({ maxWidth, ...registerFormProps }: RegisterPageProps): import("react/jsx-runtime").JSX.Element;
+export default RegisterPage;

package/dist/pages/index.d.ts

@@ -0,0 +1,2 @@
+export { LoginPage, type LoginPageProps } from './LoginPage';
+export { RegisterPage, type RegisterPageProps } from './RegisterPage';

package/dist/providers/AccountProvider.d.ts

@@ -0,0 +1,40 @@
+import React from 'react';
+import type { AccountOptions } from '../models';
+/**
+ * Account context value
+ */
+export interface AccountContextValue {
+    options: Required<AccountOptions>;
+}
+/**
+ * Props for AccountProvider
+ */
+export interface AccountProviderProps {
+    children: React.ReactNode;
+    options?: AccountOptions;
+}
+/**
+ * AccountProvider - Provides account configuration to the component tree
+ *
+ * This is the React equivalent of Angular's AccountModule.forRoot(options)
+ *
+ * @example
+ * ```tsx
+ * <AccountProvider options={{ redirectUrl: '/dashboard' }}>
+ *   <App />
+ * </AccountProvider>
+ * ```
+ */
+export declare function AccountProvider({ children, options }: AccountProviderProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * Hook to access the account context
+ *
+ * @throws Error if used outside of AccountProvider
+ */
+export declare function useAccountContext(): AccountContextValue;
+/**
+ * Hook to access account options
+ *
+ * Returns default options if not within AccountProvider (for standalone usage)
+ */
+export declare function useAccountOptions(): Required<AccountOptions>;

package/dist/providers/index.d.ts

@@ -0,0 +1 @@
+export { AccountProvider, useAccountContext, useAccountOptions, type AccountProviderProps, type AccountContextValue, } from './AccountProvider';