@leancodepl/kratos 8.5.0 → 8.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leancodepl/kratos",
-  "version": "8.5.0",
+  "version": "8.6.0",
   "license": "Apache-2.0",
   "publishConfig": {
     "access": "public",
@@ -45,11 +45,6 @@
     "name": "LeanCode",
     "url": "https://leancode.co"
   },
-  "files": [
-    "dist",
-    "README.md",
-    "CHANGELOG.md"
-  ],
   "sideEffects": false,
   "exports": {
     "./package.json": "./package.json",

package/src/index.d.ts

@@ -0,0 +1,12 @@
+export * from "./lib/createKratosClient";
+export * from "./lib/kratosContext";
+export * from "./lib/kratosContextProvider";
+export * from "./lib/utils/variables";
+export * from "./lib/types/responseError";
+export * from "./lib/types/useHandleFlowError";
+export * from "./lib/sessionManager/baseSessionManager";
+export * from "./lib/types/enums";
+export * from "./lib/types/components";
+export * from "./lib/utils/typeGuards";
+export * from "./lib/flows";
+export * from "./lib/cards";

package/src/lib/cards/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./userAuthCard";
+export * from "./userSettingsCard";

package/src/lib/cards/userAuthCard.d.ts

@@ -0,0 +1,62 @@
+import { LoginFlow, RecoveryFlow, RegistrationFlow, UpdateLoginFlowBody, UpdateRecoveryFlowBody, UpdateRegistrationFlowBody, UpdateVerificationFlowBody, VerificationFlow } from "@ory/client";
+import { UserAuthFormAdditionalProps } from "../helpers/userAuthForm";
+type UserAuthCardProps<TBody> = UserAuthFormAdditionalProps<TBody> & {
+    className?: string;
+    flow: LoginFlow | RecoveryFlow | RegistrationFlow | VerificationFlow;
+    flowType: "login" | "recovery" | "registration" | "verification";
+};
+/**
+ * Pre-built login card component for Kratos login flows.
+ *
+ * Renders a complete login form with support for password, passkey, OIDC,
+ * multi-factor authentication, and identifier-first flows.
+ *
+ * @param flow - Kratos login flow object
+ * @param onSubmit - Form submission handler
+ * @param className - Optional CSS class name
+ * @returns JSX element with login form
+ */
+export declare const LoginCard: ({ ...props }: Omit<UserAuthCardProps<UpdateLoginFlowBody>, "flow" | "flowType"> & {
+    flow: LoginFlow;
+}) => import("react/jsx-runtime").JSX.Element;
+/**
+ * Pre-built verification card component for Kratos verification flows.
+ *
+ * Renders a complete verification form for email/phone verification processes.
+ *
+ * @param flow - Kratos verification flow object
+ * @param onSubmit - Form submission handler
+ * @param className - Optional CSS class name
+ * @returns JSX element with verification form
+ */
+export declare const VerificationCard: ({ ...props }: Omit<UserAuthCardProps<UpdateVerificationFlowBody>, "flow" | "flowType"> & {
+    flow: VerificationFlow;
+}) => import("react/jsx-runtime").JSX.Element;
+/**
+ * Pre-built registration card component for Kratos registration flows.
+ *
+ * Renders a complete registration form with support for profile fields,
+ * password, passkey, and OIDC registration methods.
+ *
+ * @param flow - Kratos registration flow object
+ * @param onSubmit - Form submission handler
+ * @param className - Optional CSS class name
+ * @returns JSX element with registration form
+ */
+export declare const RegistrationCard: ({ ...props }: Omit<UserAuthCardProps<UpdateRegistrationFlowBody>, "flow" | "flowType"> & {
+    flow: RegistrationFlow;
+}) => import("react/jsx-runtime").JSX.Element;
+/**
+ * Pre-built recovery card component for Kratos account recovery flows.
+ *
+ * Renders a complete recovery form for password reset and account recovery processes.
+ *
+ * @param flow - Kratos recovery flow object
+ * @param onSubmit - Form submission handler
+ * @param className - Optional CSS class name
+ * @returns JSX element with recovery form
+ */
+export declare const RecoveryCard: ({ ...props }: Omit<UserAuthCardProps<UpdateRecoveryFlowBody>, "flow" | "flowType"> & {
+    flow: RecoveryFlow;
+}) => import("react/jsx-runtime").JSX.Element;
+export {};

package/src/lib/cards/userSettingsCard.d.ts

@@ -0,0 +1,36 @@
+import { JSX } from "react";
+import { SettingsFlow, UiNodeGroupEnum, UpdateSettingsFlowBody } from "@ory/client";
+import { UserAuthFormAdditionalProps } from "../helpers/userAuthForm";
+export type UserSettingsFlowType = typeof UiNodeGroupEnum.LookupSecret | typeof UiNodeGroupEnum.Oidc | typeof UiNodeGroupEnum.Passkey | typeof UiNodeGroupEnum.Password | typeof UiNodeGroupEnum.Profile | typeof UiNodeGroupEnum.Totp;
+export type UserSettingsCardProps = UserAuthFormAdditionalProps<UpdateSettingsFlowBody> & {
+    flow: SettingsFlow;
+    flowType: UserSettingsFlowType;
+    className?: string;
+};
+/**
+ * Pre-built settings card component for Kratos settings flows.
+ *
+ * Renders different settings sections based on flow type: profile, password,
+ * passkey, TOTP, lookup secrets, or OIDC settings management.
+ *
+ * @param flow - Kratos settings flow object
+ * @param flowType - Type of settings flow to render
+ * @param onSubmit - Form submission handler
+ * @param className - Optional CSS class name
+ * @returns JSX element with settings form or null if flow type unavailable
+ * @example
+ * ```typescript
+ * import { UserSettingsCard } from '@leancodepl/kratos';
+ *
+ * function ProfileSettings() {
+ *   return (
+ *     <UserSettingsCard
+ *       flow={settingsFlow}
+ *       flowType="profile"
+ *       onSubmit={handleSubmit}
+ *     />
+ *   );
+ * }
+ * ```
+ */
+export declare function UserSettingsCard({ flow, flowType, onSubmit, className }: UserSettingsCardProps): JSX.Element | null;

package/src/lib/createKratosClient.d.ts

@@ -0,0 +1,19 @@
+import { ConfigurationParameters, FrontendApi } from "@ory/client";
+/**
+ * Creates Ory Kratos FrontendApi client with axios and credentials configuration.
+ *
+ * Initializes a Kratos client for browser-based applications with automatic
+ * cookie handling and CORS support for authentication flows.
+ *
+ * @param configuration - Kratos client configuration parameters
+ * @returns Configured FrontendApi instance for Kratos operations
+ * @example
+ * ```typescript
+ * import { createKratosClient } from '@leancodepl/kratos';
+ *
+ * const kratosClient = createKratosClient({
+ *   basePath: 'https://auth.example.com'
+ * });
+ * ```
+ */
+export declare function createKratosClient(configuration: ConfigurationParameters): FrontendApi;

package/src/lib/defaultComponents/DefaultButtonComponent/index.d.ts

@@ -0,0 +1,2 @@
+import type { ButtonComponentProps } from "../../types/components";
+export declare function DefaultButtonComponent({ header, ...props }: ButtonComponentProps): import("react/jsx-runtime").JSX.Element;

package/src/lib/defaultComponents/DefaultCheckboxComponent/index.d.ts

@@ -0,0 +1,2 @@
+import type { CheckboxComponentProps } from "../../types/components";
+export declare function DefaultCheckboxComponent({ label, helperMessage, ...props }: CheckboxComponentProps): import("react/jsx-runtime").JSX.Element;

package/src/lib/defaultComponents/DefaultImageComponent/index.d.ts

@@ -0,0 +1,2 @@
+import type { ImageComponentProps } from "../../types/components";
+export declare function DefaultImageComponent({ header, ...props }: ImageComponentProps): import("react/jsx-runtime").JSX.Element;

package/src/lib/defaultComponents/DefaultInputComponent/index.d.ts

@@ -0,0 +1,2 @@
+import type { InputComponentProps } from "../../types/components";
+export declare function DefaultInputComponent({ helperMessage, header, ...props }: InputComponentProps): import("react/jsx-runtime").JSX.Element;

package/src/lib/defaultComponents/DefaultLinkComponent/index.d.ts

@@ -0,0 +1,2 @@
+import type { LinkComponentProps } from "../../types/components";
+export declare function DefaultLinkComponent({ href: _href, ...props }: LinkComponentProps): import("react/jsx-runtime").JSX.Element;

package/src/lib/defaultComponents/DefaultMessageComponent/index.d.ts

@@ -0,0 +1,2 @@
+import type { MessageComponentProps } from "../../types/components";
+export declare function DefaultMessageComponent({ children }: MessageComponentProps): import("react/jsx-runtime").JSX.Element;

package/src/lib/defaultComponents/DefaultMessageFormatComponent/index.d.ts

@@ -0,0 +1,2 @@
+import type { MessageFormatComponentProps } from "../../types/components";
+export declare function DefaultMessageFormatComponent({ text }: MessageFormatComponentProps): import("react/jsx-runtime").JSX.Element;

package/src/lib/defaultComponents/DefaultTextComponent/index.d.ts

@@ -0,0 +1,2 @@
+import type { TextComponentProps } from "../../types/components";
+export declare function DefaultTextComponent({ label, codes }: TextComponentProps): import("react/jsx-runtime").JSX.Element;

package/src/lib/defaultComponents/DefaultUiMessagesComponent/index.d.ts

@@ -0,0 +1,2 @@
+import type { UiMessagesComponentProps } from "../../types/components";
+export declare function DefaultUiMessagesComponent(props: UiMessagesComponentProps): import("react/jsx-runtime").JSX.Element;

package/src/lib/defaultComponents.d.ts

@@ -0,0 +1,2 @@
+import type { KratosComponents } from "./types/components";
+export declare const defaultComponents: KratosComponents;

package/src/lib/flows/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./useReauthenticationFlow";
+export * from "./useRecoveryFlow";
+export * from "./useSettingsFlow";
+export * from "./useLoginFlow";
+export * from "./useRegistrationFlow";
+export * from "./useVerificationFlow";
+export * from "./useLogoutFlow";

package/src/lib/flows/useLoginFlow.d.ts

@@ -0,0 +1,50 @@
+import { FrontendApi, LoginFlow, Session, UpdateLoginFlowBody } from "@ory/client";
+import { aalParameterName, flowIdParameterName, refreshParameterName, returnToParameterName } from "../utils/variables";
+export type LoginSearchParams = {
+    [flowIdParameterName]?: string;
+    [returnToParameterName]?: string;
+    [refreshParameterName]?: string;
+    [aalParameterName]?: string;
+};
+/**
+ * Manages Kratos login flow state and form submission.
+ *
+ * Handles login flow creation, retrieval, and submission with automatic error handling,
+ * URL parameter management, and session callbacks. Supports multi-factor authentication
+ * and refresh flows.
+ *
+ * @param kratosClient - Configured Kratos FrontendApi client
+ * @param returnTo - URL to redirect after successful login
+ * @param onLoggedIn - Callback executed when user successfully logs in
+ * @param onSessionAlreadyAvailable - Callback when session already exists
+ * @param searchParams - URL search parameters for flow state
+ * @param updateSearchParams - Function to update URL search parameters
+ * @returns Object with current flow and submit function
+ * @example
+ * ```typescript
+ * import { useLoginFlow } from '@leancodepl/kratos';
+ *
+ * function LoginForm() {
+ *   const { flow, submit } = useLoginFlow({
+ *     kratosClient,
+ *     onLoggedIn: (session) => navigate('/dashboard'),
+ *     updateSearchParams: (params) => setSearchParams(params)
+ *   });
+ *
+ *   return <form onSubmit={submit}>...</form>;
+ * }
+ * ```
+ */
+export declare function useLoginFlow({ kratosClient, returnTo, onLoggedIn, onSessionAlreadyAvailable, searchParams, updateSearchParams, }: {
+    kratosClient: FrontendApi;
+    returnTo?: string;
+    onLoggedIn?: (session: Session) => void;
+    onSessionAlreadyAvailable?: () => void;
+    updateSearchParams: (searchParams: LoginSearchParams) => void;
+    searchParams?: LoginSearchParams;
+}): {
+    flow: LoginFlow | undefined;
+    submit: ({ body }: {
+        body: UpdateLoginFlowBody;
+    }) => void;
+};

package/src/lib/flows/useLogoutFlow.d.ts

@@ -0,0 +1,33 @@
+import { FrontendApi } from "@ory/client";
+/**
+ * Manages Kratos user logout flow with callback support.
+ *
+ * Provides a logout function that creates and executes logout flow,
+ * handling token invalidation and redirect logic.
+ *
+ * @param kratosClient - Configured Kratos FrontendApi client
+ * @param returnTo - Optional URL to redirect after logout
+ * @param onLoggedOut - Optional callback executed after successful logout
+ * @returns Object with logout function
+ * @example
+ * ```typescript
+ * import { useLogoutFlow } from '@leancodepl/kratos';
+ *
+ * function LogoutButton() {
+ *   const { logout } = useLogoutFlow({
+ *     kratosClient,
+ *     returnTo: '/login',
+ *     onLoggedOut: () => console.log('User logged out')
+ *   });
+ *
+ *   return <button onClick={logout}>Logout</button>;
+ * }
+ * ```
+ */
+export declare function useLogoutFlow({ kratosClient, returnTo, onLoggedOut, }: {
+    kratosClient: FrontendApi;
+    returnTo?: string;
+    onLoggedOut?: () => void;
+}): {
+    logout: () => Promise<void>;
+};

package/src/lib/flows/useReauthenticationFlow.d.ts

@@ -0,0 +1,31 @@
+import { FrontendApi, LoginFlow, Session, UpdateLoginFlowBody } from "@ory/client";
+/**
+ * Manages Kratos reauthentication flow for elevated security operations.
+ *
+ * Handles reauthentication flow creation and submission for operations requiring
+ * fresh authentication, such as changing passwords or accessing sensitive data.
+ *
+ * @param kratosClient - Configured Kratos FrontendApi client
+ * @param onReauthenticated - Callback executed with session after successful reauthentication
+ * @returns Object with current flow and submit function
+ * @example
+ * ```typescript
+ * import { useReauthenticationFlow } from '@leancodepl/kratos';
+ *
+ * function ReauthForm() {
+ *   const { flow, submit } = useReauthenticationFlow({
+ *     kratosClient,
+ *     onReauthenticated: (session) => navigate('/secure-area')
+ *   });
+ *
+ *   return <form onSubmit={submit}>...</form>;
+ * }
+ * ```
+ */
+export declare function useReauthenticationFlow({ kratosClient, onReauthenticated, }: {
+    kratosClient: FrontendApi;
+    onReauthenticated: (session: Session) => void;
+}): {
+    flow: LoginFlow | undefined;
+    submit: (values: UpdateLoginFlowBody) => Promise<unknown> | undefined;
+};

package/src/lib/flows/useRecoveryFlow.d.ts

@@ -0,0 +1,47 @@
+import { ContinueWith, FrontendApi, RecoveryFlow, UpdateRecoveryFlowBody } from "@ory/client";
+import { flowIdParameterName, returnToParameterName } from "../utils/variables";
+type RecoveryFlowSearchParams = {
+    [flowIdParameterName]?: string;
+    [returnToParameterName]?: string;
+};
+/**
+ * Manages Kratos account recovery flow state and form submission.
+ *
+ * Handles recovery flow creation, retrieval, and submission with automatic error handling,
+ * URL parameter management, and continue-with callbacks for post-recovery actions.
+ *
+ * @param kratosClient - Configured Kratos FrontendApi client
+ * @param onSessionAlreadyAvailable - Callback when session already exists
+ * @param onContinueWith - Optional callback for post-recovery actions
+ * @param searchParams - URL search parameters for flow state
+ * @param updateSearchParams - Function to update URL search parameters
+ * @returns Object with current flow, submit function, and recovery status
+ * @example
+ * ```typescript
+ * import { useRecoveryFlow } from '@leancodepl/kratos';
+ *
+ * function RecoveryForm() {
+ *   const { flow, submit, isRecovering } = useRecoveryFlow({
+ *     kratosClient,
+ *     onSessionAlreadyAvailable: () => navigate('/dashboard'),
+ *     updateSearchParams: (params) => setSearchParams(params)
+ *   });
+ *
+ *   return <form onSubmit={submit}>...</form>;
+ * }
+ * ```
+ */
+export declare function useRecoveryFlow({ kratosClient, onSessionAlreadyAvailable, onContinueWith, searchParams, updateSearchParams, }: {
+    kratosClient: FrontendApi;
+    onSessionAlreadyAvailable: () => void;
+    onContinueWith?: (continueWith: ContinueWith[]) => void;
+    searchParams?: RecoveryFlowSearchParams;
+    updateSearchParams: (searchParams: RecoveryFlowSearchParams) => void;
+}): {
+    flow: RecoveryFlow | undefined;
+    submit: ({ body }: {
+        body: UpdateRecoveryFlowBody;
+    }) => Promise<unknown> | undefined;
+    isRecovering: boolean;
+};
+export {};

package/src/lib/flows/useRegistrationFlow.d.ts

@@ -0,0 +1,47 @@
+import { ContinueWith, FrontendApi, RegistrationFlow, UpdateRegistrationFlowBody } from "@ory/client";
+import { flowIdParameterName, returnToParameterName } from "../utils/variables";
+type RegistrationFlowSearchParams = {
+    [flowIdParameterName]?: string;
+    [returnToParameterName]?: string;
+};
+/**
+ * Manages Kratos registration flow state and form submission.
+ *
+ * Handles registration flow creation, retrieval, and submission with automatic error handling,
+ * URL parameter management, and continue-with callbacks for post-registration actions.
+ *
+ * @param kratosClient - Configured Kratos FrontendApi client
+ * @param onSessionAlreadyAvailable - Callback when session already exists
+ * @param onContinueWith - Optional callback for post-registration actions
+ * @param searchParams - URL search parameters for flow state
+ * @param updateSearchParams - Function to update URL search parameters
+ * @returns Object with current flow, submit function, and registration status
+ * @example
+ * ```typescript
+ * import { useRegisterFlow } from '@leancodepl/kratos';
+ *
+ * function RegisterForm() {
+ *   const { flow, submit, isRegistered } = useRegisterFlow({
+ *     kratosClient,
+ *     onSessionAlreadyAvailable: () => navigate('/dashboard'),
+ *     updateSearchParams: (params) => setSearchParams(params)
+ *   });
+ *
+ *   return <form onSubmit={submit}>...</form>;
+ * }
+ * ```
+ */
+export declare function useRegisterFlow({ kratosClient, onSessionAlreadyAvailable, onContinueWith, searchParams, updateSearchParams, }: {
+    kratosClient: FrontendApi;
+    onSessionAlreadyAvailable: () => void;
+    onContinueWith?: (continueWith: ContinueWith[]) => void;
+    searchParams?: RegistrationFlowSearchParams;
+    updateSearchParams: (searchParams: RegistrationFlowSearchParams) => void;
+}): {
+    flow: RegistrationFlow | undefined;
+    submit: ({ body }: {
+        body: UpdateRegistrationFlowBody;
+    }) => Promise<unknown> | undefined;
+    isRegistered: boolean;
+};
+export {};

package/src/lib/flows/useSettingsFlow.d.ts

@@ -0,0 +1,47 @@
+import { ContinueWith, FrontendApi, SettingsFlow, UpdateSettingsFlowBody } from "@ory/client";
+import { AxiosRequestConfig } from "axios";
+import { flowIdParameterName, returnToParameterName } from "../utils/variables";
+type SettingsFlowSearchParams = {
+    [flowIdParameterName]?: string;
+    [returnToParameterName]?: string;
+};
+/**
+ * Manages Kratos user settings flow state and form submission.
+ *
+ * Handles settings flow creation, retrieval, and submission for profile updates,
+ * password changes, and security settings management.
+ *
+ * @param kratosClient - Configured Kratos FrontendApi client
+ * @param params - Optional Axios request parameters
+ * @param onContinueWith - Optional callback for post-settings actions
+ * @param searchParams - URL search parameters for flow state
+ * @param updateSearchParams - Function to update URL search parameters
+ * @returns Object with current flow and submit function
+ * @example
+ * ```typescript
+ * import { useSettingsFlow } from '@leancodepl/kratos';
+ *
+ * function UserSettingsForm() {
+ *   const { flow, submit } = useSettingsFlow({
+ *     kratosClient,
+ *     onContinueWith: (actions) => console.log('Settings updated'),
+ *     updateSearchParams: (params) => setSearchParams(params)
+ *   });
+ *
+ *   return <form onSubmit={submit}>...</form>;
+ * }
+ * ```
+ */
+export declare function useSettingsFlow({ kratosClient, params, onContinueWith, searchParams, updateSearchParams, }: {
+    kratosClient: FrontendApi;
+    params?: AxiosRequestConfig["params"];
+    onContinueWith?: (continueWith: ContinueWith[]) => void;
+    searchParams?: SettingsFlowSearchParams;
+    updateSearchParams: (searchParams: SettingsFlowSearchParams) => void;
+}): {
+    flow: SettingsFlow | undefined;
+    submit: ({ body }: {
+        body: UpdateSettingsFlowBody;
+    }) => Promise<unknown> | undefined;
+};
+export {};

package/src/lib/flows/useVerificationFlow.d.ts

@@ -0,0 +1,47 @@
+import { FrontendApi, UpdateVerificationFlowBody, VerificationFlow } from "@ory/client";
+import { flowIdParameterName, returnToParameterName } from "../utils/variables";
+type RecoveryFlowSearchParams = {
+    [flowIdParameterName]?: string;
+    [returnToParameterName]?: string;
+};
+/**
+ * Manages Kratos email/phone verification flow state and form submission.
+ *
+ * Handles verification flow creation, retrieval, and submission with automatic error handling,
+ * URL parameter management, and verification status tracking.
+ *
+ * @param initialFlowId - Optional initial flow ID to start with
+ * @param kratosClient - Configured Kratos FrontendApi client
+ * @param onVerified - Callback executed when verification is successful
+ * @param searchParams - URL search parameters for flow state
+ * @param updateSearchParams - Function to update URL search parameters
+ * @returns Object with current flow, submit function, and reset function
+ * @example
+ * ```typescript
+ * import { useVerificationFlow } from '@leancodepl/kratos';
+ *
+ * function VerifyEmailForm() {
+ *   const { flow, submit, reset } = useVerificationFlow({
+ *     kratosClient,
+ *     onVerified: () => navigate('/dashboard'),
+ *     updateSearchParams: (params) => setSearchParams(params)
+ *   });
+ *
+ *   return <form onSubmit={submit}>...</form>;
+ * }
+ * ```
+ */
+export declare function useVerificationFlow({ initialFlowId, kratosClient, onVerified, searchParams, updateSearchParams, }: {
+    initialFlowId?: string;
+    kratosClient: FrontendApi;
+    onVerified: () => void;
+    searchParams?: RecoveryFlowSearchParams;
+    updateSearchParams: (searchParams: RecoveryFlowSearchParams) => void;
+}): {
+    flow: VerificationFlow | undefined;
+    submit: ({ body }: {
+        body: UpdateVerificationFlowBody;
+    }) => Promise<unknown> | undefined;
+    reset: () => void;
+};
+export {};

package/src/lib/helpers/errorMessages.d.ts

@@ -0,0 +1,7 @@
+import { UiNode, UiText } from "@ory/client";
+type NodeMessagesProps = {
+    nodes?: UiNode[];
+    uiMessages?: UiText[];
+};
+export declare function NodeMessages({ nodes, uiMessages }: NodeMessagesProps): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/src/lib/helpers/filterFlowNodes.d.ts

@@ -0,0 +1,7 @@
+import { FilterNodesByGroups } from "../utils/filterNodesByGroups";
+type FilterFlowNodesProps = {
+    filter: FilterNodesByGroups;
+    includeCSRF?: boolean;
+};
+export declare function FilterFlowNodes({ filter, includeCSRF, ...overrides }: FilterFlowNodesProps): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/src/lib/helpers/formattedMessage.d.ts

@@ -0,0 +1,4 @@
+import { UiText } from "@ory/client";
+export declare function FormattedMessage({ message }: {
+    message?: Omit<UiText, "type">;
+}): import("react/jsx-runtime").JSX.Element | null;

package/src/lib/helpers/getNodeLabel.d.ts

@@ -0,0 +1,2 @@
+import { UiNode, UiText } from "@ory/client";
+export declare const getNodeLabel: (node: UiNode) => UiText | undefined;

package/src/lib/helpers/node.d.ts

@@ -0,0 +1,7 @@
+import { UiNode } from "@ory/client";
+type NodeProps = {
+    node: UiNode;
+    className?: string;
+};
+export declare function Node({ node, className }: NodeProps): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/src/lib/helpers/useScriptNodes.d.ts

@@ -0,0 +1,5 @@
+import { UiNode } from "@ory/client";
+export declare function useScriptNodes({ nodes, excludeScripts }: {
+    nodes: UiNode[];
+    excludeScripts?: boolean;
+}): void;

package/src/lib/helpers/userAuthForm.d.ts

@@ -0,0 +1,31 @@
+import { ReactNode } from "react";
+import { LoginFlow, RecoveryFlow, RegistrationFlow, SettingsFlow, VerificationFlow } from "@ory/client";
+import { FilterNodesByGroups } from "../utils/filterNodesByGroups";
+export type SelfServiceFlow = LoginFlow | RecoveryFlow | RegistrationFlow | SettingsFlow | VerificationFlow;
+/**
+ * Additional props that can be passed to the UserAuthForm component
+ * @see UserAuthForm
+ *
+ * @param onSubmit - function that is called when the form is submitted. It automatically maps the form data to the request body and prevents native form submits.
+ */
+export type UserAuthFormAdditionalProps<TBody> = {
+    onSubmit?: ({ body, event }: {
+        body: TBody;
+        event?: React.FormEvent<HTMLFormElement>;
+    }) => void;
+};
+export type UserAuthFormProps<TBody> = Omit<React.FormHTMLAttributes<HTMLFormElement>, "onSubmit"> & UserAuthFormAdditionalProps<TBody> & {
+    flow: SelfServiceFlow;
+    children: ReactNode;
+    formFilterOverride?: FilterNodesByGroups;
+    submitOnEnter?: boolean;
+    className?: string;
+};
+/**
+ * UserAuthForm is a component that renders a form for a given Ory flow.
+ * It automatically adds the form action and method and adds csrf tokens to the form.
+ * When the `onSubmit` parameter is passed, it also automatically maps the form data to the request body and prevents native form submits.
+ * @see UserAuthFormProps
+ * @returns JSX.Element
+ */
+export declare function UserAuthForm<TBody>({ flow, children, submitOnEnter, onSubmit, formFilterOverride, ...props }: UserAuthFormProps<TBody>): import("react/jsx-runtime").JSX.Element;

package/src/lib/kratosContext.d.ts

@@ -0,0 +1,29 @@
+import type { KratosComponents } from "./types/components";
+import type { UseHandleFlowError } from "./types/useHandleFlowError";
+export type KratosContextData = {
+    components: KratosComponents | undefined;
+    useHandleFlowError: UseHandleFlowError;
+    excludeScripts: boolean;
+};
+export declare const kratosContext: import("react").Context<KratosContextData>;
+/**
+ * Access Kratos context data with components and error handling.
+ *
+ * Retrieves the current Kratos context including UI components, error handlers,
+ * and configuration. Throws error if components are not initialized.
+ *
+ * @returns Kratos context data with initialized components
+ * @throws Error when Kratos context components are not initialized
+ * @example
+ * ```typescript
+ * import { useKratosContext } from '@leancodepl/kratos';
+ *
+ * function LoginComponent() {
+ *   const { components, useHandleFlowError } = useKratosContext();
+ *   // Use components and error handling...
+ * }
+ * ```
+ */
+export declare function useKratosContext(): KratosContextData & {
+    components: KratosComponents;
+};