@joelbarron/react-web-dev-kit 0.1.9 → 0.1.10

package/dist/auth/forms/password/AuthForgotPasswordForm.js

@@ -0,0 +1,109 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { zodResolver } from '@hookform/resolvers/zod';
+import LinkOutlinedIcon from '@mui/icons-material/LinkOutlined';
+import Alert from '@mui/material/Alert';
+import _ from 'lodash';
+import { useEffect, useState } from 'react';
+import { useForm } from 'react-hook-form';
+import { z } from 'zod';
+import { JBTextField } from '../../../forms';
+import { AuthPrimaryButton } from '../../ui';
+import { parseAuthError } from '../errorParser';
+function getEmailSentFlag(response) {
+    if (!response || typeof response !== 'object') {
+        return undefined;
+    }
+    const data = response;
+    const emailSent = data.emailSent ?? data.email_sent;
+    return typeof emailSent === 'boolean' ? emailSent : undefined;
+}
+const forgotSchema = z.object({
+    email: z.string().email('Debes ingresar un correo válido').nonempty('Debes ingresar un correo')
+});
+export function AuthForgotPasswordForm(props) {
+    const { defaultValues, loading = false, submitLabel = 'Enviar enlace de recuperación', resendLabel = 'Reenviar enlace de recuperación', successMessage = 'Si la cuenta existe, enviamos un enlace de recuperación a tu correo.', notSentMessage = 'Solicitud recibida, pero no se pudo enviar el correo de recuperación.', resendCooldownSeconds = 30, onEmailSentSuccess, onSubmit } = props;
+    const [success, setSuccess] = useState(null);
+    const [successSeverity, setSuccessSeverity] = useState('success');
+    const [isEmailSentSuccessfully, setIsEmailSentSuccessfully] = useState(false);
+    const [resendSecondsLeft, setResendSecondsLeft] = useState(0);
+    const { control, formState, handleSubmit, setError, clearErrors, watch } = useForm({
+        mode: 'onChange',
+        defaultValues: {
+            email: defaultValues?.email ?? ''
+        },
+        resolver: zodResolver(forgotSchema)
+    });
+    const { errors, dirtyFields, isSubmitting, isValid } = formState;
+    const emailValue = watch('email');
+    const isResendCooldownActive = isEmailSentSuccessfully && resendSecondsLeft > 0;
+    useEffect(() => {
+        if (!isResendCooldownActive) {
+            return;
+        }
+        const timer = window.setInterval(() => {
+            setResendSecondsLeft((current) => {
+                if (current <= 1) {
+                    window.clearInterval(timer);
+                    return 0;
+                }
+                return current - 1;
+            });
+        }, 1000);
+        return () => {
+            window.clearInterval(timer);
+        };
+    }, [isResendCooldownActive]);
+    useEffect(() => {
+        const subscription = watch((_value, { name }) => {
+            if (name) {
+                clearErrors(name);
+            }
+            clearErrors('root');
+        });
+        return () => {
+            subscription.unsubscribe();
+        };
+    }, [watch, clearErrors]);
+    async function onSubmitForm(values) {
+        try {
+            setSuccess(null);
+            const response = await onSubmit(values);
+            const emailSent = getEmailSentFlag(response);
+            setSuccessSeverity(emailSent === false ? 'warning' : 'success');
+            setSuccess(emailSent === false ? notSentMessage : successMessage);
+            setIsEmailSentSuccessfully(emailSent === true);
+            if (emailSent === true) {
+                setResendSecondsLeft(resendCooldownSeconds);
+                onEmailSentSuccess?.();
+            }
+        }
+        catch (error) {
+            const parsed = parseAuthError(error);
+            Object.entries(parsed.fieldErrors).forEach(([field, message]) => {
+                if (field === 'email') {
+                    setError('email', {
+                        type: 'manual',
+                        message
+                    });
+                    return;
+                }
+                setError('root', {
+                    type: 'manual',
+                    message
+                });
+            });
+            if (parsed.rootMessage) {
+                setError('root', {
+                    type: 'manual',
+                    message: parsed.rootMessage
+                });
+                return;
+            }
+            setError('root', {
+                type: 'manual',
+                message: 'No se pudo enviar el correo de recuperación. Inténtalo de nuevo.'
+            });
+        }
+    }
+    return (_jsxs("form", { name: "forgotPasswordForm", noValidate: true, style: { display: 'flex', width: '100%', flexDirection: 'column', justifyContent: 'center', paddingTop: 4 }, onSubmit: handleSubmit(onSubmitForm), children: [!isEmailSentSuccessfully ? (_jsx(JBTextField, { control: control, name: "email", sx: { mb: 3 }, label: "Correo electr\u00F3nico", autoFocus: true, type: "email", variant: "outlined", required: true, fullWidth: true })) : null, errors.root?.message && (_jsx(Alert, { sx: { mb: 2 }, severity: "error", children: errors.root.message })), success && (_jsx(Alert, { sx: { mb: 2 }, severity: successSeverity, children: success })), !isEmailSentSuccessfully ? (_jsx(AuthPrimaryButton, { "aria-label": submitLabel, type: "submit", startIcon: _jsx(LinkOutlinedIcon, { fontSize: "small" }), disabled: loading || isSubmitting || _.isEmpty(dirtyFields) || !isValid, children: submitLabel })) : (_jsx(AuthPrimaryButton, { "aria-label": resendLabel, type: "submit", startIcon: _jsx(LinkOutlinedIcon, { fontSize: "small" }), disabled: loading || isSubmitting || isResendCooldownActive || !isValid || !emailValue?.trim(), children: isResendCooldownActive ? `${resendLabel} (${resendSecondsLeft}s)` : resendLabel }))] }));
+}

package/dist/auth/forms/password/AuthPasswordResetConfirmForm.d.ts

@@ -0,0 +1,17 @@
+export type AuthPasswordResetConfirmFormValues = {
+    uid: string;
+    token: string;
+    newPassword: string;
+    newPasswordConfirm: string;
+};
+export type AuthPasswordResetConfirmFormProps = {
+    defaultValues?: Partial<AuthPasswordResetConfirmFormValues>;
+    loading?: boolean;
+    submitLabel?: string;
+    successMessage?: string;
+    successRedirectSeconds?: number;
+    onGoToSignIn?: () => void;
+    onSubmit: (values: AuthPasswordResetConfirmFormValues) => unknown | Promise<unknown>;
+};
+export declare function AuthPasswordResetConfirmForm(props: AuthPasswordResetConfirmFormProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=AuthPasswordResetConfirmForm.d.ts.map

package/dist/auth/forms/password/AuthPasswordResetConfirmForm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AuthPasswordResetConfirmForm.d.ts","sourceRoot":"","sources":["../../../../src/auth/forms/password/AuthPasswordResetConfirmForm.tsx"],"names":[],"mappings":"AAkBA,MAAM,MAAM,kCAAkC,GAAG;IAC/C,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,kBAAkB,EAAE,MAAM,CAAC;CAC5B,CAAC;AAEF,MAAM,MAAM,iCAAiC,GAAG;IAC9C,aAAa,CAAC,EAAE,OAAO,CAAC,kCAAkC,CAAC,CAAC;IAC5D,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAChC,YAAY,CAAC,EAAE,MAAM,IAAI,CAAC;IAC1B,QAAQ,EAAE,CAAC,MAAM,EAAE,kCAAkC,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CACtF,CAAC;AA8BF,wBAAgB,4BAA4B,CAAC,KAAK,EAAE,iCAAiC,2CA6OpF"}

package/dist/auth/forms/password/AuthPasswordResetConfirmForm.js

@@ -0,0 +1,163 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { zodResolver } from '@hookform/resolvers/zod';
+import ArrowBackOutlinedIcon from '@mui/icons-material/ArrowBackOutlined';
+import LockResetOutlinedIcon from '@mui/icons-material/LockResetOutlined';
+import VisibilityOffOutlinedIcon from '@mui/icons-material/VisibilityOffOutlined';
+import VisibilityOutlinedIcon from '@mui/icons-material/VisibilityOutlined';
+import Alert from '@mui/material/Alert';
+import IconButton from '@mui/material/IconButton';
+import InputAdornment from '@mui/material/InputAdornment';
+import _ from 'lodash';
+import { useEffect, useMemo, useState } from 'react';
+import { useForm } from 'react-hook-form';
+import { z } from 'zod';
+import { JBTextField } from '../../../forms';
+import { AuthPrimaryButton, AuthSecondaryButton } from '../../ui';
+import { parseAuthError } from '../errorParser';
+import { getDjangoLikePasswordError } from './passwordValidation';
+const resetSchema = z
+    .object({
+    uid: z.string().nonempty('El uid es obligatorio'),
+    token: z.string().nonempty('El token es obligatorio'),
+    newPassword: z.string().superRefine((value, ctx) => {
+        if (!value) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: 'Debes ingresar tu nueva contraseña'
+            });
+            return;
+        }
+        const passwordError = getDjangoLikePasswordError(value);
+        if (passwordError) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: passwordError
+            });
+        }
+    }),
+    newPasswordConfirm: z.string().nonempty('La confirmación de contraseña es obligatoria')
+})
+    .refine((data) => data.newPassword === data.newPasswordConfirm, {
+    message: 'Las contraseñas deben coincidir',
+    path: ['newPasswordConfirm']
+});
+export function AuthPasswordResetConfirmForm(props) {
+    const { defaultValues, loading = false, submitLabel = 'Restablecer contraseña', successMessage = 'Contraseña restablecida correctamente. Ya puedes iniciar sesión.', successRedirectSeconds = 5, onGoToSignIn, onSubmit } = props;
+    const [redirectSecondsLeft, setRedirectSecondsLeft] = useState(null);
+    const [showNewPassword, setShowNewPassword] = useState(false);
+    const [showNewPasswordConfirm, setShowNewPasswordConfirm] = useState(false);
+    const { control, formState, handleSubmit, setError, clearErrors, watch } = useForm({
+        mode: 'onChange',
+        defaultValues: {
+            uid: defaultValues?.uid ?? '',
+            token: defaultValues?.token ?? '',
+            newPassword: defaultValues?.newPassword ?? '',
+            newPasswordConfirm: defaultValues?.newPasswordConfirm ?? ''
+        },
+        resolver: zodResolver(resetSchema)
+    });
+    const { errors, dirtyFields, isSubmitting, isValid, isSubmitSuccessful } = formState;
+    const uidValue = watch('uid');
+    const tokenValue = watch('token');
+    const hasValidRecoveryLink = Boolean(uidValue?.trim() && tokenValue?.trim());
+    const goToSignInLabel = useMemo(() => {
+        if (!isSubmitSuccessful) {
+            return 'Ir a iniciar sesión';
+        }
+        if (!redirectSecondsLeft || redirectSecondsLeft <= 0) {
+            return 'Ir a iniciar sesión';
+        }
+        return `Ir a iniciar sesión (${redirectSecondsLeft}s)`;
+    }, [isSubmitSuccessful, redirectSecondsLeft]);
+    useEffect(() => {
+        const subscription = watch((_value, { name }) => {
+            if (name) {
+                clearErrors(name);
+            }
+            clearErrors('root');
+        });
+        return () => {
+            subscription.unsubscribe();
+        };
+    }, [watch, clearErrors]);
+    useEffect(() => {
+        if (!isSubmitSuccessful || !onGoToSignIn) {
+            setRedirectSecondsLeft(null);
+            return;
+        }
+        setRedirectSecondsLeft(successRedirectSeconds);
+        const timer = window.setInterval(() => {
+            setRedirectSecondsLeft((current) => {
+                if (!current || current <= 1) {
+                    window.clearInterval(timer);
+                    onGoToSignIn();
+                    return 0;
+                }
+                return current - 1;
+            });
+        }, 1000);
+        return () => {
+            window.clearInterval(timer);
+        };
+    }, [isSubmitSuccessful, onGoToSignIn, successRedirectSeconds]);
+    async function onSubmitForm(values) {
+        try {
+            await onSubmit(values);
+        }
+        catch (error) {
+            const parsed = parseAuthError(error);
+            const allowedFields = [
+                'uid',
+                'token',
+                'newPassword',
+                'newPasswordConfirm'
+            ];
+            Object.entries(parsed.fieldErrors).forEach(([field, message]) => {
+                if (field === 'uid' || field === 'token') {
+                    setError('root', {
+                        type: 'manual',
+                        message
+                    });
+                    return;
+                }
+                if (allowedFields.includes(field)) {
+                    setError(field, {
+                        type: 'manual',
+                        message
+                    });
+                    return;
+                }
+                setError('root', {
+                    type: 'manual',
+                    message
+                });
+            });
+            if (parsed.rootMessage) {
+                setError('root', {
+                    type: 'manual',
+                    message: parsed.rootMessage
+                });
+                return;
+            }
+            if (Object.keys(parsed.fieldErrors).length > 0) {
+                const firstFieldError = Object.values(parsed.fieldErrors)[0];
+                if (firstFieldError) {
+                    setError('root', {
+                        type: 'manual',
+                        message: firstFieldError
+                    });
+                    return;
+                }
+            }
+            setError('root', {
+                type: 'manual',
+                message: 'No se pudo restablecer la contraseña. Inténtalo de nuevo.'
+            });
+        }
+    }
+    return (_jsxs("form", { name: "resetPasswordForm", noValidate: true, style: { display: 'flex', width: '100%', flexDirection: 'column', justifyContent: 'center', paddingTop: 4 }, onSubmit: handleSubmit(onSubmitForm), children: [!isSubmitSuccessful && !hasValidRecoveryLink ? (_jsx(Alert, { sx: { mb: 3 }, severity: "warning", children: "El enlace de recuperaci\u00F3n es inv\u00E1lido o incompleto." })) : null, !isSubmitSuccessful ? (_jsxs(_Fragment, { children: [_jsx(JBTextField, { control: control, name: "newPassword", sx: { mb: 3 }, label: "Nueva contrase\u00F1a", type: showNewPassword ? 'text' : 'password', InputProps: {
+                            endAdornment: (_jsx(InputAdornment, { position: "end", children: _jsx(IconButton, { edge: "end", "aria-label": showNewPassword ? 'Ocultar contraseña' : 'Mostrar contraseña', onClick: () => setShowNewPassword((prev) => !prev), children: showNewPassword ? _jsx(VisibilityOffOutlinedIcon, {}) : _jsx(VisibilityOutlinedIcon, {}) }) }))
+                        }, variant: "outlined", required: true, fullWidth: true }), _jsx(JBTextField, { control: control, name: "newPasswordConfirm", sx: { mb: 3 }, label: "Confirmar nueva contrase\u00F1a", type: showNewPasswordConfirm ? 'text' : 'password', InputProps: {
+                            endAdornment: (_jsx(InputAdornment, { position: "end", children: _jsx(IconButton, { edge: "end", "aria-label": showNewPasswordConfirm ? 'Ocultar confirmación de contraseña' : 'Mostrar confirmación de contraseña', onClick: () => setShowNewPasswordConfirm((prev) => !prev), children: showNewPasswordConfirm ? _jsx(VisibilityOffOutlinedIcon, {}) : _jsx(VisibilityOutlinedIcon, {}) }) }))
+                        }, variant: "outlined", required: true, fullWidth: true })] })) : null, errors.root?.message && (_jsx(Alert, { sx: { mb: 2 }, severity: "error", children: errors.root.message })), isSubmitSuccessful && (_jsx(Alert, { sx: { mb: 2 }, severity: "success", children: successMessage })), !isSubmitSuccessful ? (_jsx(AuthPrimaryButton, { "aria-label": submitLabel, startIcon: _jsx(LockResetOutlinedIcon, { fontSize: "small" }), disabled: loading || isSubmitting || _.isEmpty(dirtyFields) || !isValid || !hasValidRecoveryLink, type: "submit", size: "large", children: submitLabel })) : null, isSubmitSuccessful && onGoToSignIn ? (_jsx(AuthSecondaryButton, { sx: { mt: 2 }, startIcon: _jsx(ArrowBackOutlinedIcon, { fontSize: "small" }), onClick: onGoToSignIn, children: goToSignInLabel })) : null] }));
+}

package/dist/auth/forms/password/AuthResetPasswordForm.d.ts

@@ -0,0 +1,12 @@
+export type AuthResetPasswordFormValues = {
+    newPassword: string;
+    confirmPassword: string;
+};
+export type AuthResetPasswordFormProps = {
+    defaultValues?: Partial<AuthResetPasswordFormValues>;
+    loading?: boolean;
+    submitLabel?: string;
+    onSubmit: (values: AuthResetPasswordFormValues) => void | Promise<void>;
+};
+export declare function AuthResetPasswordForm(props: AuthResetPasswordFormProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=AuthResetPasswordForm.d.ts.map

package/dist/auth/forms/password/AuthResetPasswordForm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AuthResetPasswordForm.d.ts","sourceRoot":"","sources":["../../../../src/auth/forms/password/AuthResetPasswordForm.tsx"],"names":[],"mappings":"AAMA,MAAM,MAAM,2BAA2B,GAAG;IACxC,WAAW,EAAE,MAAM,CAAC;IACpB,eAAe,EAAE,MAAM,CAAC;CACzB,CAAC;AAEF,MAAM,MAAM,0BAA0B,GAAG;IACvC,aAAa,CAAC,EAAE,OAAO,CAAC,2BAA2B,CAAC,CAAC;IACrD,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,CAAC,MAAM,EAAE,2BAA2B,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACzE,CAAC;AAEF,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,0BAA0B,2CA+CtE"}

package/dist/auth/forms/password/AuthResetPasswordForm.js

@@ -0,0 +1,22 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Button, Stack } from '@mui/material';
+import { useForm } from 'react-hook-form';
+import { JBTextField } from '../../../forms';
+import { getDjangoLikePasswordError } from './passwordValidation';
+export function AuthResetPasswordForm(props) {
+    const { defaultValues, loading = false, submitLabel = 'Restablecer contraseña', onSubmit } = props;
+    const { control, handleSubmit, watch } = useForm({
+        defaultValues: {
+            newPassword: defaultValues?.newPassword ?? '',
+            confirmPassword: defaultValues?.confirmPassword ?? ''
+        }
+    });
+    const newPasswordValue = watch('newPassword');
+    return (_jsx("form", { style: { paddingTop: 4 }, onSubmit: handleSubmit((values) => onSubmit(values)), children: _jsxs(Stack, { spacing: 2, children: [_jsx(JBTextField, { control: control, name: "newPassword", label: "Nueva contrase\u00F1a", type: "password", fullWidth: true, rules: {
+                        required: 'El password es requerido',
+                        validate: (value) => getDjangoLikePasswordError(value) ?? true
+                    } }), _jsx(JBTextField, { control: control, name: "confirmPassword", label: "Confirmar contrase\u00F1a", type: "password", fullWidth: true, rules: {
+                        required: 'La confirmacion es requerida',
+                        validate: (value) => value === newPasswordValue || 'Las contraseñas no coinciden'
+                    } }), _jsx(Button, { variant: "contained", type: "submit", disabled: loading, children: submitLabel })] }) }));
+}

package/dist/auth/forms/password/index.d.ts

@@ -0,0 +1,4 @@
+export * from './AuthForgotPasswordForm';
+export * from './AuthPasswordResetConfirmForm';
+export * from './AuthResetPasswordForm';
+//# sourceMappingURL=index.d.ts.map

package/dist/auth/forms/password/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/auth/forms/password/index.ts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAC;AACzC,cAAc,gCAAgC,CAAC;AAC/C,cAAc,yBAAyB,CAAC"}

package/dist/auth/forms/password/index.js

@@ -0,0 +1,3 @@
+export * from './AuthForgotPasswordForm';
+export * from './AuthPasswordResetConfirmForm';
+export * from './AuthResetPasswordForm';

package/dist/auth/forms/password/passwordValidation.d.ts

@@ -0,0 +1,3 @@
+export declare function getDjangoLikePasswordError(password: string): string | null;
+export declare function isPasswordTooSimilar(password: string, candidates: Array<string | undefined | null>): boolean;
+//# sourceMappingURL=passwordValidation.d.ts.map

package/dist/auth/forms/password/passwordValidation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"passwordValidation.d.ts","sourceRoot":"","sources":["../../../../src/auth/forms/password/passwordValidation.ts"],"names":[],"mappings":"AAqBA,wBAAgB,0BAA0B,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAe1E;AAED,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,KAAK,CAAC,MAAM,GAAG,SAAS,GAAG,IAAI,CAAC,GAAG,OAAO,CAa5G"}

package/dist/auth/forms/password/passwordValidation.js

@@ -0,0 +1,45 @@
+const COMMON_PASSWORDS = new Set([
+    '12345678',
+    '123456789',
+    'password',
+    'password123',
+    'qwerty123',
+    'abc12345',
+    'letmein123',
+    'admin1234',
+    'welcome123',
+    'iloveyou123'
+]);
+function normalize(value) {
+    return value
+        .normalize('NFD')
+        .replace(/[\u0300-\u036f]/g, '')
+        .toLowerCase()
+        .trim();
+}
+export function getDjangoLikePasswordError(password) {
+    if (!password || password.length < 8) {
+        return 'La contraseña debe tener al menos 8 caracteres.';
+    }
+    if (/^\d+$/.test(password)) {
+        return 'La contraseña no puede ser completamente numérica.';
+    }
+    const normalized = normalize(password);
+    if (COMMON_PASSWORDS.has(normalized)) {
+        return 'La contraseña es demasiado común.';
+    }
+    return null;
+}
+export function isPasswordTooSimilar(password, candidates) {
+    const normalizedPassword = normalize(password);
+    if (!normalizedPassword) {
+        return false;
+    }
+    return candidates.some((candidate) => {
+        const normalizedCandidate = normalize(candidate ?? '');
+        if (normalizedCandidate.length < 3) {
+            return false;
+        }
+        return normalizedPassword.includes(normalizedCandidate);
+    });
+}

package/dist/auth/forms/sign-in/AuthOtpSignInForm.d.ts

@@ -0,0 +1,24 @@
+import { SelectOption } from '../../../forms';
+export type AuthOtpSignInFormValues = {
+    countryCode: string;
+    phone: string;
+    code?: string;
+};
+export type AuthOtpSignInFormProps = {
+    defaultValues?: Partial<AuthOtpSignInFormValues>;
+    countryCodeOptions?: SelectOption<string>[];
+    requestRoleSelection?: () => Promise<string | undefined>;
+    countryCodes?: string[];
+    loading?: boolean;
+    onRequestOtp: (values: {
+        phone: string;
+    }) => unknown | Promise<unknown>;
+    onVerifyOtp: (values: {
+        phone: string;
+        code: string;
+        role?: string;
+    }) => unknown | Promise<unknown>;
+    onBackToPassword?: () => void;
+};
+export declare function AuthOtpSignInForm(props: AuthOtpSignInFormProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=AuthOtpSignInForm.d.ts.map

package/dist/auth/forms/sign-in/AuthOtpSignInForm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AuthOtpSignInForm.d.ts","sourceRoot":"","sources":["../../../../src/auth/forms/sign-in/AuthOtpSignInForm.tsx"],"names":[],"mappings":"AAaA,OAAO,EAA8B,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAK1E,MAAM,MAAM,uBAAuB,GAAG;IACpC,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAAG;IACnC,aAAa,CAAC,EAAE,OAAO,CAAC,uBAAuB,CAAC,CAAC;IACjD,kBAAkB,CAAC,EAAE,YAAY,CAAC,MAAM,CAAC,EAAE,CAAC;IAC5C,oBAAoB,CAAC,EAAE,MAAM,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAAC;IACzD,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,YAAY,EAAE,CAAC,MAAM,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IACxE,WAAW,EAAE,CAAC,MAAM,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IACpG,gBAAgB,CAAC,EAAE,MAAM,IAAI,CAAC;CAC/B,CAAC;AAQF,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,sBAAsB,2CAuX9D"}