@stackcraftmx/calcita 0.0.0-stage → 0.25.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/ComponentTexts.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @param {object} props
+ * @param {string} props.namespace 'table', 'common', 'account'… (los de src/locales/es.js)
+ * @param {object} [props.texts] los textos que cambian, con la forma de ese namespace
+ * @param {import('react').ReactNode} props.children
+ */
+export default function ComponentTexts({ namespace, texts, children }: {
+    namespace: string;
+    texts?: object;
+    children: import('react').ReactNode;
+}): import("react").JSX.Element;

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

@@ -0,0 +1,47 @@
+/**
+ * @param {object} props
+ * @param {string} [props.language] idioma activo, uno de `languages` (por omisión es)
+ * @param {Array<{code: string, label: string, locale?: string}>} [props.languages] los idiomas que ofrece la app: su código,
+ *     su nombre en su propio idioma («Português») y su locale de Intl ('pt-BR'). Por omisión español e inglés
+ *     (DEFAULT_LANGUAGES). Sus traducciones van en `texts`
+ * @param {Record<string, {Icon: import('react').ElementType, color?: string, label?: string, hint?: string}>} [props.fileTypes]
+ *     tipos de archivo del proyecto para las descargas, además de Excel, CSV y PDF (downloads/fileTypes.js)
+ * @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, languages, onLanguageChange, texts, translate, timeZone, currency, appName, navigation, buildId, canAccess, fileTypes, children, }: {
+    language?: string;
+    languages?: Array<{
+        code: string;
+        label: string;
+        locale?: string;
+    }>;
+    fileTypes?: Record<string, {
+        Icon: import('react').ElementType;
+        color?: string;
+        label?: string;
+        hint?: 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,27 @@
+/**
+ * La navegación del navegador, con o sin prefijo.
+ *
+ * @param {{basePath?: string}} [options] basePath: donde vive la app detrás de un proxy ('/portal'); sin él, la raíz
+ * @returns {{useNavigate: () => (destination: string|number) => void, useLocation: () => {pathname: string, search: string, key: string}, Link: import('react').ElementType}}
+ */
+export declare function createBrowserNavigation({ basePath }?: {
+    basePath?: string;
+}): {
+    useNavigate: () => (destination: string | number) => void;
+    useLocation: () => {
+        pathname: string;
+        search: string;
+        key: string;
+    };
+    Link: import('react').ElementType;
+};
+/** La de omisión: sin prefijo. */
+export declare const browserNavigation: {
+    useNavigate: () => (destination: string | number) => void;
+    useLocation: () => {
+        pathname: string;
+        search: string;
+        key: string;
+    };
+    Link: import('react').ElementType;
+};

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

@@ -0,0 +1,20 @@
+/** @type {import('react').Context<{namespace: string, texts: object|undefined, parent: object|null}|null>} */
+export declare const ComponentTextsContext: import('react').Context<{
+    namespace: string;
+    texts: object | undefined;
+    parent: object | null;
+} | null>;
+/**
+ * Las capas de afuera hacia la más lejana, para componentTextOf.
+ *
+ * @param {{namespace: string, texts: object|undefined, parent: object|null}|null} layer
+ * @returns {Array<{namespace: string, texts: object|undefined}>}
+ */
+export declare function layersOf(layer: {
+    namespace: string;
+    texts: object | undefined;
+    parent: object | null;
+} | null): Array<{
+    namespace: string;
+    texts: object | undefined;
+}>;

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

@@ -0,0 +1,12 @@
+/**
+ * @returns {{useNavigate: () => (destination: string|number) => void, useLocation: () => {pathname: string, search: string, key: string}, Link: import('react').ElementType}}
+ */
+export declare function createHashNavigation(): {
+    useNavigate: () => (destination: string | number) => void;
+    useLocation: () => {
+        pathname: string;
+        search: string;
+        key: string;
+    };
+    Link: import('react').ElementType;
+};

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

@@ -0,0 +1,43 @@
+/**
+ * El prefijo limpio: '' sin prefijo; si no, empieza con / y no termina con / ('portal/' → '/portal').
+ *
+ * @param {string|null|undefined} basePath
+ * @returns {string}
+ */
+export declare function normalizedBasePath(basePath: string | null | undefined): string;
+/**
+ * La dirección real de una ruta de la app con el prefijo puesto: '/pedidos' → '/portal/pedidos'. Lo que no es ruta de la
+ * app se queda como viene.
+ *
+ * @param {string} basePath
+ * @param {string} destination
+ * @returns {string}
+ */
+export declare function pathWithBase(basePath: string, destination: string): string;
+/**
+ * La ruta de la app de una dirección real, sin el prefijo: '/portal/pedidos' → '/pedidos'; el prefijo solo → '/'. Una
+ * dirección de fuera del prefijo se queda como viene.
+ *
+ * @param {string} basePath
+ * @param {string} pathname
+ * @returns {string}
+ */
+export declare function pathWithoutBase(basePath: string, pathname: string): string;
+/**
+ * La página de la app que va después del # ('#/pedidos?estado=pendiente' → {pathname: '/pedidos', search: '?estado=pendiente'}).
+ * Sin nada después del #, el inicio.
+ *
+ * @param {string} hash el de la dirección (location.hash), con o sin #
+ * @returns {{pathname: string, search: string}}
+ */
+export declare function hashLocationOf(hash: string): {
+    pathname: string;
+    search: string;
+};
+/**
+ * El enlace de una ruta de la app con # ('/pedidos' → '#/pedidos'). Lo que no es ruta de la app se queda como viene.
+ *
+ * @param {string} destination
+ * @returns {string}
+ */
+export declare function hashHrefOf(destination: string): string;

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;
+};