@stackcraftmx/calcita 0.0.0-stage → 0.23.0

package/dist/types/theme/glassSurface.d.ts

@@ -0,0 +1,247 @@
+/** Qué tan opaca es la superficie (0 a 1). */
+export declare const GLASS_OPACITY = 0.6;
+/** Las esquinas de lo que flota grande (menú lateral, barra, diálogos): renglones de 12 px a 8 px del borde. */
+export declare const GLASS_PANEL_RADIUS_PIXELS = 20;
+/** Las esquinas de los menús y ventanitas: renglones de 8 px a 4 px del borde. */
+export declare const GLASS_MENU_RADIUS_PIXELS = 12;
+/**
+ * Lo que se separa de la orilla de la ventana lo que flota (la barra, el menú lateral, los cajones y la hoja de abajo):
+ * Apple lo pide para que el contenido se asome por detrás («half sheets are inset from the edge of the display to allow
+ * content to peek through from beneath them», Adopting Liquid Glass).
+ */
+export declare const GLASS_INSET_PIXELS = 8;
+/**
+ * El lente de cada tamaño (ver lensRulesOf), medido en capturas de Chrome: el control chico (botón, chip) más claro y con
+ * la orilla más marcada; el panel (barra, menú, diálogo) más grueso, porque lleva texto («Liquid Glass appears more opaque
+ * in larger elements like sidebars to preserve legibility», HIG «Color»). edgeFraction y scale van en fracción del tamaño
+ * del vidrio; clearerBy es cuánto menos tinte lleva que el esmerilado.
+ */
+export declare const GLASS_LENS: Readonly<{
+    control: {
+        filterId: string;
+        edgeFraction: number;
+        scale: number;
+        blurPixels: number;
+        clearerBy: number;
+    };
+    panel: {
+        filterId: string;
+        edgeFraction: number;
+        scale: number;
+        blurPixels: number;
+        clearerBy: number;
+    };
+}>;
+/** La marca que GlassLensFilter pone en <body> cuando el navegador sí pinta el lente. */
+export declare const GLASS_LENS_FLAG_SELECTOR = "body[data-glass-lens=\"on\"]";
+/**
+ * El selector de «este control está dentro de una tarjeta» (cualquier Paper: tarjeta, diálogo, menú), donde el control ya
+ * no es vidrio. Va en dos versiones, sin y con la marca del lente: la regla del lente (una etiqueta y dos clases) le ganaba
+ * a la de la tarjeta (dos clases) y los botones dentro de una tarjeta volvían a ser vidrio. Medido en Chrome.
+ *
+ * @param {string} [suffix] lo que va pegado al control (p. ej. ':not(.MuiButtonGroup-grouped)')
+ * @returns {string}
+ */
+export declare function insideContentSelectorOf(suffix?: string): string;
+/**
+ * Si el tema trae el vidrio prendido (createToolkitTheme({glass: …})). Lo usan los componentes del framework que flotan
+ * (el marco, el panel de descargas, los avisos) y lo puede usar el proyecto para lo suyo.
+ *
+ * @param {object} theme el tema de MUI
+ * @returns {boolean}
+ */
+export declare function isGlassTheme(theme: object): boolean;
+/**
+ * La opacidad del vidrio del tema: la que pidió el proyecto o GLASS_OPACITY.
+ *
+ * @param {object} theme
+ * @returns {number}
+ */
+export declare function glassOpacityOf(theme: object): number;
+/**
+ * El estilo de una superficie de vidrio sobre un color.
+ *
+ * @param {string} solidColor el color sólido de la superficie (p. ej. palette.background.paper o primary.main)
+ * @param {object} [options]
+ * @param {number} [options.opacity] por omisión GLASS_OPACITY
+ * @param {boolean} [options.isDark] en oscuro el vidrio se aclara un poco y su filo brilla más
+ * @param {boolean} [options.isControl] un control chico (botón, chip): sombra corta en vez de la de un panel
+ * @returns {object} estilos para styleOverrides o sx
+ */
+export declare function glassSurfaceOf(solidColor: string, { opacity, isDark, isControl }?: {
+    opacity?: number;
+    isDark?: boolean;
+    isControl?: boolean;
+}): object;
+/**
+ * Lo que se pinta en lugar del vidrio si la persona pidió menos transparencia o más contraste, o si el navegador no sabe
+ * desenfocar. Para lo transparente que no es una superficie (el fondo oscuro detrás de un diálogo, la perilla del
+ * deslizador al arrastrarla).
+ *
+ * @param {object} solidStyle los estilos sólidos
+ * @returns {object}
+ */
+export declare function solidFallbackOf(solidStyle: object): object;
+/**
+ * El vidrio sobre un color del tema en claro y en oscuro, con la opacidad del tema. Es lo que usan los ajustes de
+ * componentes, y lo que usa el proyecto para algo suyo que flote:
+ *   sx={(theme) => glassStylesOf(theme)}                                          // sobre el color de las tarjetas
+ *   sx={(theme) => glassStylesOf(theme, {color: paletteOf(theme).primary.main})}  // vidrio del color principal
+ *
+ * @param {object} theme el tema de MUI
+ * @param {object} [options]
+ * @param {string} [options.color] el color de la superficie; por omisión el de las tarjetas (background.paper)
+ * @param {string} [options.darkColor] el de modo oscuro, si es otro; por omisión el mismo
+ * @param {number} [options.opacity] por omisión la del tema
+ * @param {boolean} [options.isControl] un control chico (botón, chip): sombra corta en vez de la de un panel
+ * @returns {object}
+ */
+export declare function glassStylesOf(theme: object, { color, darkColor, opacity, isControl }?: {
+    color?: string;
+    darkColor?: string;
+    opacity?: number;
+    isControl?: boolean;
+}): object;
+/**
+ * El mapa de desplazamiento del lente (una imagen SVG): rojo para lo de lado y verde para lo de arriba abajo; 128 en medio
+ * es «no mover». En la orilla de la izquierda y la de arriba vale más (toma de adentro) y en la de la derecha y la de
+ * abajo, menos (también de adentro): así la orilla dobla lo de atrás hacia el centro, como una lente convexa, y nunca toma
+ * de afuera del vidrio (afuera no hay imagen y la orilla se quedaba en blanco).
+ *
+ * @param {number} edgeFraction lo ancho de la orilla que dobla (0 a 0.5 del tamaño del vidrio)
+ * @returns {string} data URI para el feImage del filtro
+ */
+export declare function lensDisplacementMapOf(edgeFraction: number): string;
+/**
+ * El material del contenido sobre un color: esmerilado como el vidrio pero sin el brillo del borde, y más transparente.
+ *
+ * @param {string} solidColor
+ * @param {object} [options]
+ * @param {number} [options.opacity] la del vidrio; el material le suma MATERIAL_OPACITY_OFFSET de su modo (le resta)
+ * @param {boolean} [options.isDark]
+ * @returns {object}
+ */
+export declare function materialSurfaceOf(solidColor: string, { opacity, isDark }?: {
+    opacity?: number;
+    isDark?: boolean;
+}): object;
+/**
+ * El material del contenido en claro y en oscuro (las tarjetas con glass: {surfaces: true}). Para algo del proyecto que va
+ * en el contenido: sx={(theme) => materialStylesOf(theme)}.
+ *
+ * @param {object} theme
+ * @param {object} [options]
+ * @param {string} [options.color] por omisión el de las tarjetas (background.paper)
+ * @param {string} [options.darkColor] por omisión el mismo
+ * @returns {object}
+ */
+export declare function materialStylesOf(theme: object, { color, darkColor }?: {
+    color?: string;
+    darkColor?: string;
+}): object;
+/**
+ * Solo el fondo del material, sin su línea ni su sombra: para lo que va DENTRO de una tarjeta y debe tapar lo que pasa por
+ * debajo sin verse como un parche sólido (la columna pegada de la tabla al deslizarla de lado). Va como capa
+ * (background-image) y no como color: así el color propio del elemento (el del renglón: la cebra, el cursor encima) se
+ * sigue pintando encima.
+ *
+ * Con {thick: true}, el material «grueso» de Apple (HIG «Materials»: los gruesos son para leer sobre otro contenido): el
+ * mismo desenfoque al 92 %. Es el de la columna fija de una tabla: con el delgado de la tarjeta (45 a 55 %) se veían pasar
+ * por detrás las otras columnas (lo reportaron).
+ *
+ * @param {object} theme
+ * @param {object} [options]
+ * @param {boolean} [options.thick] el material grueso, para tapar lo que pasa por debajo
+ * @returns {object}
+ */
+export declare function materialBackgroundOf(theme: object, { thick }?: {
+    thick?: boolean;
+}): object;
+/**
+ * La «gota» que marca lo elegido dentro de un control (la pestaña, la opción, el renglón del menú lateral): en claro, una
+ * pastilla blanca con su brillo y su sombra; en oscuro, un relleno gris parejo, como el renglón elegido de las barras
+ * laterales de Apple en oscuro. No es transparente del todo: va DENTRO de algo que ya puede ser de vidrio (un menú), y
+ * vidrio sobre vidrio no se lee.
+ * OJO, oscuro: con blanco al 14 % casi no se veía, y su línea de luz arriba dibujaba un arco raro en la esquina («no se
+ * nota la selección», «se ve raro»; lo reportaron). Va al 18 % y sin línea.
+ *
+ * @param {object} theme
+ * @returns {object}
+ */
+export declare function glassDropOf(theme: object): object;
+/**
+ * El relleno de un control lleno de color (el botón principal, la etiqueta elegida) para llevar letra BLANCA y que se lea:
+ * el color del tema oscurecido lo justo para llegar a 4.5 : 1 (WCAG). En oscuro la paleta trae letra negra sobre el
+ * naranja («El suyo», «Guardar»: se veía feo, lo reportaron) y el blanco sobre el naranja tal cual da 2.85 : 1; con el
+ * naranja al 75 % y blanco da 4.79 : 1. Se calcula con el color que elija el proyecto, no con uno fijo.
+ *
+ * @param {string} rawColor el color en #RRGGBB o #RGB (el de la paleta, no la variable CSS)
+ * @returns {string|null} el relleno en #RRGGBB; null si el color no viene en hexadecimal
+ */
+export declare function whiteLabelFillOf(rawColor: string): string | null;
+/**
+ * El «pozo» de un campo de texto dentro del contenido (una tarjeta, un formulario agrupado), como los de Apple: un relleno
+ * parejo con esquinas de 12 px, del gris de relleno de Apple («tertiary fill»): tenue en claro y más claro que la tarjeta en
+ * oscuro (con negro, en oscuro se perdía). Sin vidrio adentro de la tarjeta: ahí no tiene nada que dejar
+ * ver. Con el cursor encima se marca apenas; antes el relleno salía solo con el cursor y en cuadro («hovers espantosos»).
+ *
+ * @param {object} theme
+ * @returns {object}
+ */
+export declare function fieldWellStylesOf(theme: object): object;
+/**
+ * Un campo de texto suelto sobre el lienzo (fuera de una tarjeta): una lámina de vidrio clara en claro y el gris de relleno
+ * de Apple en oscuro, más claro que el fondo casi negro. Con «Reducir transparencia» se pinta sólido.
+ *
+ * @param {object} theme
+ * @returns {object}
+ */
+export declare function canvasFieldStylesOf(theme: object): object;
+/**
+ * El color de un TEXTO que debe ir del color del tema (una liga, un botón de solo texto, el renglón elegido del menú, el
+ * valor de una fecha): el color de la paleta oscurecido en claro y aclarado en oscuro, para que se lea. Medido (WCAG pide
+ * 4.5 : 1 en letra normal): el naranja de la marca sobre una tarjeta clara daba 2.78 : 1 y sobre su propio tinte en oscuro
+ * 4.41 : 1 (el reporte: «cuesta leer», «se pierde»); con 30 % de negro en claro da 5.24 : 1 y con 30 % de blanco en
+ * oscuro 8.23 : 1. Los botones con relleno de color NO usan esto: van con letra de un solo color (HIG «Buttons»: «Avoid
+ * applying a similar color to button labels and content layer backgrounds»).
+ *
+ * @param {object} theme
+ * @param {string} [colorName] primary, error, success… (por omisión primary)
+ * @returns {object} {color, y el de oscuro}
+ */
+export declare function accentTextStylesOf(theme: object, colorName?: string): object;
+/**
+ * Un fondo FIJO a la ventana que no se mueve al deslizar, también en el iPhone: va en una capa aparte (::before con
+ * position: fixed) detrás del contenido del elemento. Así el vidrio se ve pasar por encima de un fondo quieto.
+ *
+ * OJO: background-attachment: fixed no sirve para esto. Safari del iPhone y del iPad lo ignora y el fondo se movía con
+ * todo (lo vio el autor en el teléfono); además, en escritorio vuelve a pintar todo el fondo en cada paso al deslizar.
+ * La capa va con z-index -1 dentro de un contexto propio (isolation): queda arriba del color del elemento y abajo de su
+ * contenido. Si el elemento es una caja con esquinas (la escena de un ejemplo), clip-path la recorta a la caja.
+ *
+ * @param {object} layerStyles el fondo de la capa (backgroundColor, backgroundImage…; puede llevar el modo oscuro)
+ * @param {object} [options]
+ * @param {string} [options.clipPath] p. ej. 'inset(0 round 20px)' para una caja; sin él, la capa ocupa toda la ventana
+ * @returns {object} estilos para el sx del elemento
+ */
+export declare function fixedBackgroundLayerOf(layerStyles: object, { clipPath }?: {
+    clipPath?: string;
+}): object;
+/**
+ * El fondo del lienzo con vidrio: manchas del color principal y del de información, fijas a la ventana, para
+ * que el vidrio tenga algo que desenfocar. AppLayout ya lo pone; una pantalla fuera del marco (el inicio de sesión) lo usa
+ * con sx={(theme) => ambientBackgroundOf(theme)}.
+ *
+ * @param {object} theme
+ * @returns {object}
+ */
+export declare function ambientBackgroundOf(theme: object): object;
+/**
+ * La orilla de arriba cuando la barra va en cápsulas (TOP_BAR.capsules con vidrio, como las ventanas de macOS Tahoe; Apple le
+ * llama «scroll edge effect»): lo que pasa por debajo se desenfoca y se desvanece hacia el contenido, para que el título
+ * y las cápsulas se lean sobre cualquier cosa. Con «Reducir transparencia» o sin backdrop-filter, el color del lienzo.
+ *
+ * @param {object} theme
+ * @returns {object}
+ */
+export declare function scrollEdgeStylesOf(theme: object): object;

package/dist/types/theme/glassToasterStyles.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Los estilos globales de los avisos de vidrio (para <GlobalStyles styles={…} />).
+ *
+ * @param {object} theme el tema de MUI
+ * @returns {object}
+ */
+export declare function glassToasterStylesOf(theme: object): object;

package/dist/types/theme/mergeComponents.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Suma dos objetos de estilos: con la misma propiedad gana el segundo, lo anidado se suma por dentro y lo del segundo
+ * queda después de lo del primero (en CSS gana lo último).
+ *
+ * @param {object} baseStyle
+ * @param {object} extraStyle
+ * @returns {object}
+ */
+export declare function mergeStyles(baseStyle: object, extraStyle: object): object;
+/**
+ * @param {object} baseComponents
+ * @param {object} extraComponents gana cuando chocan
+ * @returns {object}
+ */
+export declare function mergeComponents(baseComponents: object, extraComponents: object): object;

package/dist/types/theme/stackcraftPalette.d.ts

@@ -0,0 +1,142 @@
+/** Los tokens de la marca, para lo que la paleta de MUI no cubre (un SVG, una insignia decorativa). */
+export declare const STACKCRAFT: Readonly<{
+    forge: "#FF6B1A";
+    ember: "#CC5614";
+    spark: "#FF8A4D";
+    carbon: "#0A0A0A";
+    iron: "#1A1A1A";
+    steel: "#4A4A4A";
+    mist: "#E6E6E6";
+    cloud: "#FAFAFA";
+    slateNavy: "#1E3A8A";
+}>;
+/** La paleta del modo claro. */
+export declare const stackcraftLightPalette: Readonly<{
+    primary: {
+        main: "#FF6B1A";
+        light: "#FF8A4D";
+        dark: "#CC5614";
+        contrastText: "#FAFAFA";
+    };
+    secondary: {
+        main: "#4A4A4A";
+        light: "#E6E6E6";
+        dark: "#1A1A1A";
+        contrastText: "#FAFAFA";
+    };
+    success: {
+        main: string;
+        light: string;
+        dark: string;
+        contrastText: "#FAFAFA";
+    };
+    warning: {
+        main: string;
+        light: string;
+        dark: string;
+        contrastText: "#FAFAFA";
+    };
+    error: {
+        main: string;
+        light: string;
+        dark: string;
+        contrastText: "#FAFAFA";
+    };
+    info: {
+        main: string;
+        light: string;
+        dark: string;
+        contrastText: "#FAFAFA";
+    };
+    grey: Readonly<{
+        50: "#FAFAFA";
+        100: "#E6E6E6";
+        200: "#D6D3D1";
+        300: "#A8A29E";
+        400: "#78716C";
+        500: "#4A4A4A";
+        600: "#3C3C3C";
+        700: "#2A2A2A";
+        800: "#1A1A1A";
+        900: "#0A0A0A";
+    }>;
+    text: {
+        primary: string;
+        secondary: string;
+        disabled: string;
+    };
+    divider: "rgba(26, 26, 26, 0.14)";
+    background: {
+        default: "#FAFAFA";
+        paper: string;
+    };
+    action: {
+        hover: string;
+        selected: string;
+    };
+}>;
+/** La paleta del modo oscuro. */
+export declare const stackcraftDarkPalette: Readonly<{
+    primary: {
+        main: "#FF6B1A";
+        light: "#FF8A4D";
+        dark: "#CC5614";
+        contrastText: "#0A0A0A";
+    };
+    secondary: {
+        main: "#E6E6E6";
+        light: "#FAFAFA";
+        dark: "#4A4A4A";
+        contrastText: "#0A0A0A";
+    };
+    success: {
+        main: string;
+        light: string;
+        dark: string;
+        contrastText: "#0A0A0A";
+    };
+    warning: {
+        main: string;
+        light: string;
+        dark: string;
+        contrastText: "#0A0A0A";
+    };
+    error: {
+        main: string;
+        light: string;
+        dark: string;
+        contrastText: "#0A0A0A";
+    };
+    info: {
+        main: string;
+        light: string;
+        dark: string;
+        contrastText: "#0A0A0A";
+    };
+    grey: Readonly<{
+        50: "#FAFAFA";
+        100: "#E6E6E6";
+        200: "#D6D3D1";
+        300: "#A8A29E";
+        400: "#78716C";
+        500: "#4A4A4A";
+        600: "#3C3C3C";
+        700: "#2A2A2A";
+        800: "#1A1A1A";
+        900: "#0A0A0A";
+    }>;
+    text: {
+        primary: string;
+        secondary: string;
+        disabled: string;
+    };
+    divider: "#4A4A4A";
+    background: {
+        default: "#0A0A0A";
+        paper: "#1A1A1A";
+    };
+    action: {
+        hover: string;
+        selected: string;
+    };
+}>;

package/dist/types/theme/toolkitComponents.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @returns {object} el `components` del tema de MUI
+ */
+export declare function toolkitComponents(): object;

package/dist/types/timeline.d.ts

@@ -0,0 +1,2 @@
+export { default as GroupedTimeline } from './ui/timeline/GroupedTimeline.js';
+export { TIMELINE_EMPHASIS, timelineDotOf } from './ui/timeline/timelineDot.js';

package/dist/types/toolkit/ToolkitProvider.d.ts

@@ -0,0 +1,31 @@
+/**
+ * @param {object} props
+ * @param {string} [props.language] idioma activo: es o en (por omisión es)
+ * @param {(language: string) => void} [props.onLanguageChange] lo llama LanguageToggle; el proyecto cambia su idioma
+ * @param {object} [props.texts] textos propios por idioma, con la forma de locales/ ({es: {table: {...}}})
+ * @param {(namespace: string, key: string, values?: object) => string|undefined} [props.translate] traductor del
+ *     proyecto (por ejemplo i18next); undefined deja el texto del paquete
+ * @param {string} [props.timeZone] zona de las fechas (por omisión la del navegador)
+ * @param {string} [props.currency] moneda de los montos, código ISO 4217 (por omisión MXN)
+ * @param {string} [props.appName] nombre de la aplicación para el título de la pestaña
+ * @param {object} [props.navigation] {useNavigate, useLocation, Link}; por omisión la del navegador
+ * @param {string} [props.buildId] la compilación del front que corre en esta pestaña; con ella NewBuildNotice sabe si el
+ *     servidor ya publicó otra (reportPublishedBuild). Vacía (en desarrollo) nunca avisa
+ * @param {(access: object|undefined|null) => boolean} [props.canAccess] quién ve qué (menú, rutas, botones): la regla del
+ *     proyecto, normalmente createAccessChecker({abilities, roles, policies, context}). Sin ella solo se ve lo que no
+ *     tiene regla
+ * @param {import('react').ReactNode} props.children
+ */
+export declare const ToolkitProvider: ({ language, onLanguageChange, texts, translate, timeZone, currency, appName, navigation, buildId, canAccess, children, }: {
+    language?: string;
+    onLanguageChange?: (language: string) => void;
+    texts?: object;
+    translate?: (namespace: string, key: string, values?: object) => string | undefined;
+    timeZone?: string;
+    currency?: string;
+    appName?: string;
+    navigation?: object;
+    buildId?: string;
+    canAccess?: (access: object | undefined | null) => boolean;
+    children: import('react').ReactNode;
+}) => import("react").JSX.Element;

package/dist/types/toolkit/browserNavigation.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Cambia de página: -1 regresa en el historial; una ruta abre esa ruta.
+ *
+ * @param {string|number} destination
+ * @returns {void}
+ */
+declare function navigateInBrowser(destination: string | number): void;
+/**
+ * La página actual, como la da react-router: la ruta, la búsqueda y una llave por página.
+ *
+ * @returns {{pathname: string, search: string, key: string}}
+ */
+declare function useBrowserLocation(): {
+    pathname: string;
+    search: string;
+    key: string;
+};
+/**
+ * El enlace sin router: un <a> con href.
+ *
+ * @param {{to: string}} props lo demás pasa al <a>
+ * @returns {import('react').ReactElement}
+ */
+declare function BrowserLink({ to, ...props }: {
+    to: string;
+}): import('react').ReactElement;
+export declare const browserNavigation: Readonly<{
+    useNavigate: () => typeof navigateInBrowser;
+    useLocation: typeof useBrowserLocation;
+    Link: typeof BrowserLink;
+}>;
+export {};

package/dist/types/toolkit/toolkitContext.d.ts

@@ -0,0 +1,28 @@
+export declare const ToolkitContext: import("react").Context<null>;
+/**
+ * La configuración del proveedor; sin proveedor, la vigente con la navegación del navegador.
+ *
+ * @returns {{language: string, onLanguageChange: Function|null, texts: object, translate: Function|null, timeZone: string, currency: string, appName: string, buildId: string, navigation: object, canAccess: Function}}
+ */
+export declare function useToolkitSettings(): {
+    language: string;
+    onLanguageChange: Function | null;
+    texts: object;
+    translate: Function | null;
+    timeZone: string;
+    currency: string;
+    appName: string;
+    buildId: string;
+    navigation: object;
+    canAccess: Function;
+};
+/**
+ * La navegación que conectó el proyecto: {useNavigate, useLocation, Link}.
+ *
+ * @returns {{useNavigate: Function, useLocation: Function, Link: import('react').ElementType}}
+ */
+export declare function useToolkitNavigation(): {
+    useNavigate: Function;
+    useLocation: Function;
+    Link: import('react').ElementType;
+};

package/dist/types/toolkit/toolkitSettings.d.ts

@@ -0,0 +1,68 @@
+export declare const DEFAULT_LANGUAGE = "es";
+export declare const DEFAULT_CURRENCY = "MXN";
+/**
+ * La zona horaria del navegador; si el navegador no la sabe, la de la Ciudad de México.
+ *
+ * @returns {string}
+ */
+export declare function browserTimeZone(): string;
+/**
+ * Cambia la configuración que leen las funciones del paquete. La llama ToolkitProvider; un proyecto sin React (o una
+ * prueba) la puede llamar directo.
+ *
+ * @param {{language?: string, texts?: object, translate?: Function|null, timeZone?: string, currency?: string, appName?: string, buildId?: string}} settings
+ * @returns {void}
+ */
+export declare function configureToolkit(settings: {
+    language?: string;
+    texts?: object;
+    translate?: Function | null;
+    timeZone?: string;
+    currency?: string;
+    appName?: string;
+    buildId?: string;
+}): void;
+/**
+ * La configuración vigente.
+ *
+ * @returns {{language: string, texts: object, translate: Function|null, timeZone: string, currency: string, appName: string, buildId: string}}
+ */
+export declare function toolkitSettings(): {
+    language: string;
+    texts: object;
+    translate: Function | null;
+    timeZone: string;
+    currency: string;
+    appName: string;
+    buildId: string;
+};
+/**
+ * El locale de Intl del idioma (es → es-MX, en → en-US).
+ *
+ * @param {string} language
+ * @returns {string}
+ */
+export declare function intlLocaleOf(language: string): string;
+/**
+ * El texto de una llave con una configuración dada (la del proveedor o la vigente).
+ *
+ * @param {{language: string, texts: object, translate: Function|null}} settings
+ * @param {string} defaultNamespace el namespace cuando la llave no trae uno («table», «common», «problems»...)
+ * @param {string} key «llave» o «namespace:llave»
+ * @param {object} [values] las variables del texto y, para el plural, count
+ * @returns {string} la llave misma si no hay texto, para que se note qué falta
+ */
+export declare function translateWith(settings: {
+    language: string;
+    texts: object;
+    translate: Function | null;
+}, defaultNamespace: string, key: string, values?: object): string;
+/**
+ * El texto de una llave con la configuración vigente, para lo que no es componente (avisos, errores del servidor).
+ *
+ * @param {string} defaultNamespace
+ * @param {string} key
+ * @param {object} [values]
+ * @returns {string}
+ */
+export declare function translateToolkit(defaultNamespace: string, key: string, values?: object): string;

package/dist/types/toolkit/useToolkitTranslation.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @param {string|string[]} [namespace] el namespace de las llaves sin prefijo; con una lista, el primero. Sin él, cada
+ *     llave lleva el suyo ('orders:list.title')
+ * @returns {{t: (key: string, values?: object) => string, language: string, changeLanguage: (language: string) => void}}
+ */
+export declare function useToolkitTranslation(namespace?: string | string[]): {
+    t: (key: string, values?: object) => string;
+    language: string;
+    changeLanguage: (language: string) => void;
+};

package/dist/types/ui/actions/CopyButton.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @param {object} props
+ * @param {string} props.value lo que se copia
+ * @param {string} [props.label] ya traducido; por omisión «Copiar»
+ * @param {'small'|'medium'} [props.size]
+ * @param {() => void} [props.onCopied]
+ */
+export default function CopyButton({ value, label, size, onCopied }: {
+    value: string;
+    label?: string;
+    size?: 'small' | 'medium';
+    onCopied?: () => void;
+}): import("react").JSX.Element;

package/dist/types/ui/actions/DownloadMenu.d.ts

@@ -0,0 +1,50 @@
+/**
+ * @param {object} props
+ * @param {Array<'pdf'|'xlsx'|'csv'>} props.formats
+ * @param {(format: string, transferOptions: {signal: AbortSignal, onDownloadProgress: (progress: {loaded: number, total?: number|null}) => void}) => Promise<{blob: Blob, fileName: string}>} props.download
+ * @param {string} [props.label] ya traducido; por defecto "Descargar"
+ * @param {string} [props.downloadLabel] ya traducido; lo que se ve en el panel de descargas antes de saber el nombre
+ *     del archivo
+ * @param {boolean} [props.disabled]
+ * @param {(format: string) => {title: string, description: import('react').ReactNode, confirmLabel?: string}} [props.confirmation]
+ * @param {(format: string) => void} [props.onDownloaded] p. ej. volver a pedir la tabla (si la descarga cambia algo en
+ *     el servidor)
+ * @param {'button'|'icon'} [props.variant] icon = solo el icono (columna de acciones de una tabla)
+ * @param {string} [props.ariaLabel] ya traducido; obligatorio en la variante icon
+ * @param {(format: string) => void} [props.onChooseFormat] quien llama se encarga de confirmar y descargar
+ * @param {import('react').ElementType} [props.icon] ícono del botón; por defecto el de descarga. Distingue dos descargas en la
+ *     misma fila
+ *
+ * IMPORTANTE: hay que pasar `confirmation` u `onChooseFormat`. Sin ninguno de los dos el menú no descarga nada (regla de
+ * tablas: toda descarga pasa por confirmación).
+ *
+ * OJO onChooseFormat: dentro de una celda del DataGrid el diálogo de confirmación NO puede vivir en la celda (el grid
+ * virtualiza y vuelve a pintar sus celdas; el diálogo se perdía al elegir el formato). Ahí el menú solo avisa qué formato
+ * se eligió y la pantalla abre SU confirmación (useConfirmAction) fuera de la tabla.
+ */
+export default function DownloadMenu({ formats, download, label, downloadLabel, disabled, confirmation, onDownloaded, variant, ariaLabel, onChooseFormat, icon: ButtonIcon, }: {
+    formats: Array<'pdf' | 'xlsx' | 'csv'>;
+    download: (format: string, transferOptions: {
+        signal: AbortSignal;
+        onDownloadProgress: (progress: {
+            loaded: number;
+            total?: number | null;
+        }) => void;
+    }) => Promise<{
+        blob: Blob;
+        fileName: string;
+    }>;
+    label?: string;
+    downloadLabel?: string;
+    disabled?: boolean;
+    confirmation?: (format: string) => {
+        title: string;
+        description: import('react').ReactNode;
+        confirmLabel?: string;
+    };
+    onDownloaded?: (format: string) => void;
+    variant?: 'button' | 'icon';
+    ariaLabel?: string;
+    onChooseFormat?: (format: string) => void;
+    icon?: import('react').ElementType;
+}): import("react").JSX.Element;

package/dist/types/ui/actions/SecretField.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @param {object} props
+ * @param {string} props.value el secreto
+ * @param {string} props.label ya traducido
+ * @param {string} [props.helperText] p. ej. «Guárdela: no se vuelve a enseñar»
+ * @param {() => void} [props.onCopied]
+ */
+export default function SecretField({ value, label, helperText, onCopied }: {
+    value: string;
+    label: string;
+    helperText?: string;
+    onCopied?: () => void;
+}): import("react").JSX.Element;