@groupteknology/vuno 3.0.0 → 4.0.0

package/dist/runtime/app/types/page.d.ts

@@ -1,57 +0,0 @@
-import type { VunoColor } from './base.js';
-/** Segmento que `VBreadcrumb` muestra dentro de una ruta de navegación. */
-export type VunoBreadcrumbItem = {
-    icon?: string;
-    label: string;
-    to?: string;
-};
-/**
- * Un elemento de navegación, que puede tener hijos hasta cualquier profundidad.
- *
- * `to` es opcional a propósito y las tres combinaciones significan cosas
- * distintas: con `to` y sin hijos es una hoja; con hijos y sin `to` es solo un
- * grupo que agrupa; y **con los dos es una página que además tiene hijos**, que
- * es el caso que obliga a separar el enlace del botón de desplegar.
- */
-export type VunoNavigationItem = {
-    badge?: string;
-    children?: VunoNavigationItem[];
-    disabled?: boolean;
-    icon?: string;
-    label: string;
-    to?: string;
-};
-/** Enlace de un índice de página declarado antes del render, también disponible en SSR. */
-export type VunoNavigationTocItem = {
-    label: string;
-    /** Nivel visual del enlace dentro del índice. */
-    level?: 2 | 3;
-    /** Destino del enlace, normalmente el identificador de una sección: `#usage`. */
-    to: string;
-};
-/**
- * Una pestaña. El contenido lo pinta quien la usa, por el slot.
- *
- * Vivía dentro de `Tabs.vue`, y eso lo dejaba fuera del contrato: el componente
- * recibe `items: VunoTabItem[]` y desde el proyecto consumidor **ese tipo no se
- * podía nombrar** —`import type { VunoTabItem }` fallaba con TS2305—, así que la
- * única salida era un `as` o repetir la forma a mano, que es peor porque deja de
- * avisar cuando cambie. Los demás tipos de esta familia ya estaban aquí, de modo
- * que era un olvido y no una decisión.
- *
- * El `badge` cae a `error` si no lleva color, porque existe para contar los
- * fallos de una pestaña que no estás mirando.
- */
-export type VunoTabItem = {
-    badge?: {
-        color?: VunoColor;
-        label: string;
-    };
-    icon?: string;
-    label: string;
-    /** Destino opcional. Con `to`, la pestaña navega y su estado activo sigue la ruta actual. */
-    to?: string;
-    value: string;
-};
-/** Apariencia de la barra de pestañas. */
-export type VunoTabsVariant = 'segmented' | 'underline';

package/dist/runtime/app/types/responsive.d.ts

@@ -1,8 +0,0 @@
-export type VunoResponsiveColumnSpan = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12;
-export type VunoResponsiveColumns = {
-    xs?: VunoResponsiveColumnSpan;
-    sm?: VunoResponsiveColumnSpan;
-    md?: VunoResponsiveColumnSpan;
-    lg?: VunoResponsiveColumnSpan;
-    xl?: VunoResponsiveColumnSpan;
-};

package/dist/runtime/app/types/shortcuts.d.ts

@@ -1,44 +0,0 @@
-/** Lo que corre cuando el atajo entra. Recibe el evento por si hace falta pararlo o leerlo. */
-export type VunoShortcutHandler = (event: KeyboardEvent) => void;
-/**
- * Un atajo: la función a secas, o la función con condiciones.
- *
- * `usingInput` decide qué pasa cuando el foco está dentro de un campo, y es la
- * parte que no se puede omitir: sin ella, escribir «g» en un buscador dispararía
- * el atajo «ir a…» y el usuario vería la página cambiar mientras teclea.
- *
- * - `false` —lo de serie— solo fuera de un campo.
- * - `true` también dentro, que es lo que quiere `escape` para cerrar.
- * - una cadena, solo dentro del campo que se llame así, que es lo que quiere
- *   `enter` para buscar sin robarle el Enter al resto de formularios.
- */
-export type VunoShortcut = VunoShortcutHandler | {
-    handler: VunoShortcutHandler;
-    usingInput?: boolean | string;
-};
-/**
- * El mapa de atajos. La clave es la combinación y el valor lo que hace.
- *
- * Un valor falso —`false`, `null`, `undefined`— **salta ese atajo sin sacarlo
- * del mapa**, que es como se enciende y se apaga uno según el estado sin
- * reconstruir el objeto entero.
- */
-export type VunoShortcuts = Record<string, false | null | undefined | VunoShortcut>;
-export type VunoShortcutsOptions = {
-    /**
-     * Cuánto se espera entre teclas para que sigan contando como una secuencia.
-     *
-     * Pasado ese tiempo la secuencia se olvida, que es lo que evita que teclear
-     * «g» ahora y «d» dentro de un minuto acabe navegando a otra parte.
-     */
-    chainDelay?: number;
-    /**
-     * Comparar por la **posición física** de la tecla en vez de por el carácter.
-     *
-     * Con esto puesto, un teclado árabe o hebreo dispara los mismos atajos que
-     * uno latino, porque se mira dónde está la tecla y no qué letra escribe. El
-     * precio es el contrario: un teclado AZERTY tendrá la `a` donde el QWERTY
-     * tiene la `q`.
-     */
-    layoutIndependent?: boolean;
-};

package/dist/runtime/app/types/table.d.ts

@@ -1,287 +0,0 @@
-import type { VunoColor, VunoSize } from './base.js';
-import type { VunoField } from './field.js';
-import type { VunoUi } from './slots.js';
-type WithType<TColumn, TType extends string> = TColumn & {
-    type: TType;
-};
-/**
- * `Omit` que recorre la unión miembro a miembro.
- *
- * El `Omit` de TypeScript aplana la unión en un solo objeto con las claves
- * comunes, y con ella se lleva por delante el discriminante: el resultado ya no
- * distingue un `badge` de un `date`.
- */
-type OmitEach<TUnion, TKey extends PropertyKey> = TUnion extends unknown ? Omit<TUnion, TKey> : never;
-export type VunoTableSortDirection = 'asc' | 'desc';
-export type VunoTableSort = {
-    column: string;
-    direction: VunoTableSortDirection;
-};
-/**
- * Estado de consulta de la tabla. Es el `v-model:query` y la única fuente de
- * verdad: en modo servidor el consumidor observa este objeto, pide su página
- * y devuelve `data` y `total`.
- */
-export type VunoTableFilters = Record<string, unknown>;
-export type VunoTableQuery = {
-    /** Valores del panel de filtros, indexados por el `name` de cada campo. */
-    filters: VunoTableFilters;
-    page: number;
-    pageSize: number;
-    search: string;
-    sort: null | VunoTableSort;
-};
-/**
- * Fallo de la consulta, con el reintento DENTRO. Es un objeto y no dos props
- * sueltas a propósito: así no se puede pintar un error sin ofrecer salida.
- *
- * Existe porque sin él una consulta fallida se normaliza a lista vacía
- * (`data ?? []`) y la tabla dice «No hay resultados»: afirma que no hay nada
- * cuando lo que pasa es que no se pudo saber.
- */
-export type VunoTableFailure = {
-    hint?: string;
-    title?: string;
-    retry: () => void;
-};
-/** Qué mostrar cuando la consulta va bien y no hay ninguna fila. */
-export type VunoTableEmpty = {
-    hint?: string;
-    icon?: string;
-    title?: string;
-};
-export type VunoTableAlign = 'center' | 'end' | 'start';
-export type VunoTableDensity = 'compact' | 'default';
-export type VunoTableSticky = 'end' | 'start';
-/**
- * Una fila. `object` y no `Record<string, unknown>` a propósito: un `interface`
- * de TypeScript no tiene firma de índice implícita, así que no satisface un
- * `Record`, y los tipos de respuesta de una API se declaran como `interface`
- * casi siempre. Con el `Record`, cada consumidor tenía que escribir
- * `type Fila = SuInterface & Record<string, unknown>` para poder usar la tabla,
- * y el error que salía —«no assignable to VunoTableRow»— no señalaba la causa.
- *
- * La firma de índice no hacía falta para nada: los valores se leen con
- * `getPath`, que recorre el objeto en tiempo de ejecución y acepta `unknown`.
- */
-export type VunoTableRow = object;
-/**
- * Nota: no hay `searchable` por columna. La búsqueda la resuelve el endpoint,
- * que es quien sabe sobre qué campos puede buscar; declararlo aquí sugeriría
- * que la tabla filtra, y no lo hace.
- */
-export type VunoTableColumnBase<TRow extends VunoTableRow = VunoTableRow> = {
-    align?: VunoTableAlign;
-    class?: string;
-    /**
-     * Ruta del valor en la fila. Admite anidado: `'proveedor.nombre'`.
-     *
-     * Sigue haciendo falta con `value`: nombra la columna para el orden y para
-     * el slot `cell-<key>`.
-     */
-    key: string;
-    label?: string;
-    sortable?: boolean;
-    /** Fija la columna al borde lógico del contenedor cuando la tabla se desplaza horizontalmente. */
-    sticky?: VunoTableSticky;
-    ui?: VunoUi<'avatar' | 'badge' | 'cellBoolean' | 'cellCurrency' | 'cellDate' | 'cellNumber' | 'cellText' | 'menu'>;
-    width?: string;
-    /**
-     * Calcula el valor a partir de la fila entera, en lugar de leerlo de `key`.
-     *
-     * ```ts
-     * { key: 'role', type: 'badge', value: (row) => traducirRol(row.role) }
-     * ```
-     *
-     * Sustituye de dónde sale el valor, no cómo se pinta: lo que devuelve sigue
-     * pasando por el formato de su tipo de columna —moneda, fecha, el `map` de
-     * un badge—, así que se combinan.
-     *
-     * Cuidado al ordenar: `sortable` ordena en servidor por `key`, y el servidor
-     * no conoce esta función. Si el valor mostrado no se deriva de `key` de
-     * forma monótona, el orden no coincidirá con lo que se ve.
-     */
-    value?: (row: TRow) => unknown;
-};
-export type VunoTableColumnText<TRow extends VunoTableRow = VunoTableRow> = VunoTableColumnBase<TRow> & {
-    truncate?: boolean;
-};
-export type VunoTableColumnNumber<TRow extends VunoTableRow = VunoTableRow> = VunoTableColumnBase<TRow> & {
-    decimals?: number;
-};
-export type VunoTableColumnCurrency<TRow extends VunoTableRow = VunoTableRow> = VunoTableColumnBase<TRow> & {
-    currency?: string;
-    decimals?: number;
-};
-export type VunoTableColumnDate<TRow extends VunoTableRow = VunoTableRow> = VunoTableColumnBase<TRow> & {
-    dateStyle?: 'full' | 'long' | 'medium' | 'short';
-    timeStyle?: 'full' | 'long' | 'medium' | 'short';
-};
-export type VunoTableColumnBoolean<TRow extends VunoTableRow = VunoTableRow> = VunoTableColumnBase<TRow> & {
-    falseLabel?: string;
-    trueLabel?: string;
-};
-/** Traduce el valor crudo a una etiqueta con color, p. ej. estados. */
-export type VunoTableBadgeMap = Record<string, {
-    color?: VunoColor;
-    label?: string;
-}>;
-export type VunoTableColumnBadge<TRow extends VunoTableRow = VunoTableRow> = VunoTableColumnBase<TRow> & {
-    color?: VunoColor;
-    map?: VunoTableBadgeMap;
-};
-export type VunoTableColumnImage<TRow extends VunoTableRow = VunoTableRow> = VunoTableColumnBase<TRow> & {
-    alt?: string;
-    /** Clave de la fila de la que sacar el texto alternativo. */
-    altKey?: string;
-    size?: Extract<VunoSize, 'lg' | 'md' | 'sm' | 'xs'>;
-};
-/** Delega el contenido en el slot `cell-<key>`. */
-export type VunoTableColumnCustom<TRow extends VunoTableRow = VunoTableRow> = VunoTableColumnBase<TRow>;
-export type VunoTableAction<TRow extends VunoTableRow = VunoTableRow> = {
-    onSelect: (row: TRow) => void;
-    color?: VunoColor;
-    icon?: string;
-    label: string;
-    /** Dibuja un separador encima de la acción. */
-    separator?: boolean;
-    disabled?: (row: TRow) => boolean;
-    /** Oculta la acción para esa fila concreta. */
-    hidden?: (row: TRow) => boolean;
-};
-export type VunoTableColumnActions<TRow extends VunoTableRow = VunoTableRow> = VunoTableColumnBase<TRow> & {
-    actions: VunoTableAction<TRow>[];
-};
-/** Unión discriminada por `type`, igual que `VunoField` en los formularios. */
-export type VunoTableColumn<TRow extends VunoTableRow = VunoTableRow> = WithType<VunoTableColumnActions<TRow>, 'actions'> | WithType<VunoTableColumnBadge<TRow>, 'badge'> | WithType<VunoTableColumnBoolean<TRow>, 'boolean'> | WithType<VunoTableColumnCurrency<TRow>, 'currency'> | WithType<VunoTableColumnCustom<TRow>, 'custom'> | WithType<VunoTableColumnDate<TRow>, 'date'> | WithType<VunoTableColumnImage<TRow>, 'image'> | WithType<VunoTableColumnNumber<TRow>, 'number'> | WithType<VunoTableColumnText<TRow>, 'text'>;
-export type VunoTableColumnType = VunoTableColumn['type'];
-/** Extrae los props de un tipo concreto de columna: `VunoTableColumnOf<'badge'>`. */
-export type VunoTableColumnOf<TType extends VunoTableColumnType> = Extract<VunoTableColumn, {
-    type: TType;
-}>;
-/**
- * Tipos que pinta una celda.
- *
- * `actions` y `custom` quedan fuera porque no los resuelve la celda: el menú de
- * acciones y el slot propio los pinta la tabla, que es quien tiene los eventos.
- */
-export type VunoTableCellType = Exclude<VunoTableColumnType, 'actions' | 'custom'>;
-/**
- * La columna tal y como la ve una celda: la misma, sin `value`.
- *
- * `value` es lo único de una columna que depende del tipo de la fila, y la
- * celda no lo usa: el valor le llega ya resuelto. Dejarlo fuera es lo que
- * permite que una celda pinte la columna de cualquier tabla. Con él dentro, una
- * `VunoTableColumn<TuFila>` no vale donde se espera una `VunoTableColumn`,
- * porque una función que sabe leer tu fila no sabe leer un objeto cualquiera, y
- * esa es una diferencia real y no un capricho del compilador.
- */
-export type VunoTableCellColumn<TType extends VunoTableCellType = VunoTableCellType> = OmitEach<VunoTableColumnOf<TType>, 'value'>;
-/** Props comunes a toda celda. El valor llega resuelto para no repetir `getPath`. */
-export type VunoTableCellProps<TType extends VunoTableCellType = VunoTableCellType> = {
-    column: VunoTableCellColumn<TType>;
-    row: VunoTableRow;
-    value: unknown;
-};
-export type VunoTableDefinition<TRow extends VunoTableRow = VunoTableRow> = {
-    /** Texto visible que nombra la tabla mediante su `<caption>` nativo. */
-    caption?: string;
-    columns: VunoTableColumn<TRow>[];
-    /** Densidad visual de las cabeceras y celdas. */
-    density?: VunoTableDensity;
-    /** Hace que cada fila sea enfocable y active `rowClick` con Enter o Espacio. */
-    interactive?: boolean;
-    /** Identificador del título externo que nombra la tabla. No se combina con `caption`. */
-    labelledBy?: string;
-    /** Campo que identifica la fila; se usa como clave de selección. */
-    rowKey?: string;
-    /**
-     * Con qué se **nombra** una fila para quien no ve la pantalla.
-     *
-     * No lo confundas con `rowKey`, que identifica para la selección y puede ser
-     * un número opaco: esto es lo que se lee en voz alta. Va dentro del nombre
-     * accesible de la casilla y del menú de acciones de cada fila —«Elegir
-     * Cafetera italiana», «Acciones de Cafetera italiana»—, que sin él se
-     * llamaban las veinte igual.
-     *
-     * **Sin declararlo se adivina**, y se adivina bien en el caso corriente: la
-     * primera columna de texto, que es la misma pista que usa quien mira la
-     * pantalla. Se declara cuando adivinar no vale — una tabla cuya primera
-     * columna de texto es un estado que se repite («Activo», «Activo»,
-     * «Activo»), o una donde lo que identifica la fila son dos columnas juntas.
-     *
-     * Las dos formas dicen cosas distintas:
-     *
-     * - Una **cadena es una ruta dentro de la fila**, igual que `rowKey` y que
-     *   la `key` de una columna: `'name'`, `'client.name'`. No es un rótulo
-     *   literal — un literal nombraría todas las filas igual, que es justo el
-     *   defecto que esto viene a quitar.
-     * - Una **función** es la salida para lo que no cabe en una ruta: juntar dos
-     *   campos, recortar, o componer un nombre que no está guardado.
-     *
-     * Lo que devuelva vacío cae al número de fila —«fila 3»— y **no** a la
-     * heurística: declarar es decir cuál es la fuente, y volver a adivinar por
-     * detrás dejaría unas filas nombradas por la columna declarada y otras por
-     * otra, sin que nada lo dijera.
-     */
-    rowLabel?: ((row: TRow) => string) | string;
-    selectable?: boolean;
-    /** Fija la cabecera al borde superior de un contenedor con altura limitada. */
-    stickyHeader?: boolean;
-};
-/** Configuración del componente compuesto que consulta y presenta una tabla. */
-export type VunoDataTableDefinition<TRow extends VunoTableRow = VunoTableRow> = VunoTableDefinition<TRow> & {
-    /** Texto e icono cuando no hay ninguna fila. */
-    empty?: VunoTableEmpty;
-    /** Campos del panel lateral de filtros. */
-    filters?: VunoField[];
-    /** Tamaños ofrecidos en el selector de filas por página. */
-    pageSizes?: number[];
-    /** Si el endpoint pagina. Por defecto `true`. */
-    paginated?: boolean;
-    /** Si el endpoint busca. Por defecto `true`. */
-    searchable?: boolean;
-    searchPlaceholder?: string;
-};
-export type VunoTableQueryOptions = {
-    /**
-     * Nombres de los filtros que viajan en la URL. Hace falta declararlos
-     * porque al arrancar sin valores no habría forma de saber cuáles leer.
-     */
-    filterKeys?: string[];
-    filters?: VunoTableFilters;
-    /**
-     * Cómo se escribe en el historial del navegador.
-     *
-     * - `replace` (por defecto): no deja rastro. Recargar y compartir el
-     *   enlace funcionan, pero el botón atrás sale de la página en vez de
-     *   deshacer el último filtro.
-     * - `push`: cada cambio es una entrada, así que atrás deshace filtro a
-     *   filtro. A cambio, teclear en el buscador llena el historial —el
-     *   antirrebote de la tabla lo suaviza, pero no lo evita.
-     */
-    history?: 'push' | 'replace';
-    page?: number;
-    pageSize?: number;
-    /** Prefijo de los parámetros, para tener varias tablas en la misma página. */
-    prefix?: string;
-    search?: string;
-    /**
-     * Orden inicial de la tabla. Admite la forma corta `'sku'` (ascendente).
-     *
-     * Declararlo cambia el ciclo de la cabecera: en vez de asc → desc → sin
-     * orden, el tercer clic devuelve a este orden.
-     *
-     * Va aquí y no en la definición porque el primer `fetch` —el del servidor
-     * incluido— tiene que salir ya ordenado; aplicarlo al montar la tabla
-     * provocaría una segunda petición y un parpadeo.
-     */
-    sort?: null | string | VunoTableSort;
-    /**
-     * Guarda el estado en la query string: el enlace es compartible y recargar
-     * conserva los filtros. Si además quieres que el botón atrás los deshaga,
-     * usa `history: 'push'`.
-     */
-    url?: boolean;
-};
-export {};

package/dist/runtime/app/types/text.d.ts

@@ -1,6 +0,0 @@
-/** Elemento semántico que puede pintar `VText`. */
-export type VunoTextTag = 'code' | 'div' | 'em' | 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6' | 'p' | 'small' | 'span' | 'strong';
-/** Jerarquía cromática del texto, independiente de su tamaño o etiqueta. */
-export type VunoTextTone = 'body' | 'inherit' | 'inverse' | 'muted' | 'strong' | 'subtle';
-/** Rol visual completo: tamaño, peso, interlineado y espaciado. */
-export type VunoTextVariant = 'body' | 'caption' | 'code' | 'display' | 'heading' | 'inherit' | 'label' | 'title';

package/dist/runtime/app/utils/query-key.d.ts

@@ -1,20 +0,0 @@
-/**
- * Clave base de la caché ya resuelta.
- *
- * `ready` en `false` significa que la clave todavía no se puede construir
- * —falta la empresa, la tienda o el almacén que la pantalla está resolviendo—
- * y que la consulta no debe dispararse.
- */
-export type VunoResolvedKey = {
-    ready: boolean;
-    segments: readonly unknown[];
-};
-/**
- * Normaliza la clave base a segmentos y dice si está completa.
- *
- * Un segmento `undefined` o `null` marca la clave como no lista. En una clave
- * de caché ese hueco nunca es un valor: es un dato que aún no ha llegado, y
- * consultar con él devolvería la lista de otro inquilino o una vacía. Tratarlo
- * como «todavía no» evita que cada pantalla repita su propio `enabled`.
- */
-export declare function resolveQueryKey(key: null | readonly unknown[] | string | undefined): VunoResolvedKey;

package/dist/runtime/app/utils/query-key.js

@@ -1,7 +0,0 @@
-export function resolveQueryKey(key) {
-  if (key === null || key === void 0) return { ready: false, segments: [] };
-  const segments = Array.isArray(key) ? key : [key];
-  if (segments.length === 0) return { ready: false, segments };
-  const complete = segments.every((segment) => segment !== null && segment !== void 0);
-  return { ready: complete, segments };
-}