@stackcraftmx/calcita 0.0.0-stage → 0.25.0

package/dist/types/maps/MapView.d.ts

@@ -0,0 +1,41 @@
+/** Los mosaicos de OpenStreetMap con su crédito (lo pide su política de uso). */
+export declare const OPEN_STREET_MAP_TILES: Readonly<{
+    url: "https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png";
+    attribution: "&copy; <a href=\"https://www.openstreetmap.org/copyright\">OpenStreetMap</a>";
+}>;
+/**
+ * @param {object} props
+ * @param {Array<{id: string, position: [number, number], title: string, description?: string, tone?: string} & Record<string, any>>} props.markers
+ *     tone: un color del tema (primary, success, warning, error, info…); por omisión primary
+ * @param {string|null} [props.selectedId]
+ * @param {(markerId: string) => void} [props.onSelect] al picar un marcador
+ * @param {string} props.ariaLabel ya traducido: qué enseña el mapa
+ * @param {number} [props.height] px
+ * @param {{url: string, attribution: string}} [props.tileLayer] por omisión OpenStreetMap
+ * @param {(marker: any) => import('react').ReactNode} [props.renderPopup] lo que dice el globo de un marcador (recibe el
+ *     marcador tal cual, con sus campos propios); por omisión su título y su descripción
+ * @param {(position: [number, number]) => void} [props.onMapClick] al picar el mapa fuera de un marcador
+ * @param {import('react').ReactNode} [props.children] capas propias de react-leaflet (Circle, Polygon, GeoJSON…)
+ * @param {object} [props.mapProps] lo demás de MapContainer de react-leaflet (scrollWheelZoom, minZoom…)
+ */
+export default function MapView({ markers, selectedId, onSelect, ariaLabel, height, tileLayer, renderPopup, onMapClick, children, mapProps, }: {
+    markers: Array<{
+        id: string;
+        position: [number, number];
+        title: string;
+        description?: string;
+        tone?: string;
+    } & Record<string, any>>;
+    selectedId?: string | null;
+    onSelect?: (markerId: string) => void;
+    ariaLabel: string;
+    height?: number;
+    tileLayer?: {
+        url: string;
+        attribution: string;
+    };
+    renderPopup?: (marker: any) => import('react').ReactNode;
+    onMapClick?: (position: [number, number]) => void;
+    children?: import('react').ReactNode;
+    mapProps?: object;
+}): import("react").JSX.Element;

package/dist/types/maps/mapMarkers.d.ts

@@ -0,0 +1,23 @@
+/** El alfiler: su tamaño normal y el del elegido (px). */
+export declare const MAP_PIN_SIZE: Readonly<{
+    normal: 32;
+    selected: 44;
+}>;
+/**
+ * El HTML del alfiler para un divIcon de Leaflet: la gota del color pedido con un punto blanco al centro. El color va en
+ * style y no en el atributo fill: así acepta las variables CSS del tema (var(--mui-palette-…)) en todos los navegadores.
+ *
+ * @param {string} color cualquier color de CSS (también var(--mui-palette-…))
+ * @param {boolean} [isSelected]
+ * @returns {string}
+ */
+export declare function mapPinHtmlOf(color: string, isSelected?: boolean): string;
+/**
+ * El recuadro que encierra a todos los marcadores ([[sur, oeste], [norte, este]]), para acomodar el mapa; null sin marcadores.
+ *
+ * @param {Array<{position: [number, number]}>} markers
+ * @returns {[[number, number], [number, number]]|null}
+ */
+export declare function boundsOfMarkers(markers: Array<{
+    position: [number, number];
+}>): [[number, number], [number, number]] | null;

package/dist/types/maps.d.ts

@@ -0,0 +1,2 @@
+export { OPEN_STREET_MAP_TILES, default as MapView } from './maps/MapView.js';
+export { MAP_PIN_SIZE, boundsOfMarkers, mapPinHtmlOf } from './maps/mapMarkers.js';

package/dist/types/money/money.d.ts

@@ -0,0 +1,203 @@
+/** Cómo se redondea al centavo lo que no cabe en centavos (al multiplicar, dividir, elevar o sacar raíz). */
+export declare const MONEY_ROUNDING: Readonly<{
+    halfUp: "halfUp";
+    halfEven: "halfEven";
+    down: "down";
+}>;
+export declare class Money {
+    #private;
+    /**
+     * Centavos (la unidad menor de la moneda): 1050 son $10.50.
+     *
+     * @readonly
+     * @type {number}
+     */
+    readonly minorUnits: number;
+    /**
+     * Código ISO 4217 de la moneda.
+     *
+     * @readonly
+     * @type {string}
+     */
+    readonly currency: string;
+    /**
+     * Cuántos decimales lleva.
+     *
+     * @readonly
+     * @type {number}
+     */
+    readonly decimals: number;
+    /**
+     * No se usa directo: los montos se arman con Money.fromString, Money.fromNumber, Money.fromMinorUnits o Money.zero.
+     *
+     * @param {number} minorUnits centavos (la unidad menor de la moneda), entero
+     * @param {string} currency código ISO 4217
+     * @param {number} decimals cuántos decimales lleva
+     */
+    constructor(minorUnits: number, currency: string, decimals: number);
+    /**
+     * Cero, para arrancar una suma.
+     *
+     * @param {object} [options]
+     * @param {string} [options.currency] código ISO 4217; por omisión, la del proveedor
+     * @param {number} [options.decimals] por omisión, los de la moneda
+     * @returns {Money}
+     */
+    static zero(options?: {
+        currency?: string;
+        decimals?: number;
+    }): Money;
+    /**
+     * Un monto a partir del texto que manda el API o la base ('1234.50', '-3', '0.5').
+     *
+     * @param {string} text un número simple: sin comas, espacios, símbolo ni exponente
+     * @param {object} [options]
+     * @param {string} [options.currency] código ISO 4217; por omisión, la del proveedor
+     * @param {number} [options.decimals] por omisión, los de la moneda
+     * @returns {Money}
+     */
+    static fromString(text: string, options?: {
+        currency?: string;
+        decimals?: number;
+    }): Money;
+    /**
+     * Un monto a partir de un número del JSON del API (2450.5). Lo que trae decimales de más (lo que deja hacer cuentas
+     * con decimales, como 0.30000000000000004) truena igual que en fromString.
+     *
+     * @param {number} value
+     * @param {object} [options]
+     * @param {string} [options.currency] código ISO 4217; por omisión, la del proveedor
+     * @param {number} [options.decimals] por omisión, los de la moneda
+     * @returns {Money}
+     */
+    static fromNumber(value: number, options?: {
+        currency?: string;
+        decimals?: number;
+    }): Money;
+    /**
+     * Un monto a partir de sus centavos enteros (1050 son $10.50).
+     *
+     * @param {number} minorUnits
+     * @param {object} [options]
+     * @param {string} [options.currency] código ISO 4217; por omisión, la del proveedor
+     * @param {number} [options.decimals] por omisión, los de la moneda
+     * @returns {Money}
+     */
+    static fromMinorUnits(minorUnits: number, options?: {
+        currency?: string;
+        decimals?: number;
+    }): Money;
+    /**
+     * Este monto más otro.
+     *
+     * @param {Money} other
+     * @returns {Money}
+     */
+    plus(other: Money): Money;
+    /**
+     * Este monto menos otro.
+     *
+     * @param {Money} other
+     * @returns {Money}
+     */
+    minus(other: Money): Money;
+    /**
+     * Este monto por un factor (1.16 para el IVA, 3 piezas, '0.5'), redondeado al centavo.
+     *
+     * @param {number|string} factor un número simple; mejor en texto si viene de una tasa ('0.16')
+     * @param {object} [options]
+     * @param {string} [options.rounding] uno de MONEY_ROUNDING; por omisión halfUp
+     * @returns {Money}
+     */
+    times(factor: number | string, { rounding }?: {
+        rounding?: string;
+    }): Money;
+    /**
+     * Este monto entre un divisor (3 pagos, '1.16' para quitar el IVA), redondeado al centavo.
+     *
+     * OJO: tres pagos de un tercio redondeado no siempre suman el total (10.00 / 3 = 3.33 y 3 × 3.33 = 9.99). Si las
+     * partes tienen que sumar el total exacto, la última se calcula restando las demás.
+     *
+     * @param {number|string} divisor un número simple, distinto de cero
+     * @param {object} [options]
+     * @param {string} [options.rounding] uno de MONEY_ROUNDING; por omisión halfUp
+     * @returns {Money}
+     */
+    dividedBy(divisor: number | string, { rounding }?: {
+        rounding?: string;
+    }): Money;
+    /**
+     * Este monto elevado a una potencia entera, redondeado al centavo: (1.05)² = 1.1025 → 1.10.
+     *
+     * @param {number} exponent entero de 0 en adelante
+     * @param {object} [options]
+     * @param {string} [options.rounding] uno de MONEY_ROUNDING; por omisión halfUp
+     * @returns {Money}
+     */
+    pow(exponent: number, { rounding }?: {
+        rounding?: string;
+    }): Money;
+    /**
+     * La raíz cuadrada de este monto, redondeada al centavo: √2.00 = 1.414… → 1.41.
+     *
+     * @param {object} [options]
+     * @param {string} [options.rounding] uno de MONEY_ROUNDING; por omisión halfUp (en una raíz nunca cae justo en la
+     *     mitad, así que halfEven da lo mismo)
+     * @returns {Money}
+     */
+    sqrt({ rounding }?: {
+        rounding?: string;
+    }): Money;
+    /**
+     * Si los dos montos valen exactamente lo mismo, hasta el centavo.
+     *
+     * @param {Money} other
+     * @returns {boolean}
+     */
+    equals(other: Money): boolean;
+    /**
+     * Si este monto es mayor que otro. El centavo de diferencia cuenta.
+     *
+     * @param {Money} other
+     * @returns {boolean}
+     */
+    isGreaterThan(other: Money): boolean;
+    /**
+     * Si el monto es cero o negativo.
+     *
+     * @returns {boolean}
+     */
+    isZeroOrLess(): boolean;
+    /**
+     * El monto como texto, con todos sus decimales: '1234.50'. Es lo que se le manda al API para una columna NUMERIC.
+     *
+     * @returns {string}
+     */
+    amount(): string;
+    /**
+     * El monto como lo lee una persona, en el idioma del proveedor y con el símbolo de su moneda: $1,234.50 (es) o
+     * $1,234.50 (en); US$ o ¥ según la moneda. Sin pasar por decimales: Intl recibe el texto exacto.
+     *
+     * @returns {string}
+     */
+    format(): string;
+    /**
+     * Para que JSON.stringify mande el texto del monto ('1234.50') y no un objeto.
+     *
+     * @returns {string}
+     */
+    toJSON(): string;
+    /**
+     * Para que un texto con el monto adentro (`${total}`) diga '1234.50'.
+     *
+     * @returns {string}
+     */
+    toString(): string;
+    /**
+     * Truena a propósito: `total + iva` o `total > limit` regresarían a los números con decimales sin que nadie se dé
+     * cuenta. Se usa plus, minus, isGreaterThan...
+     *
+     * @returns {never}
+     */
+    valueOf(): never;
+}

package/dist/types/money.d.ts

@@ -0,0 +1 @@
+export { MONEY_ROUNDING, Money } from './money/money.js';

package/dist/types/navigation/appMenu.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Las entradas del menú que le tocan a esta sesión, ordenadas.
+ *
+ * @param {Record<string, any>|any[]} menuModules lo que regresa import.meta.glob(..., {eager: true}) o una lista
+ * @param {object} [options]
+ * @param {(access: object|undefined) => boolean} [options.canAccess] la regla de permisos del proyecto; sin ella, todos
+ * @param {object} [options.context] lo que reciben buildMenuItem(s): la sesión, la configuración…
+ * @returns {object[]} las entradas, cada una con to y su texto
+ */
+export declare function composeMenu(menuModules: Record<string, any> | any[], { canAccess, context }?: {
+    canAccess?: (access: object | undefined) => boolean;
+    context?: object;
+}): object[];
+/**
+ * Las entradas que llevan a una pantalla, con las de los submenús (las de arriba primero).
+ *
+ * @param {object[]} menuItems lo que regresa composeMenu
+ * @returns {object[]}
+ */
+export declare function screenMenuItemsOf(menuItems: object[]): object[];
+/**
+ * La entrada del menú de la pantalla abierta: la más específica gana (/orders/15 marca «Pedidos», no «Inicio»).
+ *
+ * @param {Array<{to: string, matchPrefix?: string}>} menuItems lo que regresa composeMenu
+ * @param {string} pathname location.pathname
+ * @returns {object|null}
+ */
+export declare function activeMenuItemOf(menuItems: Array<{
+    to: string;
+    matchPrefix?: string;
+}>, pathname: string): object | null;
+/**
+ * El submenú que contiene a una entrada (para abrirlo y para las migas); null si la entrada está arriba.
+ *
+ * @param {object[]} menuItems lo que regresa composeMenu
+ * @param {object|null} menuItem
+ * @returns {object|null}
+ */
+export declare function parentMenuItemOf(menuItems: object[], menuItem: object | null): object | null;
+/**
+ * Las migas de la pantalla abierta, sacadas del menú: el inicio, el submenú (si lo hay) y la entrada activa.
+ * En el inicio, o en una pantalla que no está en el menú, regresa solo lo que encuentra (una o ninguna).
+ *
+ * @param {object[]} menuItems lo que regresa composeMenu
+ * @param {string} pathname location.pathname
+ * @returns {object[]} entradas del menú, en orden
+ */
+export declare function menuBreadcrumbsOf(menuItems: object[], pathname: string): object[];
+/**
+ * El badge de una entrada del menú: el conteo que llegó del servidor por su badgeKey (lo pendiente de esa pantalla), la
+ * suma de sus hijas si es un submenú (como las carpetas del iPhone), o el badge fijo de su menu.js («Nuevo»). Un conteo
+ * en cero no se enseña: no hay nada pendiente.
+ *
+ *   menuBadgeOf({badgeKey: 'pendingPayment'}, {pendingPayment: 13})   // {content: 13, isCount: true}
+ *
+ * @param {object} menuItem una entrada de composeMenu
+ * @param {Record<string, number>} [menuBadges] los conteos por badgeKey (el proyecto los pide a su servidor)
+ * @returns {{content: number|string, isCount: boolean}|null}
+ */
+export declare function menuBadgeOf(menuItem: object, menuBadges?: Record<string, number>): {
+    content: number | string;
+    isCount: boolean;
+} | null;
+/** Cuántas puede fijar la persona en la barra: las que caben junto a «Más». */
+export declare const PINNABLE_TAB_LIMIT: number;
+/**
+ * Con qué se reconoce una entrada del menú para recordarla (las pestañas que fijó la persona): su ruta, o su llave de
+ * texto si no navega. No el texto traducido: cambia con el idioma.
+ *
+ * @param {{to?: string, labelKey?: string, label?: string}} menuItem
+ * @returns {string}
+ */
+export declare function menuItemKeyOf(menuItem: {
+    to?: string;
+    labelKey?: string;
+    label?: string;
+}): string;
+/**
+ * Las pestañas de la barra del teléfono y lo que va en «Más». Van las que fijó la persona (pinnedKeys, en el orden del
+ * menú); si no fijó ninguna, las que el menu.js marca con mobileTab: true; si ninguna lo dice, las primeras. Si todas
+ * las entradas caben (tabLimit), van todas y no hay «Más»; si no, tabLimit - 1 y «Más» con el resto.
+ *
+ * @param {object[]} menuItems lo que regresa composeMenu
+ * @param {string[]|null} [pinnedKeys] las que eligió la persona (menuItemKeyOf); las que ya no existen o ya no puede ver
+ *     no cuentan
+ * @param {number} [tabLimit] cuántas caben en la barra contando «Más» (por omisión 5; la barra mide su ancho)
+ * @returns {{tabs: object[], more: object[]}}
+ */
+export declare function mobileTabsOf(menuItems: object[], pinnedKeys?: string[] | null, tabLimit?: number): {
+    tabs: object[];
+    more: object[];
+};

package/dist/types/navigation/useMenuBadges.d.ts

@@ -0,0 +1,16 @@
+/**
+ * La respuesta del servidor como {badgeKey: conteo}.
+ *
+ * @param {unknown} response
+ * @returns {Record<string, number>}
+ */
+export declare function menuBadgesFrom(response: unknown): Record<string, number>;
+/**
+ * @param {() => Promise<unknown>} loadBadges pide los conteos al servidor
+ * @returns {{menuBadges: Record<string, number>, refreshMenuBadges: () => Promise<void>, isLoading: boolean}}
+ */
+export declare function useMenuBadges(loadBadges: () => Promise<unknown>): {
+    menuBadges: Record<string, number>;
+    refreshMenuBadges: () => Promise<void>;
+    isLoading: boolean;
+};

package/dist/types/navigation.d.ts

@@ -0,0 +1,22 @@
+export declare const REDIRECT_PARAM = "redirect";
+/**
+ * La ruta si es interna y segura; null si no.
+ *
+ * @param {string|null|undefined} candidatePath
+ * @returns {string|null}
+ */
+export declare function safeInternalPath(candidatePath: string | null | undefined): string | null;
+/**
+ * Lee el destino de ?redirect= ya validado.
+ *
+ * @param {string} search location.search
+ * @returns {string|null}
+ */
+export declare function readRedirectParam(search: string): string | null;
+/**
+ * Arma "/iniciar-sesion?redirect=<destino>" (sin parámetro si el destino no es seguro o es la misma entrada).
+ *
+ * @param {string} entryPath p. ej. '/iniciar-sesion'
+ * @param {string} targetPath ruta que se intentó abrir
+ */
+export declare function withRedirect(entryPath: string, targetPath: string): string;

package/dist/types/navigationTrail.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Posición de la página actual en el historial de esta pestaña: 0 es la primera página de la app.
+ *
+ * @returns {number}
+ */
+export declare function currentHistoryIndex(): number;
+/**
+ * Anota el nombre de regreso de la página que está en esa posición del historial.
+ *
+ * @param {number} index posición en el historial (currentHistoryIndex)
+ * @param {{labelKey: string, params?: object}} pageName llave de i18n con su espacio, p. ej. 'upload-control:detail.backToList'
+ * @param {Storage|null} [storage] el de la pestaña; las pruebas pasan uno de mentiras
+ */
+export declare function rememberPageName(index: number, pageName: {
+    labelKey: string;
+    params?: object;
+}, storage?: Storage | null): void;
+/**
+ * Borra el nombre de esa posición (y los de las posteriores): una página nueva la ocupa.
+ *
+ * @param {number} index
+ * @param {Storage|null} [storage]
+ */
+export declare function forgetPageName(index: number, storage?: Storage | null): void;
+/**
+ * El nombre de regreso anotado en esa posición; null si la página no anotó ninguno.
+ *
+ * @param {number} index
+ * @param {Storage|null} [storage]
+ * @returns {{labelKey: string, params: object}|null}
+ */
+export declare function pageNameAt(index: number, storage?: Storage | null): {
+    labelKey: string;
+    params: object;
+} | null;
+/**
+ * Se monta UNA vez en el layout de la aplicación: cuando cambia la página (otra posición u otra ruta), borra el nombre que tenía esa posición
+ * antes de que la página nueva anote el suyo. Cambiar solo los parámetros de la URL en la misma posición (una pestaña,
+ * un filtro) no cuenta como otra página.
+ */
+export declare function useNavigationTrail(): void;
+/**
+ * Se monta en una página: anota cómo se llama para el botón «Regresar» de la página que sigue. Mientras sus datos no
+ * llegan (labelKey null) no anota nada.
+ *
+ * @param {string|null} labelKey llave de i18n con su espacio, p. ej. 'upload-control:detail.backToList'
+ * @param {object} [params] valores de la llave, ya listos para pintarse
+ */
+export declare function usePageName(labelKey: string | null, params?: object): void;

package/dist/types/next.d.ts

@@ -0,0 +1 @@
+export { nextNavigation } from './adapters/nextNavigation.js';

package/dist/types/observability/buildWatch.d.ts

@@ -0,0 +1,28 @@
+/** Lo que toca hacer al ver la versión publicada. */
+export declare const BUILD_WATCH_ACTION: Readonly<{
+    none: "none";
+    notice: "notice";
+    reload: "reload";
+}>;
+/**
+ * @param {object} watch
+ * @param {string|null|undefined} watch.runningBuildId la versión de esta pestaña (buildId de ToolkitProvider)
+ * @param {string|null|undefined} watch.publishedBuildId la que está publicada
+ * @param {number} [watch.hiddenMilliseconds] cuánto estuvo la app en segundo plano antes de esta revisión (0: no estuvo)
+ * @param {number|null} [watch.reloadAfterHiddenMilliseconds] desde cuánto tiempo fuera se recarga sola; null: nunca
+ *     (solo el aviso)
+ * @returns {string} un valor de BUILD_WATCH_ACTION
+ */
+export declare function buildWatchActionOf({ runningBuildId, publishedBuildId, hiddenMilliseconds, reloadAfterHiddenMilliseconds }: {
+    runningBuildId: string | null | undefined;
+    publishedBuildId: string | null | undefined;
+    hiddenMilliseconds?: number;
+    reloadAfterHiddenMilliseconds?: number | null;
+}): string;
+/**
+ * La versión publicada que viene en el archivo de versión ({"buildId": "…"}); null si el archivo no la trae.
+ *
+ * @param {unknown} versionFile lo que se leyó del archivo (JSON ya convertido)
+ * @returns {string|null}
+ */
+export declare function publishedBuildIdOf(versionFile: unknown): string | null;

package/dist/types/observability/logger.d.ts

@@ -0,0 +1,19 @@
+/**
+ * El nivel de lo que sale en consola: 'error', 'warn', 'info' o 'debug'. Lo llama la aplicación al arrancar, por ejemplo
+ * setLogLevel(import.meta.env.DEV ? 'debug' : 'warn').
+ *
+ * @param {'error'|'warn'|'info'|'debug'} level
+ * @returns {void}
+ */
+export declare function setLogLevel(level: 'error' | 'warn' | 'info' | 'debug'): void;
+/**
+ * Logger que antepone [namespace] a cada mensaje.
+ *
+ * @param {string} namespace p. ej. 'api', 'session'
+ */
+export declare function createLogger(namespace: string): {
+    error: (message: any, context: any) => void;
+    warn: (message: any, context: any) => void;
+    info: (message: any, context: any) => void;
+    debug: (message: any, context: any) => void;
+};

package/dist/types/observability/publishedBuild.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Si el servidor publica una compilación distinta a la que corre en la pestaña.
+ *
+ * @param {string|null|undefined} runningBuildId compilación de esta pestaña; vacía en desarrollo
+ * @param {string|null|undefined} publishedBuildId compilación que anuncia el servidor; vacía si la respuesta no la trae
+ * @returns {boolean} false si falta cualquiera de los dos: sin los dos no hay nada que comparar
+ */
+export declare function isAnotherBuild(runningBuildId: string | null | undefined, publishedBuildId: string | null | undefined): boolean;
+/**
+ * Recibe la compilación que anunció una respuesta del servidor y prende el aviso si ya no es la de la pestaña.
+ *
+ * @param {string|null|undefined} publishedBuildId la que anunció la respuesta
+ * @param {string|null|undefined} [runningBuildId] la de esta pestaña; por omisión, el buildId de ToolkitProvider
+ * @returns {void}
+ */
+export declare function reportPublishedBuild(publishedBuildId: string | null | undefined, runningBuildId?: string | null | undefined): void;
+/**
+ * Si ya se supo que hay una compilación nueva publicada.
+ *
+ * @returns {boolean}
+ */
+export declare function isNewBuildPublished(): boolean;
+/**
+ * Avisa a quien se suscriba cuando el aviso se prende (contrato de useSyncExternalStore).
+ *
+ * @param {() => void} listener función que se llama al prenderse
+ * @returns {() => void} función para dejar de escuchar
+ */
+export declare function subscribeToNewBuild(listener: () => void): () => void;
+/**
+ * Para un componente: si hay una compilación nueva publicada. El componente se vuelve a pintar cuando el aviso se prende.
+ *
+ * @returns {boolean}
+ */
+export declare function useNewBuildPublished(): boolean;

package/dist/types/observability/usePublishedBuildWatch.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @param {object} [options]
+ * @param {string|null} [options.url] dónde está el archivo de versión ({"buildId": "…"}); null: no vigila
+ * @param {string} [options.buildId] la versión de esta pestaña; por omisión el buildId de ToolkitProvider (ver el OJO)
+ * @param {number} [options.checkEveryMinutes] cada cuánto revisa mientras se usa; por omisión 5
+ * @param {number|null} [options.reloadAfterHiddenMinutes] desde cuántos minutos fuera se recarga sola al volver; por
+ *     omisión 15. null: nunca se recarga sola, siempre el aviso
+ * @param {() => void} [options.onReload] cómo recargar (p. ej. guardar un borrador antes). OJO: con useCallback; una
+ *     función nueva en cada pintada volvería a armar la vigilancia
+ * @returns {void}
+ */
+export declare function usePublishedBuildWatch({ url, buildId, checkEveryMinutes, reloadAfterHiddenMinutes, onReload, }?: {
+    url?: string | null;
+    buildId?: string;
+    checkEveryMinutes?: number;
+    reloadAfterHiddenMinutes?: number | null;
+    onReload?: () => void;
+}): void;

package/dist/types/passkeys.d.ts

@@ -0,0 +1 @@
+export { createPasskey, passkeysSupported, signWithPasskey } from './security/passkeys.js';

package/dist/types/periodRanges.d.ts

@@ -0,0 +1,32 @@
+export type PeriodOption = {
+    value: string;
+    disabled: boolean;
+};
+/**
+ * Las opciones de «hasta» para un «desde»: apagadas las de antes de «desde» y todas desde la primera apagada después de
+ * él (un rango no salta un periodo roto).
+ *
+ * @param {PeriodOption[]} options en orden
+ * @param {string|null|undefined} from el «desde» elegido; sin él, las opciones tal cual
+ * @returns {PeriodOption[]} las mismas opciones, con disabled donde no se puede terminar el rango
+ */
+export declare function rangeEndOptionsOf(options: PeriodOption[], from: string | null | undefined): PeriodOption[];
+/**
+ * Si un rango se puede pedir.
+ *
+ * @param {PeriodOption[]} options en orden
+ * @param {string|null|undefined} from
+ * @param {string|null|undefined} to
+ * @returns {boolean} true si los dos extremos existen, se pueden elegir, van en orden y no hay nada apagado en medio
+ */
+export declare function periodRangeIsValid(options: PeriodOption[], from: string | null | undefined, to: string | null | undefined): boolean;
+/**
+ * El «hasta» que queda al cambiar «desde»: el mismo si el rango sigue valiendo; si no, el propio «desde» (un rango de un
+ * solo periodo siempre vale).
+ *
+ * @param {PeriodOption[]} options en orden
+ * @param {string} from el «desde» nuevo
+ * @param {string|null|undefined} to el «hasta» que había
+ * @returns {string} el «hasta» que se queda
+ */
+export declare function rangeEndAfterStartChange(options: PeriodOption[], from: string, to: string | null | undefined): string;

package/dist/types/problems.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Título del problema en el idioma activo.
+ *
+ * @param {object|null} problem cuerpo RFC 9457 (puede faltar)
+ * @param {number} status status HTTP; 0 si no hubo respuesta
+ * @param {{translatedByServer?: boolean}} [options] false cuando el idioma de la respuesta no es el pedido
+ * @returns {string}
+ */
+export declare function problemTitle(problem: object | null, status: number, { translatedByServer }?: {
+    translatedByServer?: boolean;
+}): string;
+/**
+ * Mensaje principal (detail) del problema en el idioma activo.
+ *
+ * @param {object|null} problem cuerpo RFC 9457 (puede faltar)
+ * @param {number} status status HTTP; 0 si no hubo respuesta
+ * @param {{translatedByServer?: boolean}} [options] false cuando el idioma de la respuesta no es el pedido
+ * @returns {string}
+ */
+export declare function problemMessage(problem: object | null, status: number, { translatedByServer }?: {
+    translatedByServer?: boolean;
+}): string;
+/**
+ * Errores por campo de un 422 de Laravel: {campo: ['mensaje', ...]}, ya traducidos por el backend.
+ * Un campo anidado ("rows.3.email") se reduce a su último segmento que no es número, porque el formulario
+ * conoce el campo y no la ruta.
+ *
+ * @param {object|null} problem cuerpo RFC 9457
+ * @returns {Record<string, string[]>}
+ */
+export declare function fieldErrorsOf(problem: object | null): Record<string, string[]>;

package/dist/types/pwa/InstallAppSetting.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @param {object} [props]
+ * @param {object} [props.texts] los textos que cambian, con la forma de `common` en los textos del paquete
+ */
+export default function InstallAppSetting({ texts }?: {
+    texts?: object;
+}): import("react").JSX.Element | null;

package/dist/types/pwa/InstallInstructionsDialog.d.ts

@@ -0,0 +1,20 @@
+/**
+ * ¿Esta variante se instala con pasos a mano (y no con el diálogo del navegador)?
+ *
+ * @param {string|null} variant
+ * @returns {boolean}
+ */
+export declare function variantHasInstructions(variant: string | null): boolean;
+/**
+ * @param {object} props
+ * @param {string|null} props.variant una de INSTALL_VARIANT (useInstallPrompt)
+ * @param {boolean} props.open
+ * @param {() => void} props.onClose
+ * @param {object} [props.texts] los textos que cambian, con la forma de `common` en los textos del paquete
+ */
+export default function InstallInstructionsDialog({ variant, open, onClose, texts }: {
+    variant: string | null;
+    open: boolean;
+    onClose: () => void;
+    texts?: object;
+}): import("react").JSX.Element | null;