@coinbase/cdp-react 0.0.78 → 0.0.80

package/dist/components/VerifyMfa/VerifyMfaFlow.d.ts

@@ -0,0 +1,11 @@
+import { HTMLAttributes, ReactNode } from 'react';
+import { MfaMethod, VerifyMfaState } from './types';
+export interface VerifyMfaFlowProps extends Omit<HTMLAttributes<HTMLElement>, "children"> {
+    autoFocus?: boolean;
+    children?: (props: {
+        step: VerifyMfaState["step"];
+        method: MfaMethod;
+        Form: ReactNode;
+    }) => ReactNode;
+}
+export declare const VerifyMfaFlow: ({ autoFocus, children, className, ...props }: VerifyMfaFlowProps) => import("react/jsx-runtime").JSX.Element;

package/dist/components/VerifyMfa/VerifyMfaFlow.js

@@ -0,0 +1,19 @@
+import { jsx as r } from "react/jsx-runtime";
+import "react";
+import { m as h } from "../../chunks/index.Dp-lIxM1.js";
+import "@coinbase/cdp-hooks";
+import { useVerifyMfaContext as l } from "./VerifyMfaProvider.js";
+import '../../assets/VerifyMfaFlow.css';const u = {
+  "method-wrapper": "VerifyMfaFlow-module__method-wrapper___LEPzD"
+}, F = ({
+  autoFocus: s = !0,
+  children: t,
+  className: m = "",
+  ...p
+}) => {
+  const { state: n, onSuccess: a, onError: i } = l(), { method: o, step: c } = n, f = h[o].content;
+  return /* @__PURE__ */ r("div", { className: `${u["method-wrapper"]} ${m}`, ...p, children: /* @__PURE__ */ r(f, { autoFocus: s, step: c, onSuccess: a, onError: i, children: ({ step: d, Content: e }) => t ? t({ step: d, method: o, Form: e }) : e }) });
+};
+export {
+  F as VerifyMfaFlow
+};

package/dist/components/VerifyMfa/VerifyMfaFooter.d.ts

@@ -0,0 +1,2 @@
+import { HTMLAttributes } from 'react';
+export declare const VerifyMfaFooter: (props: HTMLAttributes<HTMLDivElement>) => import("react/jsx-runtime").JSX.Element;

package/dist/components/VerifyMfa/VerifyMfaFooter.js

@@ -0,0 +1,7 @@
+import { jsx as r } from "react/jsx-runtime";
+import "react";
+import { CoinbaseFooter as t } from "../ui/CoinbaseFooter/index.js";
+const f = (o) => /* @__PURE__ */ r(t, { ...o });
+export {
+  f as VerifyMfaFooter
+};

package/dist/components/VerifyMfa/VerifyMfaImage.d.ts

@@ -0,0 +1,6 @@
+import { ElementType, HTMLAttributes } from 'react';
+import { VerifyMfaMethodComponentProps } from './types';
+export interface VerifyMfaImageProps extends VerifyMfaMethodComponentProps, HTMLAttributes<HTMLElement> {
+    as?: ElementType;
+}
+export declare const VerifyMfaImage: ({ as: Component, children, className, method: methodFromProps, step: stepFromProps, ...props }: VerifyMfaImageProps) => import("react/jsx-runtime").JSX.Element;

package/dist/components/VerifyMfa/VerifyMfaImage.js

@@ -0,0 +1,21 @@
+import { jsx as o } from "react/jsx-runtime";
+import "react";
+import { m as c } from "../../chunks/index.Dp-lIxM1.js";
+import "@coinbase/cdp-hooks";
+import { useVerifyMfaContext as g } from "./VerifyMfaProvider.js";
+import '../../assets/VerifyMfaImage.css';const d = "VerifyMfaImage-module__image___xftcN", y = {
+  image: d
+}, u = ({
+  as: s = "div",
+  children: t,
+  className: a = "",
+  method: i,
+  step: r,
+  ...f
+}) => {
+  const { state: e } = g(), n = r || e.step, m = i || e.method, p = c[m].image;
+  return /* @__PURE__ */ o(s, { className: `${y.image} ${a}`, ...f, children: t || /* @__PURE__ */ o(p, { step: n, method: m }) });
+};
+export {
+  u as VerifyMfaImage
+};

package/dist/components/VerifyMfa/VerifyMfaProvider.d.ts

@@ -0,0 +1,15 @@
+import { Dispatch, ReactNode } from 'react';
+import { VerifyMfaAction, VerifyMfaState } from './types';
+export interface VerifyMfaContextValue {
+    onSuccess?: (mfaCode: string) => void;
+    onError?: (error: Error) => void;
+    state: VerifyMfaState;
+    dispatch: Dispatch<VerifyMfaAction>;
+}
+export declare const useVerifyMfaContext: () => VerifyMfaContextValue;
+export interface VerifyMfaProviderProps {
+    children: ReactNode;
+    onSuccess?: (mfaCode: string) => void;
+    onError?: (error: Error) => void;
+}
+export declare const VerifyMfaProvider: ({ children, onError, onSuccess }: VerifyMfaProviderProps) => import("react/jsx-runtime").JSX.Element;

package/dist/components/VerifyMfa/VerifyMfaProvider.js

@@ -0,0 +1,28 @@
+import { jsx as n } from "react/jsx-runtime";
+import { createContext as a, useContext as u, useMemo as c } from "react";
+import "@coinbase/cdp-hooks";
+import { useVerifyMfaReducer as m } from "./useVerifyMfaReducer.js";
+const d = {
+  method: "totp",
+  methods: ["totp"],
+  step: "verification",
+  mfaCode: "",
+  error: null,
+  isPending: !1,
+  isSuccess: !1
+}, s = a(null), y = () => {
+  const e = u(s);
+  if (!e)
+    throw new Error("useVerifyMfaContext must be used within a VerifyMfaProvider");
+  return e;
+}, C = ({ children: e, onError: t, onSuccess: o }) => {
+  const [r, i] = m({ ...d }), f = c(
+    () => ({ state: r, dispatch: i, onSuccess: o, onError: t }),
+    [r, i, o, t]
+  );
+  return /* @__PURE__ */ n(s.Provider, { value: f, children: e });
+};
+export {
+  C as VerifyMfaProvider,
+  y as useVerifyMfaContext
+};

package/dist/components/VerifyMfa/VerifyMfaTitle.d.ts

@@ -0,0 +1,6 @@
+import { ElementType, HTMLAttributes } from 'react';
+import { VerifyMfaMethodComponentProps } from './types';
+export interface VerifyMfaTitleProps extends VerifyMfaMethodComponentProps, HTMLAttributes<HTMLElement> {
+    as?: ElementType;
+}
+export declare const VerifyMfaTitle: ({ as: Component, children, className, method: methodFromProps, step: stepFromProps, ...props }: VerifyMfaTitleProps) => import("react/jsx-runtime").JSX.Element;

package/dist/components/VerifyMfa/VerifyMfaTitle.js

@@ -0,0 +1,21 @@
+import { jsx as s } from "react/jsx-runtime";
+import "react";
+import { m as d } from "../../chunks/index.Dp-lIxM1.js";
+import "@coinbase/cdp-hooks";
+import { useVerifyMfaContext as h } from "./VerifyMfaProvider.js";
+import '../../assets/VerifyMfaTitle.css';const c = "VerifyMfaTitle-module__heading___18nul", l = {
+  heading: c
+}, x = ({
+  as: i = "h2",
+  children: t,
+  className: m = "",
+  method: n,
+  step: r,
+  ...a
+}) => {
+  const { state: e } = h(), f = r || e.step, o = n || e.method, p = d[o].title;
+  return /* @__PURE__ */ s(i, { className: `${l.heading} ${m}`, ...a, children: t || /* @__PURE__ */ s(p, { step: f, method: o }) });
+};
+export {
+  x as VerifyMfaTitle
+};

package/dist/components/VerifyMfa/index.d.ts

@@ -0,0 +1,16 @@
+import { APIError } from '@coinbase/cdp-hooks';
+import { HTMLAttributes, ReactNode } from 'react';
+import { VerifyMfaAction, VerifyMfaState } from './types';
+import { VerifyMfaDescription, VerifyMfaDescriptionProps } from './VerifyMfaDescription';
+import { VerifyMfaFlow, VerifyMfaFlowProps } from './VerifyMfaFlow';
+import { VerifyMfaFooter } from './VerifyMfaFooter';
+import { VerifyMfaImage, VerifyMfaImageProps } from './VerifyMfaImage';
+import { useVerifyMfaContext, VerifyMfaContextValue } from './VerifyMfaProvider';
+import { VerifyMfaTitle, VerifyMfaTitleProps } from './VerifyMfaTitle';
+interface VerifyMfaProps extends Omit<HTMLAttributes<HTMLDivElement>, "children" | "onSubmit" | "onError"> {
+    children?: ReactNode | ((state: VerifyMfaState) => ReactNode);
+    onSuccess?: (mfaCode: string) => void;
+    onError?: (error: APIError | Error) => void;
+}
+declare const VerifyMfa: ({ onSuccess, onError, ...props }: VerifyMfaProps) => import("react/jsx-runtime").JSX.Element;
+export { VerifyMfa, VerifyMfaDescription, VerifyMfaFooter, VerifyMfaFlow, VerifyMfaImage, VerifyMfaTitle, useVerifyMfaContext, type VerifyMfaProps, type VerifyMfaDescriptionProps, type VerifyMfaFlowProps, type VerifyMfaImageProps, type VerifyMfaTitleProps, type VerifyMfaAction, type VerifyMfaState, type VerifyMfaContextValue, };

package/dist/components/VerifyMfa/index.js

@@ -0,0 +1,20 @@
+import "react/jsx-runtime";
+import "@coinbase/cdp-hooks";
+import "../../chunks/useSendComponentCallOnce.BHZMuo6E.js";
+import "react";
+import { V as m } from "../../chunks/CDPReactProvider.CIQm4C4z.js";
+import { VerifyMfaDescription as a } from "./VerifyMfaDescription.js";
+import { VerifyMfaFlow as V } from "./VerifyMfaFlow.js";
+import { VerifyMfaFooter as M } from "./VerifyMfaFooter.js";
+import { VerifyMfaImage as l } from "./VerifyMfaImage.js";
+import { useVerifyMfaContext as F } from "./VerifyMfaProvider.js";
+import { VerifyMfaTitle as g } from "./VerifyMfaTitle.js";
+export {
+  m as VerifyMfa,
+  a as VerifyMfaDescription,
+  V as VerifyMfaFlow,
+  M as VerifyMfaFooter,
+  l as VerifyMfaImage,
+  g as VerifyMfaTitle,
+  F as useVerifyMfaContext
+};

package/dist/components/VerifyMfa/methods/totp.d.ts

@@ -0,0 +1,6 @@
+import { MfaMethodConfig, MfaMethodContentProps, VerifyMfaMethodComponentProps } from '../types';
+export declare const TotpContent: ({ autoFocus, onError, onSuccess, children, }: MfaMethodContentProps) => import("react/jsx-runtime").JSX.Element;
+export declare const TotpTitle: (_props: VerifyMfaMethodComponentProps) => import("react/jsx-runtime").JSX.Element;
+export declare const TotpImage: (_props: VerifyMfaMethodComponentProps) => import("react/jsx-runtime").JSX.Element;
+export declare const TotpDescription: (_props: VerifyMfaMethodComponentProps) => import("react/jsx-runtime").JSX.Element;
+export declare const totpMethodConfig: MfaMethodConfig;

package/dist/components/VerifyMfa/methods/totp.js

@@ -0,0 +1,69 @@
+import { jsx as o, Fragment as a } from "react/jsx-runtime";
+import { useIsInitialized as g, useCurrentUser as _, useInitiateMfaVerification as E, useSubmitMfaVerification as S } from "@coinbase/cdp-hooks";
+import { useRef as I, useEffect as T } from "react";
+import { OTPForm as F } from "../../forms/OTPForm/index.js";
+import { Badge as A } from "../../ui/Badge/index.js";
+import { IconSmartPhone as U } from "../../../icons/IconSmartPhone.js";
+import { useVerifyMfaContext as V } from "../VerifyMfaProvider.js";
+const v = ({
+  autoFocus: r = !0,
+  onError: u,
+  onSuccess: C,
+  children: s
+}) => {
+  const { isInitialized: c } = g(), { currentUser: M } = _(), { state: e, dispatch: i } = V(), { initiateMfaVerification: f } = E(), p = I(!1), { submitMfaVerification: l } = S();
+  T(() => {
+    if (!c || p.current) return;
+    requestAnimationFrame(async () => {
+      p.current = !0;
+      try {
+        await f({ mfaMethod: "totp" });
+      } catch (t) {
+        console.error("Failed to initiate MFA verification", t);
+      }
+    });
+  }, [c, f, M]);
+  const h = (n) => {
+    i({ type: "SET_MFA_CODE", payload: { mfaCode: n } });
+  }, y = async (n) => {
+    n.preventDefault(), i({ type: "SUBMIT_MFA_CODE", payload: { mfaCode: e.mfaCode } });
+    try {
+      const t = e.mfaCode;
+      await l({ mfaMethod: "totp", mfaCode: t }), i({ type: "SUBMIT_MFA_CODE_SUCCESS" }), C?.(t);
+    } catch (t) {
+      const m = t instanceof Error ? t : new Error(typeof t == "string" ? t : "Verification failed");
+      u?.(m), i({
+        type: "SUBMIT_MFA_CODE_FAILURE",
+        payload: {
+          error: m.message
+        }
+      });
+    }
+  }, d = /* @__PURE__ */ o(
+    F,
+    {
+      autoFocus: r,
+      otp: e.mfaCode,
+      error: e.error || void 0,
+      isPending: e.isPending,
+      onOTPChange: h,
+      onSubmit: y,
+      passwordLength: 6,
+      resendCountdown: null,
+      successMessage: e.isSuccess ? "Verified!" : void 0
+    }
+  );
+  return s ? /* @__PURE__ */ o(a, { children: s({ step: e.step, Content: d }) }) : d;
+}, D = (r) => /* @__PURE__ */ o(a, { children: "Enter verification code" }), O = (r) => /* @__PURE__ */ o(A, { variant: "secondary", children: /* @__PURE__ */ o(U, {}) }), w = (r) => /* @__PURE__ */ o(a, { children: "Enter the 6-digit code from your authenticator app." }), j = {
+  content: v,
+  title: D,
+  description: w,
+  image: O
+};
+export {
+  v as TotpContent,
+  w as TotpDescription,
+  O as TotpImage,
+  D as TotpTitle,
+  j as totpMethodConfig
+};

package/dist/components/VerifyMfa/types.d.ts

@@ -0,0 +1,60 @@
+import { APIError } from '@coinbase/cdp-hooks';
+import { FC, ReactNode } from 'react';
+import { MfaMethod } from '../EnrollMfa/types';
+export { type MfaMethod };
+export interface VerifyMfaMethodComponentProps {
+    method?: MfaMethod;
+    step?: VerifyMfaState["step"];
+}
+export interface VerifyMfaState {
+    method: MfaMethod;
+    methods: MfaMethod[];
+    step: "verification";
+    mfaCode: string;
+    error: string | APIError | null;
+    isPending: boolean;
+    isSuccess: boolean;
+}
+export type VerifyMfaAction = {
+    type: "SET_METHOD";
+    payload: {
+        method: MfaMethod;
+    };
+} | {
+    type: "SET_MFA_CODE";
+    payload: {
+        mfaCode: string;
+    };
+} | {
+    type: "SUBMIT_MFA_CODE";
+    payload: {
+        mfaCode: string;
+    };
+} | {
+    type: "SUBMIT_MFA_CODE_SUCCESS";
+} | {
+    type: "SUBMIT_MFA_CODE_FAILURE";
+    payload: {
+        error: string | APIError;
+    };
+} | {
+    type: "CLEAR_ERROR";
+} | {
+    type: "RESET_STATE";
+};
+export interface MfaMethodContentProps {
+    step: VerifyMfaState["step"];
+    autoFocus?: boolean;
+    onError?: (error: Error) => void;
+    onSuccess?: (mfaCode: string) => void;
+    children?: (props: {
+        step: VerifyMfaState["step"];
+        Content: ReactNode;
+    }) => ReactNode;
+}
+export interface MfaMethodConfig {
+    content: FC<MfaMethodContentProps>;
+    description: FC<VerifyMfaMethodComponentProps>;
+    image: FC<VerifyMfaMethodComponentProps>;
+    title: FC<VerifyMfaMethodComponentProps>;
+}

package/dist/components/VerifyMfa/types.js

@@ -0,0 +1,2 @@
+import "@coinbase/cdp-hooks";
+import "react";

package/dist/components/VerifyMfa/useVerifyMfaReducer.d.ts

@@ -0,0 +1,2 @@
+import { VerifyMfaAction, VerifyMfaState } from './types';
+export declare const useVerifyMfaReducer: (initialState: VerifyMfaState) => [VerifyMfaState, import('react').ActionDispatch<[action: VerifyMfaAction]>];

package/dist/components/VerifyMfa/useVerifyMfaReducer.js

@@ -0,0 +1,61 @@
+import { useReducer as o } from "react";
+import "@coinbase/cdp-hooks";
+function n(e, r) {
+  switch (r.type) {
+    case "SET_METHOD":
+      return {
+        ...e,
+        method: r.payload.method,
+        mfaCode: "",
+        error: null
+      };
+    case "SET_MFA_CODE":
+      return {
+        ...e,
+        mfaCode: r.payload.mfaCode,
+        error: null
+      };
+    case "SUBMIT_MFA_CODE":
+      return {
+        ...e,
+        isPending: !0,
+        mfaCode: r.payload.mfaCode,
+        error: null
+      };
+    case "SUBMIT_MFA_CODE_SUCCESS":
+      return {
+        ...e,
+        isPending: !1,
+        isSuccess: !0,
+        error: null
+      };
+    case "SUBMIT_MFA_CODE_FAILURE":
+      return {
+        ...e,
+        isPending: !1,
+        isSuccess: !1,
+        error: r.payload.error
+      };
+    case "CLEAR_ERROR":
+      return {
+        ...e,
+        error: null
+      };
+    case "RESET_STATE":
+      return {
+        method: e.method,
+        methods: e.methods,
+        step: "verification",
+        mfaCode: "",
+        error: null,
+        isPending: !1,
+        isSuccess: !1
+      };
+    default:
+      throw new Error("Unknown action type");
+  }
+}
+const d = (e) => o(n, e);
+export {
+  d as useVerifyMfaReducer
+};

package/dist/components/VerifyMfaInline/index.d.ts

@@ -0,0 +1,40 @@
+import { ButtonHTMLAttributes, HTMLAttributes, ReactNode } from 'react';
+import { ButtonSize, ButtonVariant } from '../../theme/theme';
+type VerifyMfaInlineView = "verify" | "content";
+type VerifyMfaInlineDirection = "left" | "right";
+interface VerifyMfaInlineContextValue {
+    view: VerifyMfaInlineView;
+    goToVerify: () => void;
+    goToContent: (direction?: VerifyMfaInlineDirection) => void;
+    goBack: () => void;
+}
+declare const useVerifyMfaInlineContext: () => VerifyMfaInlineContextValue;
+interface VerifyMfaInlineProps extends HTMLAttributes<HTMLDivElement> {
+    children: ReactNode;
+    verifyFirst?: boolean;
+    onVerified?: () => void;
+    onCancel?: () => void;
+    successDelay?: number;
+    className?: string;
+}
+interface VerifyMfaInlineFlowProps {
+    children: ReactNode | ((props: {
+        view: "verify";
+        Content: ReactNode;
+    } | {
+        view: "content";
+        Content: null;
+    }) => ReactNode);
+    className?: string;
+    animateHeight?: boolean;
+    autoFocus?: boolean;
+    transition?: "slide" | "fade";
+}
+interface VerifyMfaInlineBackButtonProps extends ButtonHTMLAttributes<HTMLButtonElement> {
+    size?: ButtonSize;
+    variant?: ButtonVariant;
+}
+declare const VerifyMfaInlineBackButton: ({ children, onClick, size, variant, ["aria-label"]: ariaLabel, ...props }: VerifyMfaInlineBackButtonProps) => import("react/jsx-runtime").JSX.Element | null;
+declare const VerifyMfaInlineFlow: ({ children, className, animateHeight, autoFocus, transition, }: VerifyMfaInlineFlowProps) => import("react/jsx-runtime").JSX.Element;
+declare const VerifyMfaInline: ({ children, verifyFirst, onVerified, onCancel, successDelay, className, ...props }: VerifyMfaInlineProps) => import("react/jsx-runtime").JSX.Element;
+export { VerifyMfaInline, VerifyMfaInlineBackButton, VerifyMfaInlineFlow, useVerifyMfaInlineContext, type VerifyMfaInlineBackButtonProps, type VerifyMfaInlineContextValue, type VerifyMfaInlineDirection, type VerifyMfaInlineFlowProps, type VerifyMfaInlineProps, type VerifyMfaInlineView, };

package/dist/components/VerifyMfaInline/index.js

@@ -0,0 +1,175 @@
+import { jsx as n, jsxs as R } from "react/jsx-runtime";
+import { isMfaRequired as E } from "@coinbase/cdp-core";
+import { useCancelMfaVerification as j, useIsInitialized as q, useRegisterMfaListener as F } from "@coinbase/cdp-hooks";
+import { u as L } from "../../chunks/useSendComponentCallOnce.BHZMuo6E.js";
+import { createContext as A, useMemo as h, useRef as x, useState as b, useCallback as w, useContext as O } from "react";
+import { c as P } from "../../chunks/lite.1fxw3LjI.js";
+import { Button as W } from "../ui/Button/index.js";
+import { SwitchFadeTransition as X } from "../ui/SwitchFadeTransition/index.js";
+import { SwitchSlideTransition as Y } from "../ui/SwitchSlideTransition/index.js";
+import { V as G } from "../../chunks/CDPReactProvider.CIQm4C4z.js";
+import { IconArrowLeft as J } from "../../icons/IconArrowLeft.js";
+import "../../theme/theme.js";
+import { VerifyMfaImage as Q } from "../VerifyMfa/VerifyMfaImage.js";
+import { VerifyMfaTitle as U } from "../VerifyMfa/VerifyMfaTitle.js";
+import { VerifyMfaDescription as Z } from "../VerifyMfa/VerifyMfaDescription.js";
+import { VerifyMfaFlow as $ } from "../VerifyMfa/VerifyMfaFlow.js";
+import '../../assets/VerifyMfaInline.css';const H = "VerifyMfaInline-module__icon___pezMX", C = {
+  "verify-mfa-inline": "VerifyMfaInline-module__verify-mfa-inline___mn38o",
+  icon: H,
+  "mfa-verification": "VerifyMfaInline-module__mfa-verification___WyY76",
+  "mfa-verification-content": "VerifyMfaInline-module__mfa-verification-content___M4fq0",
+  "mfa-verification-form": "VerifyMfaInline-module__mfa-verification-form___8h2u-"
+}, z = A(null), S = () => {
+  const e = O(z);
+  if (!e)
+    throw new Error("VerifyMfaInline compound components must be used within VerifyMfaInline");
+  return e;
+}, ve = () => {
+  const { view: e, goToContent: t, goToVerify: i, goBack: o } = S();
+  return h(
+    () => ({ view: e, goToVerify: i, goToContent: t, goBack: o }),
+    [e, i, t, o]
+  );
+}, Ve = ({
+  children: e,
+  onClick: t,
+  size: i = "md",
+  variant: o = "transparentSecondary",
+  ["aria-label"]: d = "Back",
+  ...s
+}) => {
+  const { goBack: M, verifyFirst: y, needsMfa: l, view: r } = S(), m = (f) => {
+    t?.(f), M();
+  };
+  return y || !l || r === "content" ? null : /* @__PURE__ */ n(
+    W,
+    {
+      type: "button",
+      "aria-label": d,
+      onClick: m,
+      size: i,
+      variant: o,
+      ...s,
+      children: e || /* @__PURE__ */ n(J, { className: C.icon })
+    }
+  );
+}, N = ({ onSuccess: e }) => /* @__PURE__ */ n(G, { className: C["mfa-verification"], onSuccess: e, children: /* @__PURE__ */ R("div", { className: C["mfa-verification-content"], children: [
+  /* @__PURE__ */ n(Q, {}),
+  /* @__PURE__ */ R("div", { children: [
+    /* @__PURE__ */ n(U, {}),
+    /* @__PURE__ */ n(Z, {})
+  ] }),
+  /* @__PURE__ */ n($, { className: C["mfa-verification-form"] })
+] }) }), Me = ({
+  children: e,
+  className: t = "",
+  animateHeight: i = !0,
+  autoFocus: o = !0,
+  transition: d = "slide"
+}) => {
+  const {
+    goToContent: s,
+    initialView: M,
+    direction: y,
+    transitionRef: l,
+    verifyFirst: r,
+    onVerified: m,
+    successDelay: f
+  } = S(), _ = w(() => {
+    m?.(), r && (f > 0 ? setTimeout(() => s(), f) : s());
+  }, [s, r, m, f]), v = M === "verify" ? ["verify", "content"] : ["content", "verify"], I = typeof e == "function", V = ({ itemKey: u, ...p }) => {
+    let c = null;
+    return I ? c = e(
+      u === "content" ? { view: "content", Content: null } : { view: u, Content: u === "verify" ? /* @__PURE__ */ n(N, { onSuccess: _ }) : void 0 }
+    ) : c = u === "verify" ? /* @__PURE__ */ n(N, { onSuccess: _ }) : e, /* @__PURE__ */ n("div", { ...p, children: c });
+  };
+  return d === "fade" ? /* @__PURE__ */ n(
+    X,
+    {
+      autoFocus: o,
+      animateHeight: i,
+      items: v,
+      initialEntered: !0,
+      transitionRef: l,
+      className: t,
+      children: V
+    }
+  ) : /* @__PURE__ */ n(
+    Y,
+    {
+      autoFocus: o,
+      animateHeight: i,
+      items: v,
+      initialEntered: !0,
+      direction: y,
+      transitionRef: l,
+      className: t,
+      children: V
+    }
+  );
+}, _e = ({
+  children: e,
+  verifyFirst: t = !0,
+  onVerified: i,
+  onCancel: o,
+  successDelay: d = 500,
+  className: s = "",
+  ...M
+}) => {
+  L("verify_mfa_inline");
+  const { cancelMfaVerification: y } = j(), { isInitialized: l } = q(), r = h(() => l ? E() : !1, [l]), m = x(null), f = h(() => r && t ? "verify" : "content", [r, t]), [_, v] = b(f), [I, V] = b("left"), u = x(null), p = x(f), c = w((a) => {
+    p.current !== a && (p.current = a, u.current?.transition.toggle(a));
+  }, []), g = w(
+    (a = "left") => {
+      V(a), v("verify"), c("verify");
+    },
+    [c]
+  ), T = w(
+    (a = "left") => {
+      V(a), v("content"), c("content");
+    },
+    [c]
+  ), k = w(() => {
+    const a = p.current === "verify", B = a ? "content" : "verify";
+    V("right"), v(B), c(B), a && (y(), o?.());
+  }, [c, o, y]);
+  F(() => g(), {
+    scope: m,
+    enabled: r
+  });
+  const D = h(
+    () => ({
+      view: _,
+      goToVerify: g,
+      goToContent: T,
+      goBack: k,
+      needsMfa: r,
+      verifyFirst: t,
+      initialView: f,
+      direction: I,
+      transitionRef: u,
+      onVerified: i,
+      successDelay: d
+    }),
+    [
+      _,
+      g,
+      T,
+      k,
+      r,
+      t,
+      f,
+      I,
+      i,
+      d
+    ]
+  );
+  return /* @__PURE__ */ n(z.Provider, { value: D, children: /* @__PURE__ */ n("div", { ref: m, className: P(C["verify-mfa-inline"], s), ...M, children: e }) });
+};
+export {
+  _e as VerifyMfaInline,
+  Ve as VerifyMfaInlineBackButton,
+  Me as VerifyMfaInlineFlow,
+  ve as useVerifyMfaInlineContext
+};

package/dist/components/VerifyMfaModal/index.d.ts

@@ -0,0 +1,23 @@
+import { ReactNode } from 'react';
+import { ButtonProps } from '../ui/Button';
+import { ModalContentProps } from '../ui/Modal';
+import { VerifyMfaProps } from '../VerifyMfa';
+interface VerifyMfaModalTriggerProps extends Partial<Pick<ButtonProps, "className" | "fullWidth" | "size" | "style" | "variant">> {
+    children?: ReactNode;
+    label?: ReactNode;
+}
+interface VerifyMfaModalProps {
+    children?: ReactNode;
+    open?: boolean;
+    setIsOpen?: (value: boolean) => void;
+    onCancel?: () => void;
+    onError?: (error: Error) => void;
+    onSuccess?: (mfaCode: string) => void;
+}
+interface VerifyMfaModalContentProps extends Omit<ModalContentProps, "children"> {
+    children?: VerifyMfaProps["children"];
+}
+declare const VerifyMfaModalTrigger: ({ children, className, label, ...props }: VerifyMfaModalTriggerProps) => import("react/jsx-runtime").JSX.Element;
+declare const VerifyMfaModalContent: ({ children, ...props }: VerifyMfaModalContentProps) => import("react/jsx-runtime").JSX.Element;
+declare const VerifyMfaModal: ({ children, open, setIsOpen, onCancel, onError, onSuccess, }: VerifyMfaModalProps) => import("react/jsx-runtime").JSX.Element;
+export { VerifyMfaModal, VerifyMfaModalContent, VerifyMfaModalTrigger, type VerifyMfaModalProps, type VerifyMfaModalContentProps, type VerifyMfaModalTriggerProps, };

package/dist/components/VerifyMfaModal/index.js

@@ -0,0 +1,19 @@
+import "react/jsx-runtime";
+import "../../chunks/useSendComponentCallOnce.BHZMuo6E.js";
+import "react";
+import "../../chunks/lite.1fxw3LjI.js";
+import { d as g, e as n, f as x } from "../../chunks/CDPReactProvider.CIQm4C4z.js";
+import "../ui/Button/index.js";
+import "../ui/Modal/index.js";
+import "../../icons/IconXMark.js";
+import "../../utils/childrenHasComponent.js";
+import "../VerifyMfa/VerifyMfaImage.js";
+import "../VerifyMfa/VerifyMfaTitle.js";
+import "../VerifyMfa/VerifyMfaDescription.js";
+import "../VerifyMfa/VerifyMfaFlow.js";
+import "../VerifyMfa/VerifyMfaFooter.js";
+export {
+  g as VerifyMfaModal,
+  n as VerifyMfaModalContent,
+  x as VerifyMfaModalTrigger
+};

package/dist/components/forms/AmountInput/index.d.ts

@@ -1,3 +1,3 @@
 import { InputHTMLAttributes } from 'react';
 import { AmountInputProps } from './types';
-export declare const AmountInput: import('react').ForwardRefExoticComponent<AmountInputProps & Omit<InputHTMLAttributes<HTMLInputElement>, "type" | "value" | "max" | "min" | "onChange" | "inputMode"> & import('react').RefAttributes<HTMLInputElement>>;
+export declare const AmountInput: import('react').ForwardRefExoticComponent<AmountInputProps & Omit<InputHTMLAttributes<HTMLInputElement>, "type" | "value" | "inputMode" | "onChange" | "max" | "min"> & import('react').RefAttributes<HTMLInputElement>>;