@stackcraftmx/calcita 0.0.0-stage → 0.25.0

package/dist/types/feedback/toast.d.ts

@@ -0,0 +1,100 @@
+export declare const TOAST_DEFAULT_OPTIONS: Readonly<{
+    duration: 5000;
+    closeButton: true;
+    dismissible: true;
+}>;
+/**
+ * Aviso de que algo salió bien.
+ *
+ * @param {import('react').ReactNode} [message] ya traducido; con saltos de línea, un renglón cada uno; por omisión «Listo» (common:toast.done)
+ * @param {import('sonner').ExternalToast} [options] las de sonner (duración, acción…), encima de TOAST_DEFAULT_OPTIONS
+ * @returns {string|number} el id del aviso (para cerrarlo con dismissToast)
+ */
+export declare function toastSuccess(message?: import('react').ReactNode, options?: import('sonner').ExternalToast): string | number;
+/**
+ * Aviso de error.
+ *
+ * @param {import('react').ReactNode} [message] ya traducido; con saltos de línea, un renglón cada uno; por omisión el error genérico (common:toast.error)
+ * @param {import('sonner').ExternalToast} [options] las de sonner (duración, acción…), encima de TOAST_DEFAULT_OPTIONS
+ * @returns {string|number} el id del aviso (para cerrarlo con dismissToast)
+ */
+export declare function toastError(message?: import('react').ReactNode, options?: import('sonner').ExternalToast): string | number;
+/**
+ * Aviso de advertencia.
+ *
+ * @param {import('react').ReactNode} [message] ya traducido; con saltos de línea, un renglón cada uno; por omisión la advertencia genérica (common:toast.warning)
+ * @param {import('sonner').ExternalToast} [options] las de sonner (duración, acción…), encima de TOAST_DEFAULT_OPTIONS
+ * @returns {string|number} el id del aviso (para cerrarlo con dismissToast)
+ */
+export declare function toastWarn(message?: import('react').ReactNode, options?: import('sonner').ExternalToast): string | number;
+/**
+ * Aviso informativo.
+ *
+ * @param {import('react').ReactNode} [message] ya traducido; con saltos de línea, un renglón cada uno; por omisión el aviso genérico (common:toast.info)
+ * @param {import('sonner').ExternalToast} [options] las de sonner (duración, acción…), encima de TOAST_DEFAULT_OPTIONS
+ * @returns {string|number} el id del aviso (para cerrarlo con dismissToast)
+ */
+export declare function toastInfo(message?: import('react').ReactNode, options?: import('sonner').ExternalToast): string | number;
+/**
+ * Aviso sin tipo (sin ícono ni color).
+ *
+ * @param {import('react').ReactNode} [message] ya traducido; con saltos de línea, un renglón cada uno
+ * @param {import('sonner').ExternalToast} [options] las de sonner (duración, acción…), encima de TOAST_DEFAULT_OPTIONS
+ * @returns {string|number} el id del aviso (para cerrarlo con dismissToast)
+ */
+export declare function toastDefault(message?: import('react').ReactNode, options?: import('sonner').ExternalToast): string | number;
+/**
+ * Aviso que NO se cierra solo. Regresa el id para cerrarlo al terminar.
+ *
+ * @param {import('react').ReactNode} [message] ya traducido; por omisión «Trabajando…» (common:toast.working)
+ * @param {import('sonner').ExternalToast} [options]
+ * @returns {string|number} el id del aviso (para dismissToast)
+ */
+export declare function toastLoading(message?: import('react').ReactNode, options?: import('sonner').ExternalToast): string | number;
+/**
+ * Envuelve una promesa: cargando → listo | error, solo.
+ *
+ * @template T
+ * @param {Promise<T>} promise
+ * @param {object} messages ya traducidos
+ * @param {import('react').ReactNode} messages.loading
+ * @param {import('react').ReactNode | ((data: T) => import('react').ReactNode)} messages.success
+ * @param {import('react').ReactNode | ((failure: unknown) => import('react').ReactNode)} messages.error
+ * @param {import('sonner').ExternalToast} [options]
+ */
+export declare function toastPromise<T>(promise: Promise<T>, { loading, success, error }: {
+    loading: import('react').ReactNode;
+    success: import('react').ReactNode | ((data: T) => import('react').ReactNode);
+    error: import('react').ReactNode | ((failure: unknown) => import('react').ReactNode);
+}, options?: import('sonner').ExternalToast): {
+    unwrap: () => Promise<T>;
+} | (string & {
+    unwrap: () => Promise<T>;
+}) | (number & {
+    unwrap: () => Promise<T>;
+});
+/**
+ * Cierra un aviso (el id que regresan las funciones de arriba); sin id, todos.
+ *
+ * @param {string|number} [toastId]
+ */
+export declare function dismissToast(toastId?: string | number): string | number;
+/**
+ * {email: ['Requerido', 'Inválido']} → "Requerido\nInválido".
+ *
+ * @param {Record<string, string[]|string>|null|undefined} errorsByField
+ * @param {{dedup?: boolean}} [options]
+ * @returns {string}
+ */
+export declare function errorsObjectToMessage(errorsByField: Record<string, string[] | string> | null | undefined, { dedup }?: {
+    dedup?: boolean;
+}): string;
+/**
+ * Aviso de error a partir de un ApiError: usa el detail traducido y, si es un 422, enumera los mensajes por campo.
+ *
+ * @param {Error & {problem?: object}} error
+ * @param {object} [options] opciones de sonner
+ */
+export declare function toastProblem(error: Error & {
+    problem?: object;
+}, options?: object): string | number;

package/dist/types/feedback/useConfirmAction.d.ts

@@ -0,0 +1,33 @@
+/**
+ * @param {object} options
+ * @param {(input: {subject: any, details: any}) => Promise<unknown>|void} options.run lo que se hace al confirmar (subject: lo que
+ *     se le pasó a open)
+ * @param {(output: any, subject: any) => void} [options.onDone] output: lo que regresó run
+ * @returns {{
+ *   subject: object|null, isOpen: boolean, isRunning: boolean, error: Error|null,
+ *   open: (subject: any) => void, confirm: (details?: any) => void, cancel: () => void,
+ *   dialogProps: {open: boolean, isPending: boolean, errorMessage: string|null, onConfirm: (details?: object) => void, onClose: () => void},
+ * }}
+ */
+export declare function useConfirmAction({ run, onDone }: {
+    run: (input: {
+        subject: any;
+        details: any;
+    }) => Promise<unknown> | void;
+    onDone?: (output: any, subject: any) => void;
+}): {
+    subject: object | null;
+    isOpen: boolean;
+    isRunning: boolean;
+    error: Error | null;
+    open: (subject: any) => void;
+    confirm: (details?: any) => void;
+    cancel: () => void;
+    dialogProps: {
+        open: boolean;
+        isPending: boolean;
+        errorMessage: string | null;
+        onConfirm: (details?: object) => void;
+        onClose: () => void;
+    };
+};

package/dist/types/filepond/FileDropzone.d.ts

@@ -0,0 +1,61 @@
+/**
+ * @param {object} props
+ * @param {File|File[]|null} [props.value]
+ * @param {(value: File|File[]|null) => void} props.onChange
+ * @param {string|string[]} [props.accept]
+ * @param {number|string} [props.maxSize] por archivo
+ * @param {boolean} [props.multiple]
+ * @param {number} [props.maxFiles]
+ * @param {number|string} [props.maxTotalSize]
+ * @param {string} [props.name] nombre del campo; por omisión uno propio por zona (dos zonas no se pisan)
+ * @param {string} [props.hint]
+ * @param {string} [props.buttonLabel]
+ * @param {boolean} [props.disabled]
+ * @param {boolean} [props.busy]
+ * @param {boolean|{title?: string, text?: string}} [props.busyModal]
+ * @param {boolean} [props.autoReject]
+ * @param {((file: File) => Promise<true|string>)|null} [props.validate]
+ * @param {object|null} [props.server] createPondServer(...) o {process} propio
+ * @param {boolean} [props.instantUpload]
+ * @param {{current: object|null}|null} [props.apiRef]
+ * @param {(progress: {done: number, total: number}) => void} [props.onProcessProgress]
+ * @param {(file: File|null, reason: string, message?: string) => void} [props.onReject] reason de FILE_REJECTION
+ * @param {import('react').ReactNode} [props.actions]
+ * @param {import('react').ReactNode} [props.children]
+ * @param {object} [props.sx]
+ * @param {object} [props.texts] los textos que cambian, con la forma de `common` en los textos del paquete
+ */
+export default function FileDropzone({ value, onChange, accept, maxSize, multiple, maxFiles, maxTotalSize, name, hint, buttonLabel, disabled, busy, busyModal, autoReject, validate, server, instantUpload, apiRef, onProcessProgress, onReject, actions, children, sx, texts, }: {
+    value?: File | File[] | null;
+    onChange: (value: File | File[] | null) => void;
+    accept?: string | string[];
+    maxSize?: number | string;
+    multiple?: boolean;
+    maxFiles?: number;
+    maxTotalSize?: number | string;
+    name?: string;
+    hint?: string;
+    buttonLabel?: string;
+    disabled?: boolean;
+    busy?: boolean;
+    busyModal?: boolean | {
+        title?: string;
+        text?: string;
+    };
+    autoReject?: boolean;
+    validate?: ((file: File) => Promise<true | string>) | null;
+    server?: object | null;
+    instantUpload?: boolean;
+    apiRef?: {
+        current: object | null;
+    } | null;
+    onProcessProgress?: (progress: {
+        done: number;
+        total: number;
+    }) => void;
+    onReject?: (file: File | null, reason: string, message?: string) => void;
+    actions?: import('react').ReactNode;
+    children?: import('react').ReactNode;
+    sx?: object;
+    texts?: object;
+}): import("react").JSX.Element;

package/dist/types/filepond/pondServer.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @param {object} options
+ * @param {string} options.url a dónde va cada archivo
+ * @param {string} [options.fieldName] el campo del archivo en el FormData; por omisión el name de la zona
+ * @param {Record<string, string>} [options.headers] p. ej. Authorization
+ * @param {boolean} [options.withCredentials] manda las cookies a otro dominio
+ * @returns {{process: (...args: any[]) => any, revert: (...args: any[]) => any}} lo que recibe la prop server de FileDropzone
+ */
+export declare function createPondServer({ url, fieldName, headers, withCredentials }: {
+    url: string;
+    fieldName?: string;
+    headers?: Record<string, string>;
+    withCredentials?: boolean;
+}): {
+    process: (...args: any[]) => any;
+    revert: (...args: any[]) => any;
+};

package/dist/types/filepond.d.ts

@@ -0,0 +1,3 @@
+export { default as FileDropzone } from './filepond/FileDropzone.js';
+export { createPondServer } from './filepond/pondServer.js';
+export { FILE_ACCEPT_PRESETS, FILE_REJECTION } from './upload/fileRules.js';

package/dist/types/files.d.ts

@@ -0,0 +1,29 @@
+/** Tipo de contenido de un Excel (XLSX): el mismo que manda el servidor (IngestionDictionary::XLSX_CONTENT_TYPE). */
+export declare const XLSX_CONTENT_TYPE = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
+/**
+ * Nombre de archivo del header Content-Disposition. Prefiere filename*=UTF-8'' (acentos) sobre filename=.
+ *
+ * @param {string|null|undefined} contentDisposition
+ * @param {string} fallbackFileName si el header no trae nombre
+ */
+export declare function fileNameFromContentDisposition(contentDisposition: string | null | undefined, fallbackFileName: string): string;
+/**
+ * Dispara la descarga de un Blob con el nombre dado.
+ *
+ * @param {Blob} blob
+ * @param {string} fileName
+ */
+export declare function saveBlob(blob: Blob, fileName: string): void;
+/**
+ * ¿Llegó completo el zip (un XLSX)? Sí, si termina con su registro de cierre.
+ *
+ * Por qué hace falta: el servidor manda los Excel por partes y con 200 desde el primer pedazo. Si algo falla a media
+ * escritura (p. ej. llegan más renglones de los que se contaron), ya no puede cambiar la respuesta a un error: el archivo
+ * llega cortado y Excel no lo abre. Esta revisión es lo que evita guardarlo como si estuviera bien.
+ *
+ * OJO: supone un zip sin comentario, como los que escribe el servidor (zipstream sin comentario).
+ *
+ * @param {Blob} blob el archivo descargado
+ * @returns {Promise<boolean>}
+ */
+export declare function isCompleteZip(blob: Blob): Promise<boolean>;

package/dist/types/formatting.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Los formatos con la configuración que da settingsOf (se lee en cada llamada: si cambia el idioma, el siguiente formato ya
+ * sale en el nuevo).
+ *
+ * @param {() => {language: string, languages?: Array<{code: string, locale?: string}>, timeZone: string, currency: string}} settingsOf
+ */
+export declare function formattersOf(settingsOf: () => {
+    language: string;
+    languages?: Array<{
+        code: string;
+        locale?: string;
+    }>;
+    timeZone: string;
+    currency: string;
+}): Readonly<{
+    formatNumber: (value: number | string | null | undefined, fallback?: string) => string;
+    formatList: (items: string[]) => string;
+    formatCurrency: (value: number | string | null | undefined, fallback?: string) => string;
+    formatFileSize: (bytes: number | null | undefined, fallback?: string) => string;
+    formatPercent: (value: number | null | undefined, { fractionDigits, isRatio, fallback }?: {
+        fractionDigits?: number;
+        isRatio?: boolean;
+        fallback?: string;
+    }) => string;
+    formatDateTime: (value: string | null | undefined, { fallback }?: {
+        fallback?: string;
+    }) => string;
+    formatDate: (value: string | null | undefined, { fallback }?: {
+        fallback?: string;
+    }) => string;
+    formatTime: (value: string | null | undefined, { fallback }?: {
+        fallback?: string;
+    }) => string;
+    formatMonthName: (year: number, month: number, { style, capitalize }?: {
+        style?: 'long' | 'short';
+        capitalize?: boolean;
+    }) => string;
+    formatMonthShortName: (month: number) => string;
+    formatWeekdayShortName: (isoWeekday: number) => string;
+}>;
+export declare const formatNumber: (value: number | string | null | undefined, fallback?: string) => string, formatList: (items: string[]) => string, formatCurrency: (value: number | string | null | undefined, fallback?: string) => string, formatFileSize: (bytes: number | null | undefined, fallback?: string) => string, formatPercent: (value: number | null | undefined, { fractionDigits, isRatio, fallback }?: {
+    fractionDigits?: number;
+    isRatio?: boolean;
+    fallback?: string;
+}) => string, formatDateTime: (value: string | null | undefined, { fallback }?: {
+    fallback?: string;
+}) => string, formatDate: (value: string | null | undefined, { fallback }?: {
+    fallback?: string;
+}) => string, formatTime: (value: string | null | undefined, { fallback }?: {
+    fallback?: string;
+}) => string, formatMonthName: (year: number, month: number, { style, capitalize }?: {
+    style?: 'long' | 'short';
+    capitalize?: boolean;
+}) => string, formatMonthShortName: (month: number) => string, formatWeekdayShortName: (isoWeekday: number) => string;
+/**
+ * Día del mes de una fecha de calendario ("2026-08-16" → 16), sin moverla de zona.
+ *
+ * @param {string|null|undefined} value
+ * @returns {number|null}
+ */
+export declare function dayOfPlainDate(value: string | null | undefined): number | null;

package/dist/types/forms/FormCatalogField.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @param {{name: string} & Omit<Parameters<typeof import('../inputs/CatalogInput.js').default>[0], 'name'|'value'|'onChange'|'onBlur'|'error'>} props las de CatalogInput (options, formatLabel, loading…), sin value / onChange / onBlur / error
+ */
+export default function FormCatalogField({ name, ...catalogInputProps }: {
+    name: string;
+} & Omit<Parameters<typeof import('../inputs/CatalogInput.js').default>[0], 'name' | 'value' | 'onChange' | 'onBlur' | 'error'>): import("react").JSX.Element;

package/dist/types/forms/FormColorField.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @param {{name: string} & Omit<Parameters<typeof import('../inputs/ColorInput.js').default>[0], 'name'|'value'|'onChange'|'onBlur'|'error'>} props las de ColorInput (checkContrast…), sin value / onChange / onBlur / error
+ */
+export default function FormColorField({ name, ...colorInputProps }: {
+    name: string;
+} & Omit<Parameters<typeof import('../inputs/ColorInput.js').default>[0], 'name' | 'value' | 'onChange' | 'onBlur' | 'error'>): import("react").JSX.Element;

package/dist/types/forms/FormNumberField.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @param {{name: string} & Omit<Parameters<typeof import('../inputs/NumberInput.js').default>[0], 'name'|'value'|'onChange'|'onBlur'|'error'>} props las de NumberInput (decimals, prefix, suffix, allowNegative…), sin value / onChange / onBlur / error
+ */
+export default function FormNumberField({ name, ...numberInputProps }: {
+    name: string;
+} & Omit<Parameters<typeof import('../inputs/NumberInput.js').default>[0], 'name' | 'value' | 'onChange' | 'onBlur' | 'error'>): import("react").JSX.Element;

package/dist/types/forms/FormProblemAlert.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @param {{sx?: object}} props
+ */
+export default function FormProblemAlert({ sx }: {
+    sx?: object;
+}): import("react").JSX.Element | null;

package/dist/types/forms/FormSelectField.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @param {{name: string} & Omit<Parameters<typeof import('../inputs/SelectInput.js').default>[0], 'name'|'value'|'onChange'|'onBlur'|'error'>} props las de SelectInput, sin value / onChange / onBlur / error
+ */
+export default function FormSelectField({ name, ...selectInputProps }: {
+    name: string;
+} & Omit<Parameters<typeof import('../inputs/SelectInput.js').default>[0], 'name' | 'value' | 'onChange' | 'onBlur' | 'error'>): import("react").JSX.Element;

package/dist/types/forms/FormServerProblem.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @param {{error: (Error & {problem?: object})|null}} props el error del contexto de la máquina (null = sin error)
+ */
+export default function FormServerProblem({ error }: {
+    error: (Error & {
+        problem?: object;
+    }) | null;
+}): null;

package/dist/types/forms/FormTextField.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @param {{name: string} & Omit<Parameters<typeof import('../inputs/TextInput.js').default>[0], 'name'|'value'|'onChange'|'onBlur'|'error'>} props las de TextInput, sin value / onChange / onBlur / error
+ */
+export default function FormTextField({ name, ...textInputProps }: {
+    name: string;
+} & Omit<Parameters<typeof import('../inputs/TextInput.js').default>[0], 'name' | 'value' | 'onChange' | 'onBlur' | 'error'>): import("react").JSX.Element;

package/dist/types/forms/FormWizard.d.ts

@@ -0,0 +1,22 @@
+/**
+ * @param {object} props
+ * @param {Object[]} props.steps en orden
+ * @param {string} props.steps[].key
+ * @param {string} props.steps[].label ya traducido
+ * @param {string[]} [props.steps[].fields] los campos del paso (los que revisa «Siguiente»)
+ * @param {boolean} [props.steps[].optional] se puede omitir
+ * @param {import('react').ReactNode} props.steps[].content los campos del paso
+ * @param {string} props.submitLabel ya traducido: el botón del último paso
+ * @param {object} [props.texts] los textos que cambian, con la forma de `common`: {wizard: {next, back, skip, optional, skipped, stepOf}}
+ */
+export default function FormWizard({ steps, submitLabel, texts }: {
+    steps: {
+        key: string;
+        label: string;
+        fields?: string[];
+        optional?: boolean;
+        content: import('react').ReactNode;
+    }[];
+    submitLabel: string;
+    texts?: object;
+}): import("react").JSX.Element;

package/dist/types/forms/SubmitButton.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @param {{children: import('react').ReactNode, disabled?: boolean, isPending?: boolean} & Omit<import('@mui/material/Button').ButtonProps, 'type'|'children'>} props
+ *     lo demás va al Button de MUI (sx, size, fullWidth…)
+ */
+export default function SubmitButton({ children, disabled, isPending, ...buttonProps }: {
+    children: import('react').ReactNode;
+    disabled?: boolean;
+    isPending?: boolean;
+} & Omit<import('@mui/material/Button').ButtonProps, 'type' | 'children'>): import("react").JSX.Element;

package/dist/types/forms/applyServerProblem.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @param {unknown} error normalmente un ApiError (trae problem y message ya traducidos)
+ * @param {{setFieldError: Function, setStatus: Function, values: object}} formikHelpers
+ */
+export declare function applyServerProblem(error: unknown, { setFieldError, setStatus, values }: {
+    setFieldError: Function;
+    setStatus: Function;
+    values: object;
+}): void;

package/dist/types/forms/auth/ChangePasswordForm.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @param {object} props
+ * @param {(values: {currentPassword?: string, newPassword: string}) => Promise<unknown>} props.onSubmit cambia la
+ *     contraseña; si el servidor dice que no (la actual no es), truena con su problema
+ * @param {boolean} [props.requireCurrentPassword] por omisión sí; sin ella para la pantalla del enlace del correo
+ * @param {object} [props.policy] las reglas de la nueva; por omisión DEFAULT_PASSWORD_POLICY
+ * @param {object} [props.texts] los textos que cambian, con la forma de `auth` en los textos del paquete
+ */
+export default function ChangePasswordForm({ onSubmit, requireCurrentPassword, policy, texts }: {
+    onSubmit: (values: {
+        currentPassword?: string;
+        newPassword: string;
+    }) => Promise<unknown>;
+    requireCurrentPassword?: boolean;
+    policy?: object;
+    texts?: object;
+}): import("react").JSX.Element;

package/dist/types/forms/auth/ForgotPasswordForm.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @param {object} props
+ * @param {(values: {email: string}) => Promise<unknown>} props.onSubmit pide el enlace; si el servidor falla, truena con su
+ *     problema
+ * @param {string} [props.signInPath] la liga para regresar a iniciar sesión
+ * @param {object} [props.texts] los textos que cambian, con la forma de `auth` en los textos del paquete
+ */
+export default function ForgotPasswordForm({ onSubmit, signInPath, texts }: {
+    onSubmit: (values: {
+        email: string;
+    }) => Promise<unknown>;
+    signInPath?: string;
+    texts?: object;
+}): import("react").JSX.Element;

package/dist/types/forms/auth/SignInForm.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @param {object} props
+ * @param {(values: {email: string, password: string, remember: boolean}) => Promise<unknown>} props.onSubmit entra; si
+ *     el servidor dice que no, truena con su problema
+ * @param {string} [props.forgotPasswordPath] sin ella no sale la liga de «¿Olvidó su contraseña?»
+ * @param {boolean} [props.showRememberMe] por omisión sí
+ * @param {string} [props.initialEmail]
+ * @param {object} [props.texts] los textos que cambian, con la forma de `auth` en los textos del paquete
+ */
+export default function SignInForm({ onSubmit, forgotPasswordPath, showRememberMe, initialEmail, texts }: {
+    onSubmit: (values: {
+        email: string;
+        password: string;
+        remember: boolean;
+    }) => Promise<unknown>;
+    forgotPasswordPath?: string;
+    showRememberMe?: boolean;
+    initialEmail?: string;
+    texts?: object;
+}): import("react").JSX.Element;

package/dist/types/forms/index.d.ts

@@ -0,0 +1,19 @@
+export { default as FormCatalogField } from './FormCatalogField.js';
+export { default as FormColorField } from './FormColorField.js';
+export { default as FormNumberField } from './FormNumberField.js';
+export { default as FormProblemAlert } from './FormProblemAlert.js';
+export { default as FormSelectField } from './FormSelectField.js';
+export { default as FormServerProblem } from './FormServerProblem.js';
+export { default as FormTextField } from './FormTextField.js';
+export { default as FormWizard } from './FormWizard.js';
+export { default as ChangePasswordForm } from './auth/ChangePasswordForm.js';
+export { default as ForgotPasswordForm } from './auth/ForgotPasswordForm.js';
+export { default as SignInForm } from './auth/SignInForm.js';
+export { SECOND_STEP_METHOD, default as SecondStepForm } from './security/SecondStepForm.js';
+export { default as TwoStepVerificationCard } from './security/TwoStepVerificationCard.js';
+export { RECOVERY_CODE_PATTERN, TOTP_CODE_PATTERN, normalizeRecoveryCode, normalizeTotpCode, } from './security/securityRules.js';
+export { default as SubmitButton } from './SubmitButton.js';
+export { applyServerProblem } from './applyServerProblem.js';
+export { formLevelMessageOf, splitServerFieldErrors } from './serverProblemFields.js';
+export { useFormikField } from './useFormikField.js';
+export { Yup, buildYupLocale, translateValidationMessage } from './validation.js';

package/dist/types/forms/security/SecondStepForm.d.ts

@@ -0,0 +1,30 @@
+/** Las formas de confirmar el segundo paso, como las manda el servidor. */
+export declare const SECOND_STEP_METHOD: Readonly<{
+    passkey: "passkey";
+    totp: "totp";
+    recoveryCode: "recoveryCode";
+}>;
+/**
+ * @param {object} props
+ * @param {string[]} props.methods los que tiene la cuenta (SECOND_STEP_METHOD), como los mandó el servidor
+ * @param {boolean} [props.canUsePasskeys] passkeysSupported() de /passkeys
+ * @param {() => Promise<unknown>} [props.onUsePasskey] firma con la llave y termina de entrar; truena si no se pudo
+ * @param {(input: {method: string, code: string}) => Promise<unknown>} props.onSubmitCode manda el código ya limpio y
+ *     termina de entrar; truena con el ApiError si no
+ * @param {(message: string|null) => void} props.onCancel regresa a escribir la contraseña (con el motivo, si lo hay)
+ * @param {import('react').ReactNode} [props.footer] abajo del botón, dentro del formulario: puede llenar el código con
+ *     useFormikContext (p. ej. el atajo de los ejemplos)
+ * @param {object} [props.texts] los textos que cambian, con la forma de `security` en los textos del paquete
+ */
+export default function SecondStepForm({ methods, canUsePasskeys, onUsePasskey, onSubmitCode, onCancel, footer, texts }: {
+    methods: string[];
+    canUsePasskeys?: boolean;
+    onUsePasskey?: () => Promise<unknown>;
+    onSubmitCode: (input: {
+        method: string;
+        code: string;
+    }) => Promise<unknown>;
+    onCancel: (message: string | null) => void;
+    footer?: import('react').ReactNode;
+    texts?: object;
+}): import("react").JSX.Element;

package/dist/types/forms/security/TwoStepVerificationCard.d.ts

@@ -0,0 +1,83 @@
+/**
+ * @param {object} props
+ * @param {{isEnabled: boolean, enabledAt?: string|null, passkeys: Array<{id: string, name: string, createdAt: string, lastUsedAt?: string|null}>, totp: {isEnabled: boolean, enabledAt?: string|null}, recoveryCodesRemaining: number}} props.security
+ * @param {(security: {isEnabled: boolean, enabledAt?: string|null, passkeys: Array<{id: string, name: string, createdAt: string, lastUsedAt?: string|null}>, totp: {isEnabled: boolean, enabledAt?: string|null}, recoveryCodesRemaining: number}) => void} props.onSecurityChange
+ * @param {object} props.actions lo que hace el proyecto en cada caso; cada una regresa {security, recoveryCodes?}
+ * @param {(name: string) => Promise<{security: object, recoveryCodes?: string[]}>} props.actions.addPasskey crea la llave
+ *     (createPasskey) y la guarda en el servidor
+ * @param {(passkey: {id: string, name: string}, password: string) => Promise<{security: object}>} props.actions.removePasskey
+ * @param {() => Promise<{secret: string, qrImageUrl: string, extra?: import('react').ReactNode}>} props.actions.startTotp
+ *     la clave y su QR; extra va abajo del campo (p. ej. un atajo de los ejemplos)
+ * @param {(code: string) => Promise<{security: object, recoveryCodes?: string[]}>} props.actions.confirmTotp
+ * @param {(password: string) => Promise<{security: object}>} props.actions.disableTotp
+ * @param {(password: string) => Promise<{security: object, recoveryCodes: string[]}>} props.actions.regenerateRecoveryCodes
+ * @param {boolean} [props.canUsePasskeys] passkeysSupported() de /passkeys; sin él no se ofrece agregar llaves
+ * @param {string} [props.account] la cuenta (el correo), para el archivo de los códigos
+ * @param {import('react').ReactNode} [props.passkeyNotice] un aviso en el diálogo de crear la llave, antes de que el
+ *     navegador la guarde (p. ej. el de la demostración: la llave queda de verdad en el llavero de la persona)
+ * @param {object} [props.texts] los textos que cambian, con la forma de `security` en los textos del paquete
+ */
+export default function TwoStepVerificationCard({ security, onSecurityChange, actions, canUsePasskeys, account, passkeyNotice, texts }: {
+    security: {
+        isEnabled: boolean;
+        enabledAt?: string | null;
+        passkeys: Array<{
+            id: string;
+            name: string;
+            createdAt: string;
+            lastUsedAt?: string | null;
+        }>;
+        totp: {
+            isEnabled: boolean;
+            enabledAt?: string | null;
+        };
+        recoveryCodesRemaining: number;
+    };
+    onSecurityChange: (security: {
+        isEnabled: boolean;
+        enabledAt?: string | null;
+        passkeys: Array<{
+            id: string;
+            name: string;
+            createdAt: string;
+            lastUsedAt?: string | null;
+        }>;
+        totp: {
+            isEnabled: boolean;
+            enabledAt?: string | null;
+        };
+        recoveryCodesRemaining: number;
+    }) => void;
+    actions: {
+        addPasskey: (name: string) => Promise<{
+            security: object;
+            recoveryCodes?: string[];
+        }>;
+        removePasskey: (passkey: {
+            id: string;
+            name: string;
+        }, password: string) => Promise<{
+            security: object;
+        }>;
+        startTotp: () => Promise<{
+            secret: string;
+            qrImageUrl: string;
+            extra?: import('react').ReactNode;
+        }>;
+        confirmTotp: (code: string) => Promise<{
+            security: object;
+            recoveryCodes?: string[];
+        }>;
+        disableTotp: (password: string) => Promise<{
+            security: object;
+        }>;
+        regenerateRecoveryCodes: (password: string) => Promise<{
+            security: object;
+            recoveryCodes: string[];
+        }>;
+    };
+    canUsePasskeys?: boolean;
+    account?: string;
+    passkeyNotice?: import('react').ReactNode;
+    texts?: object;
+}): import("react").JSX.Element;

package/dist/types/forms/security/securityRules.d.ts

@@ -0,0 +1,24 @@
+export declare const TOTP_CODE_MIN_LENGTH = 6;
+export declare const TOTP_CODE_MAX_LENGTH = 7;
+export declare const RECOVERY_CODE_MIN_LENGTH = 10;
+export declare const RECOVERY_CODE_MAX_LENGTH = 11;
+export declare const PASSKEY_NAME_MAX_LENGTH = 60;
+export declare const CURRENT_PASSWORD_MAX_LENGTH = 128;
+/** «123456» o «123 456». */
+export declare const TOTP_CODE_PATTERN: RegExp;
+/** «ABCDE-FGHJK» o «ABCDEFGHJK». */
+export declare const RECOVERY_CODE_PATTERN: RegExp;
+/**
+ * El código de la app como lo espera el servidor: los 6 dígitos sin espacios.
+ *
+ * @param {string} code
+ * @returns {string}
+ */
+export declare function normalizeTotpCode(code: string): string;
+/**
+ * El código de recuperación como lo espera el servidor: en mayúsculas y con su guion (ABCDE-FGHJK).
+ *
+ * @param {string} code
+ * @returns {string}
+ */
+export declare function normalizeRecoveryCode(code: string): string;