@jvsoft/components 1.0.0-alpha.16 → 1.0.0-alpha.18

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (34) hide show
  1. package/.storybook/tema-demo.css +194 -0
  2. package/dialog-flotante/README.md +21 -1
  3. package/fesm2022/jvsoft-components-dialog-flotante.mjs +18 -12
  4. package/fesm2022/jvsoft-components-dialog-flotante.mjs.map +1 -1
  5. package/fesm2022/jvsoft-components-filtro-busqueda.mjs +11 -2
  6. package/fesm2022/jvsoft-components-filtro-busqueda.mjs.map +1 -1
  7. package/fesm2022/jvsoft-components-lista-arbol.mjs +58 -17
  8. package/fesm2022/jvsoft-components-lista-arbol.mjs.map +1 -1
  9. package/fesm2022/jvsoft-components-lista-detalle.mjs +70 -0
  10. package/fesm2022/jvsoft-components-lista-detalle.mjs.map +1 -0
  11. package/fesm2022/jvsoft-components-luces-navidad.mjs +2 -2
  12. package/fesm2022/jvsoft-components-luces-navidad.mjs.map +1 -1
  13. package/fesm2022/jvsoft-components-menu.mjs +4 -1
  14. package/fesm2022/jvsoft-components-menu.mjs.map +1 -1
  15. package/fesm2022/jvsoft-components-tabla-mantenimiento-components-progress-bar.mjs +2 -5
  16. package/fesm2022/jvsoft-components-tabla-mantenimiento-components-progress-bar.mjs.map +1 -1
  17. package/fesm2022/jvsoft-components-tabla-mantenimiento.mjs +2605 -394
  18. package/fesm2022/jvsoft-components-tabla-mantenimiento.mjs.map +1 -1
  19. package/fesm2022/jvsoft-components.mjs +1 -0
  20. package/fesm2022/jvsoft-components.mjs.map +1 -1
  21. package/lista-arbol/README.md +17 -1
  22. package/lista-detalle/README.md +85 -0
  23. package/package.json +6 -2
  24. package/src/styles/base-jvsoft-components.css +714 -15
  25. package/tabla-mantenimiento/README.md +628 -0
  26. package/tabla-mantenimiento/tabla-mantenimiento.component.scss +31 -0
  27. package/types/jvsoft-components-dialog-flotante.d.ts +2 -0
  28. package/types/jvsoft-components-filtro-busqueda.d.ts +6 -0
  29. package/types/jvsoft-components-lista-arbol.d.ts +19 -2
  30. package/types/jvsoft-components-lista-detalle.d.ts +44 -0
  31. package/types/jvsoft-components-menu.d.ts +1 -0
  32. package/types/jvsoft-components-tabla-mantenimiento-components-progress-bar.d.ts +1 -2
  33. package/types/jvsoft-components-tabla-mantenimiento.d.ts +1070 -21
  34. package/types/jvsoft-components.d.ts +1 -0
@@ -1,14 +1,13 @@
1
1
  import * as _jvsoft_components_tabla_mantenimiento from '@jvsoft/components/tabla-mantenimiento';
2
2
  import * as _angular_core from '@angular/core';
3
- import { OnInit, TemplateRef, AfterContentInit, OnChanges, ViewContainerRef, EventEmitter, QueryList, ElementRef, ChangeDetectorRef, SimpleChanges } from '@angular/core';
3
+ import { InjectionToken, OnInit, TemplateRef, AfterContentInit, AfterViewInit, AfterViewChecked, OnChanges, ViewContainerRef, EventEmitter, ElementRef, QueryList, ChangeDetectorRef, SimpleChanges, EnvironmentProviders } from '@angular/core';
4
4
  import { Overlay, OverlayRef } from '@angular/cdk/overlay';
5
- import { FormGroup, FormControl, FormBuilder } from '@angular/forms';
5
+ import { FormGroup, FormControl } from '@angular/forms';
6
6
  import { MatMenuTrigger } from '@angular/material/menu';
7
7
  import { MatPaginator } from '@angular/material/paginator';
8
8
  import { MatSort } from '@angular/material/sort';
9
9
  import { MatTableDataSource, MatTable, MatColumnDef } from '@angular/material/table';
10
10
  import { BehaviorSubject, Observable, Subscription } from 'rxjs';
11
- import { SelectionModel } from '@angular/cdk/collections';
12
11
  import { Router, ActivatedRoute } from '@angular/router';
13
12
 
14
13
  declare class DataModel {
@@ -18,6 +17,22 @@ declare class DataModel {
18
17
  checkbox: ForCheckboxModel;
19
18
  constructor();
20
19
  generarId(row: any, campoValor: string[] | string, separador?: string): string;
20
+ /**
21
+ * Prepara una casilla por fila usando como clave el mismo identificador con el que la celda
22
+ * lee y escribe (`generarId`). `agregarControles` compone la clave de otra manera cuando el
23
+ * campo es un texto o un array sin separador, así que el modelo y la casilla acababan
24
+ * hablando de claves distintas: la casilla salía vacía y la lista de seleccionados
25
+ * devolvía filas que nadie había marcado.
26
+ *
27
+ * Con `limpiar` en false conserva lo ya marcado, que es lo que espera `chkFieldPersistente`
28
+ * cuando la selección tiene que sobrevivir al cambio de página.
29
+ */
30
+ prepararCasillas(lista: any[], campoValor: string[] | string, separador?: string, limpiar?: boolean): void;
31
+ /**
32
+ * @deprecated Para las casillas de `tabla-mantenimiento` usar `prepararCasillas`, que
33
+ * compone la clave igual que la celda. Este método compone claves distintas según el tipo
34
+ * de `campoValor`, que es de donde venía el desajuste entre lo marcado y lo informado.
35
+ */
21
36
  agregarControles(lista: any[], idLista: string, limpiar?: boolean, campoValor?: string[] | string | null, campoValorSeparador?: string): void;
22
37
  setState(idx: string, state: boolean): void;
23
38
  getState(idx: string): boolean | any;
@@ -28,6 +43,12 @@ declare class DataModel {
28
43
  declare class ForCheckboxModel {
29
44
  private modeloCheck;
30
45
  constructor(modeloCheck: DataModel);
46
+ /**
47
+ * Cuenta casillas y marcadas en un solo recorrido. La cabecera consulta el estado en cada
48
+ * ciclo de detección de cambios, y antes cada consulta recorría el modelo dos veces
49
+ * creando dos arrays intermedios; con mil filas marcadas eso era trabajo y basura de sobra.
50
+ */
51
+ private contar;
31
52
  get cantidadActivos(): number;
32
53
  get existenActivados(): boolean;
33
54
  get todosActivos(): boolean;
@@ -35,13 +56,156 @@ declare class ForCheckboxModel {
35
56
  establecerTodos(activo: boolean): void;
36
57
  }
37
58
 
59
+ /**
60
+ * Jerarquía en `jvs-tabla-mantenimiento` (`[arbol]`). La tabla recibe la lista plana completa
61
+ * (cada registro con su id y el de su padre) y la pinta como árbol: sangría por nivel, plegar y
62
+ * desplegar, y búsqueda o filtro que muestran las coincidencias **con sus antepasados**.
63
+ */
64
+ interface ConfigArbolTabla<T = any> {
65
+ /** Campo con el id del registro. */
66
+ campoId: string;
67
+ /** Campo con el id del padre. Si el padre no está en la lista, el registro sale como raíz. */
68
+ campoIdPadre: string;
69
+ /**
70
+ * Niveles que se ven desplegados sin búsqueda ni filtro: `1` abre las raíces (se ven sus
71
+ * hijos), `2` abre también los hijos, `0` deja todo plegado. Por defecto `1`. Con búsqueda o
72
+ * filtro se despliega todo lo que queda a la vista.
73
+ */
74
+ nivelesAbiertos?: number;
75
+ /**
76
+ * Lista plana: sin sangría ni plegado; la búsqueda y el filtro dejan solo las coincidencias y
77
+ * el orden por columnas es el de siempre. Sirve para ordenar y exportar sin jerarquía.
78
+ */
79
+ plano?: boolean;
80
+ /**
81
+ * Filtro propio de la pantalla (tipo, estado…), que se suma al buscador. En modo árbol se ven
82
+ * sus coincidencias y los antepasados de cada una, atenuados; en modo plano, solo las
83
+ * coincidencias. Sin filtro, todos coinciden.
84
+ */
85
+ filtro?: ((fila: T) => boolean) | null;
86
+ /**
87
+ * Si el filtro propio cuenta como búsqueda: despliega todo y atenúa los antepasados. Por
88
+ * defecto, cuando deja fuera alguna fila. Con `false` se ven los `nivelesAbiertos` de siempre
89
+ * (útil para un filtro que está siempre puesto, como ocultar los inactivos).
90
+ */
91
+ filtroActivo?: boolean;
92
+ /** Sangría por nivel, en px. Por defecto 14. */
93
+ sangria?: number;
94
+ /** Orden entre hermanos cuando no hay una columna ordenada. Por defecto, el de la lista. */
95
+ comparar?: ((a: T, b: T) => number) | null;
96
+ }
97
+ /** Lo que la tabla sabe de una fila en modo árbol (ver `infoArbol`). */
98
+ interface InfoNodoArbolTabla {
99
+ /** 0 en las raíces. En modo plano, siempre 0. */
100
+ nivel: number;
101
+ tieneHijos: boolean;
102
+ abierto: boolean;
103
+ /** Se ve solo como camino hacia una coincidencia de la búsqueda o del filtro (va atenuada). */
104
+ contexto: boolean;
105
+ }
106
+
107
+ /**
108
+ * `MatTableDataSource` de la tabla de mantenimiento. Sin `arbol` se comporta igual que el de
109
+ * Material. Con `arbol` (ver {@link ConfigArbolTabla}):
110
+ *
111
+ * - **Árbol**: `filteredData` son las filas que se pintan, en orden de árbol: las coincidencias del
112
+ * buscador y del filtro propio, más sus antepasados, y de ellas solo las que cuelgan de nodos
113
+ * abiertos. El paginador cuenta esas filas. Ordenar por una columna reordena entre hermanos,
114
+ * sin romper la jerarquía.
115
+ * - **Plano**: solo las coincidencias, con el orden de columnas de siempre.
116
+ *
117
+ * La jerarquía se calcula sobre la lista completa: el nivel de un nodo no cambia al filtrar, y el
118
+ * que tiene el padre fuera de la lista sale como raíz.
119
+ */
120
+ declare class TablaMantenimientoDataSource<T> extends MatTableDataSource<T> {
121
+ private _arbol;
122
+ /** Lo que el usuario abrió o cerró a mano, por id. Manda sobre los niveles por defecto. */
123
+ private expansionElegida;
124
+ /** Si la última pasada estaba filtrando: al cambiar de modo se olvida lo abierto a mano. */
125
+ private filtrandoAntes;
126
+ private info;
127
+ /** Coincidencias + antepasados de la última pasada, sin plegar (para exportar y buscar). */
128
+ private visiblesSinPlegar;
129
+ private indice;
130
+ get arbol(): ConfigArbolTabla<T> | null;
131
+ set arbol(config: ConfigArbolTabla<T> | null);
132
+ /** Árbol con sangría y plegado (no plano). */
133
+ get arbolActivo(): boolean;
134
+ /** Vuelve a filtrar con el mismo texto: tras abrir o cerrar nodos o cambiar el filtro propio. */
135
+ refrescar(): void;
136
+ private idDe;
137
+ /** Lo que se sabe de la fila en la última pasada; `null` sin árbol o si no está a la vista. */
138
+ infoArbol(fila: T): InfoNodoArbolTabla | null;
139
+ alternarNodo(fila: T): void;
140
+ /** Abre o cierra todos los nodos con hijos. */
141
+ expandirTodo(abrir?: boolean): void;
142
+ /**
143
+ * Abre los antepasados de la fila para que se vea. Devuelve `false` si la fila no pasa el
144
+ * buscador ni el filtro (no hay nada que abrir: no está a la vista).
145
+ */
146
+ abrirCaminoA(fila: T): boolean;
147
+ /**
148
+ * Si la fila pasa el buscador y el filtro (en árbol, también si queda como camino de una
149
+ * coincidencia), aunque esté dentro de una rama plegada.
150
+ */
151
+ estaALaVista(fila: T): boolean;
152
+ /**
153
+ * Filas que exporta el Excel. Sin árbol, `filteredData` (como siempre). En árbol, las
154
+ * coincidencias y sus antepasados en orden de árbol, aunque estén plegadas.
155
+ */
156
+ filasParaExportar(): T[];
157
+ _filterData(data: T[]): T[];
158
+ _orderData(data: T[]): T[];
159
+ /**
160
+ * Pone las filas en orden de árbol. Con una columna ordenada, el orden de Material decide el
161
+ * lugar entre hermanos; si no, `comparar` de la configuración o el de la lista.
162
+ */
163
+ private ordenarEnArbol;
164
+ }
165
+
166
+ /**
167
+ * Lo que la celda de árbol necesita de la tabla. Lo provee cada `jvs-tabla-mantenimiento`; va por
168
+ * token y no inyectando el componente para no formar una importación circular.
169
+ */
170
+ interface ControlArbolTabla {
171
+ /** Nivel, hijos, si está abierto y si es solo contexto. `null` si la tabla no está en modo árbol. */
172
+ infoArbol(fila: any): InfoNodoArbolTabla | null;
173
+ alternarNodo(fila: any): void;
174
+ /** Sangría por nivel, en px. */
175
+ sangriaArbol(): number;
176
+ }
177
+ declare const CONTROL_ARBOL_TABLA: InjectionToken<ControlArbolTabla>;
178
+ /**
179
+ * Sangría y botón de plegar/desplegar de una fila en modo árbol. La usa la columna `type: 'arbol'`
180
+ * y sirve también dentro de una columna `custom`, para que el consumidor ponga su propio contenido:
181
+ *
182
+ * ```html
183
+ * <td *matCellDef="let row" mat-cell>
184
+ * <jvs-tabla-arbol-celda [fila]="row">{{ row.cNombre }} <small>{{ row.cSigla }}</small></jvs-tabla-arbol-celda>
185
+ * </td>
186
+ * ```
187
+ *
188
+ * Fuera del modo árbol (o en modo plano) solo pinta el contenido. El botón no selecciona la fila:
189
+ * detiene el clic para que abrir una rama no cambie la selección.
190
+ */
191
+ declare class TablaArbolCeldaComponent {
192
+ private readonly control;
193
+ /** El registro de la fila. */
194
+ fila: _angular_core.InputSignal<any>;
195
+ /** Se consulta en cada ciclo: el estado del árbol vive en la tabla y no es una señal. */
196
+ info(): InfoNodoArbolTabla | null;
197
+ sangria(): number;
198
+ alternar(evento: Event): void;
199
+ static ɵfac: _angular_core.ɵɵFactoryDeclaration<TablaArbolCeldaComponent, never>;
200
+ static ɵcmp: _angular_core.ɵɵComponentDeclaration<TablaArbolCeldaComponent, "jvs-tabla-arbol-celda", never, { "fila": { "alias": "fila"; "required": true; "isSignal": true; }; }, {}, never, ["*"], true, never>;
201
+ }
202
+
38
203
  interface EstilosBarra {
39
204
  valorMaximo: number;
40
205
  class?: string;
41
206
  style?: string;
42
207
  }
43
208
  declare class ProgressBarComponent implements OnInit {
44
- objThis: any;
45
209
  porcentaje: number;
46
210
  textoCentrado: boolean;
47
211
  private _textoMostrar;
@@ -61,12 +225,136 @@ declare class ProgressBarComponent implements OnInit {
61
225
  };
62
226
  ordenarPorPropiedad(objData: any[], propiedad: string, numeros?: boolean): any[];
63
227
  static ɵfac: _angular_core.ɵɵFactoryDeclaration<ProgressBarComponent, never>;
64
- static ɵcmp: _angular_core.ɵɵComponentDeclaration<ProgressBarComponent, "jvs-progress-bar", never, { "objThis": { "alias": "objThis"; "required": false; }; "porcentaje": { "alias": "porcentaje"; "required": false; }; "textoCentrado": { "alias": "textoCentrado"; "required": false; }; "textoMostrar": { "alias": "textoMostrar"; "required": false; }; "formatoNumero": { "alias": "formatoNumero"; "required": false; }; "coloresValor": { "alias": "coloresValor"; "required": false; }; }, {}, never, never, true, never>;
228
+ static ɵcmp: _angular_core.ɵɵComponentDeclaration<ProgressBarComponent, "jvs-progress-bar", never, { "porcentaje": { "alias": "porcentaje"; "required": false; }; "textoCentrado": { "alias": "textoCentrado"; "required": false; }; "textoMostrar": { "alias": "textoMostrar"; "required": false; }; "formatoNumero": { "alias": "formatoNumero"; "required": false; }; "coloresValor": { "alias": "coloresValor"; "required": false; }; }, {}, never, never, true, never>;
65
229
  }
66
230
 
67
231
  type TipoValorFuncion<T> = T | ((...param: any) => T);
68
232
  declare function tipoValorFuncion<T>(datoParam: TipoValorFuncion<T>, defaultValue?: T, ...param: any[]): T | undefined;
69
233
 
234
+ /**
235
+ * Celdas declarativas (`celda` en las columnas `text` y `arbol`): la pantalla dice qué piezas lleva
236
+ * la celda y la librería las pinta con sus tamaños y tonos (`<jvs-tabla-celda>`). Los ayudantes
237
+ * para armarlas (`texto`, `nota`, `badge`, `marca`, `icono`, `imagen`, `salto`) están en
238
+ * `tabla-celda/piezas.ts`.
239
+ */
240
+ /**
241
+ * Tonos de las piezas: la pantalla elige por intención, no por color. Qué significa cada uno y cuándo
242
+ * usarlo, en `TONOS` (y en el JSDoc de los atajos: `badge.error`, `texto.exito`…). Las clases Tailwind
243
+ * de cada tono viven en la librería (`CLASES_TONO`, `tabla-celda/tonos.ts`), con su variante oscura.
244
+ */
245
+ type TonoCelda = 'neutro' | 'exito' | 'aviso' | 'error' | 'info' | 'primario';
246
+ /**
247
+ * Un valor por tono, con su significado en el JSDoc: es la forma de los atajos `pieza.tono(…)`
248
+ * (`badge.error('Inactivo')`), así el editor dice qué es cada tono al escribir `badge.`.
249
+ */
250
+ interface PorTono<T> {
251
+ /** Gris. Clasificación sin juicio: "Otros módulos", "Oculto en trámite", "Múlt.". */
252
+ neutro: T;
253
+ /** Verde. Estado correcto o completo: "Activo", "Firmado". */
254
+ exito: T;
255
+ /** Ámbar. Requiere atención pero no bloquea: "Sigla repetida", "Sin firmante", el firmante (★). */
256
+ aviso: T;
257
+ /** Rojo. Estado negativo o bloqueante: "Inactivo", "Sin padre", "Anulado". */
258
+ error: T;
259
+ /** Cian. Dato informativo destacado: "Planilla", "Externo". */
260
+ info: T;
261
+ /** Color de la entidad (oscurecido para que se lea). Marcas E/I/S, ícono del tipo de despacho. */
262
+ primario: T;
263
+ }
264
+ /** Tonos con su uso, en orden, para documentarlos (README, Storybook) o recorrerlos. */
265
+ declare const TONOS: ReadonlyArray<{
266
+ readonly tono: TonoCelda;
267
+ readonly uso: string;
268
+ }>;
269
+ /** Tono de la pieza. */
270
+ interface OpcionesTono {
271
+ /**
272
+ * Tono de la pieza (ver `TonoCelda`). `false`: la librería no pone ningún color (ni fondo ni
273
+ * texto), solo la forma, y la pantalla pone los suyos en `clase`
274
+ * (`'bg-purple-light text-purple-800 [.vex-style-dark_&]:text-purple-300'`). El contraste y el tema
275
+ * oscuro quedan entonces a cargo de la pantalla.
276
+ */
277
+ tono?: TonoCelda | false;
278
+ }
279
+ /** Cómo sale la pieza en el Excel. */
280
+ interface OpcionesExcel {
281
+ /** No sale en el Excel ni en `textoCelda` (p. ej. un badge que repite otra columna). */
282
+ soloPantalla?: boolean;
283
+ }
284
+ /** Escape para lo que la librería no cubre. */
285
+ interface OpcionesClase {
286
+ /**
287
+ * Clases Tailwind adicionales (`uppercase`, `tracking-wide`, un ancho fijo); van al final, después
288
+ * de las de la librería. No para colores de estado: para eso está `tono` (si falta uno, se pide a la
289
+ * librería). Un color en `clase` no gana al del tono (Tailwind ordena la hoja, no el atributo):
290
+ * para colores propios, `tono: false` y los colores aquí.
291
+ */
292
+ clase?: string;
293
+ }
294
+ /** Opciones comunes a las piezas que pueden llevar tooltip y tono (badge, marca, ícono). */
295
+ interface OpcionesPieza extends OpcionesTono, OpcionesExcel, OpcionesClase {
296
+ /** Tooltip de Material; también se escribe como texto oculto para lectores de pantalla. */
297
+ tooltip?: string;
298
+ /** Texto para lectores de pantalla cuando no debe ser el tooltip. */
299
+ ariaLabel?: string;
300
+ }
301
+ /** Texto principal; con `negrita`, en negrita, y con `tono`, del color del tono. */
302
+ interface PiezaTexto extends OpcionesTono, OpcionesExcel, OpcionesClase {
303
+ tipo: 'texto';
304
+ texto: string;
305
+ negrita?: boolean;
306
+ }
307
+ /** Nota gris precedida de "·"; con `bloque`, en una línea aparte y más pequeña. */
308
+ interface PiezaNota extends OpcionesExcel, OpcionesClase {
309
+ tipo: 'nota';
310
+ texto: string;
311
+ bloque?: boolean;
312
+ }
313
+ /** Badge redondeada de 12 px de alto, como las de estado. */
314
+ interface PiezaBadge extends OpcionesPieza {
315
+ tipo: 'badge';
316
+ texto: string;
317
+ /**
318
+ * Ícono registrado (`svgIcon`) de 10 px, siempre delante del texto y del color del badge.
319
+ * Decorativo (`aria-hidden`): lo que dice el badge va en su texto.
320
+ */
321
+ icono?: string;
322
+ }
323
+ /** Marca corta de 12 × 12 px (abreviatura o ícono) con su significado en el tooltip. */
324
+ interface PiezaMarca extends OpcionesPieza {
325
+ tipo: 'marca';
326
+ texto?: string;
327
+ /** Nombre de un ícono registrado (`svgIcon`). */
328
+ icono?: string;
329
+ }
330
+ /** Tamaño del ícono suelto: `'normal'` (12 px, por defecto) o `'grande'` (14 px, lo más grande que cabe en la fila densa). */
331
+ type TamanoIconoCelda = 'normal' | 'grande';
332
+ /** Ícono de 12 px (14 px con `tamano: 'grande'`); con `click`, es un botón que no selecciona la fila. */
333
+ interface PiezaIcono extends OpcionesPieza {
334
+ tipo: 'icono';
335
+ /** Nombre de un ícono registrado (`svgIcon`). */
336
+ icono: string;
337
+ /** `'normal'` (12 px, por defecto) o `'grande'` (14 px); la fila densa no crece con ninguno. */
338
+ tamano?: TamanoIconoCelda;
339
+ click?: (row: any) => void;
340
+ }
341
+ /** Imagen de 20 px (avatar); redonda por defecto. */
342
+ interface PiezaImagen extends OpcionesClase {
343
+ tipo: 'imagen';
344
+ src: string;
345
+ alt: string;
346
+ redonda?: boolean;
347
+ }
348
+ /** Cierra la línea: lo que sigue va debajo. */
349
+ interface PiezaSalto {
350
+ tipo: 'salto';
351
+ }
352
+ type PiezaCelda = PiezaTexto | PiezaNota | PiezaBadge | PiezaMarca | PiezaIcono | PiezaImagen | PiezaSalto;
353
+ /** Un elemento de la celda: texto suelto, número o pieza; `false`, `null` y `undefined` se ignoran. */
354
+ type ElementoCelda = string | number | PiezaCelda | false | null | undefined;
355
+ /** Lo que devuelve `celda(row)`: un texto, una pieza o una lista de ellos. */
356
+ type Celda = ElementoCelda | ReadonlyArray<ElementoCelda>;
357
+
70
358
  interface PopoverConfig<T> {
71
359
  content?: (row: T) => string;
72
360
  template?: TemplateRef<any>;
@@ -74,7 +362,27 @@ interface PopoverConfig<T> {
74
362
  position?: 'top' | 'bottom' | 'left' | 'right';
75
363
  customClass?: string;
76
364
  }
77
- type TiposColumnas = 'yes_no' | 'estiloEstablecido' | 'text' | 'number' | 'money' | 'date' | 'image' | 'estado' | 'badge' | 'progress' | 'checkbox' | 'icon' | 'icons' | 'icon_checkbox' | 'custom' | 'expandir' | 'numeracion_automatica';
365
+ /**
366
+ * Tipos de columna. `image` y `badge` están en desuso: ningún componente los pinta (la celda sale
367
+ * vacía); para una imagen o un badge usa `type: 'text'` con `celda` (`imagen()`, `badge()`).
368
+ */
369
+ type TiposColumnas = 'yes_no' | 'estiloEstablecido' | 'text' | 'number' | 'money' | 'date' | 'image' | 'estado' | 'badge' | 'progress' | 'checkbox' | 'icon' | 'icons' | 'icon_checkbox' | 'custom' | 'expandir' | 'arbol' | 'numeracion_automatica';
370
+ /** Alineación de la cabecera. Sin definir, sigue a la de la celda (ver `cssClasses`). */
371
+ type AlineacionColumna = 'izquierda' | 'centro' | 'derecha';
372
+ /** Cómo sale la columna en el Excel de la tabla (botón `exportar_excel`). */
373
+ interface ColumnaTablaExcel {
374
+ /** Valor de la celda en el Excel. Sirve sobre todo para las columnas `custom`, que si no
375
+ * exportan el texto de su celda tal cual. Recibe el registro y su posición en la lista. */
376
+ valor?: (row: any, indice: number) => any;
377
+ /** Encabezado en el Excel. Por defecto, `labelLista ?? label` en mayúsculas. */
378
+ titulo?: string;
379
+ /** Ancho de la columna en caracteres. */
380
+ ancho?: number;
381
+ /** No exportar esta columna aunque se vea. */
382
+ ocultar?: boolean;
383
+ /** Exportarla aunque no se vea en la tabla (columnas solo para el Excel). */
384
+ incluirOculta?: boolean;
385
+ }
78
386
  interface ColumnaTablaReporte {
79
387
  ocultar?: boolean;
80
388
  transformar?: (row: any) => any;
@@ -95,21 +403,44 @@ interface BaseColumna<T> {
95
403
  tableDataIndex?: number;
96
404
  label: '' | string;
97
405
  labelLista?: string;
406
+ /** Tooltip de la cabecera (p. ej. qué significa una columna de marcas). */
407
+ labelTooltip?: string;
98
408
  property: PropiedadString<T> | string;
99
409
  /** esta propiedad solo se usa cuando se usará una funcion para modificarla */
100
410
  propertyTemplate?: PropiedadString<T> | string;
101
411
  type: TiposColumnas;
102
412
  sort?: TipoValorFuncion<boolean>;
103
413
  sortType?: 'number' | 'date';
414
+ /**
415
+ * Valor con el que se ordena la columna. Sirve sobre todo en las `custom`, cuyo `property`
416
+ * no suele ser un campo del registro (p. ej. `colDespacho` → `row.cNombre`).
417
+ */
418
+ ordenarPor?: (row: any) => any;
104
419
  reportType?: TiposColumnas;
105
420
  visible?: TipoValorFuncion<boolean>;
421
+ /**
422
+ * Importancia de la columna cuando la tabla oculta columnas por falta de espacio
423
+ * (`columnasSiNoCaben="ocultar"`). 1 es la más importante y nunca se oculta. Sin definir, la
424
+ * primera columna de datos vale 1 y las demás siguen su orden: se ocultan de derecha a
425
+ * izquierda. Una con `prioridad` va antes que todas las que no la tienen.
426
+ */
427
+ prioridad?: number;
106
428
  cssClasses?: string[];
107
429
  cssClassesTH?: string[];
430
+ /** Alineación de la cabecera. Sin definir, sigue a la de la celda: `text-center`/`text-right`
431
+ * en `cssClasses`, o la propia del tipo (los iconos, casillas y sí/no van centrados). */
432
+ alineacionCabecera?: AlineacionColumna;
433
+ /** Cómo sale en el Excel de la tabla. */
434
+ excel?: ColumnaTablaExcel;
108
435
  textCss?: string | string[];
109
436
  cssFooterClasses?: string[];
110
437
  datosExtra?: any;
111
438
  popover?: PopoverConfig<T>;
112
439
  reporte?: ColumnaTablaReporte;
440
+ /**
441
+ * @deprecated la librería no lo lee en ningún sitio (ni la tabla ni el Excel). Para el texto del
442
+ * Excel usa `excel.valor`; para la celda, `celda` en las columnas `text`.
443
+ */
113
444
  innerHTMLInvisible?: (row: any) => string;
114
445
  /** @deprecated usar `visible` en su lugar: ejm: visible: ():boolean => {}, visible: boolean */
115
446
  esVisible?: () => boolean;
@@ -124,6 +455,19 @@ interface BaseColumna<T> {
124
455
  }
125
456
  interface ColumnaTexto<T> extends BaseColumna<T> {
126
457
  type: 'text';
458
+ /**
459
+ * Contenido declarativo: texto con nota, badges, marcas, íconos con tooltip o imagen, armado
460
+ * con los ayudantes `texto`, `nota`, `badge`, `marca`, `icono`, `imagen` y `salto`. La librería
461
+ * lo pinta (`<jvs-tabla-celda>`) y lo exporta al Excel como texto. Si vienen `celda` e
462
+ * `innerHTML`, se usa `celda`.
463
+ */
464
+ celda?: (row: T) => Celda;
465
+ /** Con `celda`: líneas máximas; con más, se recorta y el texto completo va al tooltip. */
466
+ lineas?: number;
467
+ /**
468
+ * HTML de la celda, tal cual (no se sanea: no interpoles datos sin escaparlos; ver `html` y
469
+ * `escaparHtml` de `@jvsoft/utils`). Para piezas (nota, badge, ícono…), prefiere `celda`.
470
+ */
127
471
  innerHTML?: (row: any) => string;
128
472
  zeroFill?: number;
129
473
  text?: PropiedadesText;
@@ -155,6 +499,19 @@ interface ColumnaNumber<T> extends BaseColumna<T> {
155
499
  type: 'number';
156
500
  format?: string;
157
501
  }
502
+ /**
503
+ * Columna con la sangría y el botón de plegar del modo árbol (`[arbol]` en la tabla), seguidos
504
+ * del texto de `property` (o de `transformar(row)`). Sin `[arbol]` se ve como una de texto.
505
+ * Para nota, badges o íconos, usa `celda`; para controles u otro contenido propio, una `custom`
506
+ * con `<jvs-tabla-arbol-celda [fila]="row">`.
507
+ */
508
+ interface ColumnaArbol<T> extends BaseColumna<T> {
509
+ type: 'arbol';
510
+ /** Contenido declarativo después de la sangría, como en `ColumnaTexto.celda`. */
511
+ celda?: (row: T) => Celda;
512
+ /** Con `celda`: líneas máximas; con más, se recorta y el texto completo va al tooltip. */
513
+ lineas?: number;
514
+ }
158
515
  interface ColumnaExpandir<T> extends BaseColumna<T> {
159
516
  type: 'expandir';
160
517
  }
@@ -166,17 +523,24 @@ interface ColumnaYesNo<T> extends BaseColumna<T> {
166
523
  noIcon?: string;
167
524
  noTooltip?: string;
168
525
  noValue?: any;
526
+ /**
527
+ * Íconos a la altura de una fila de texto (12 px), para que la columna no haga la fila más
528
+ * alta que las demás. Activo por defecto; `false` vuelve a los íconos de 20 px.
529
+ */
530
+ compacto?: boolean;
169
531
  }
170
532
  interface ColumnaEstiloEstablecido<T> extends BaseColumna<T> {
171
533
  type: 'estiloEstablecido';
172
534
  propertyTemplate: PropiedadString<T> | string;
173
535
  }
174
536
  interface ColumnaOtros<T> extends BaseColumna<T> {
175
- type: 'image' | 'custom' | 'estado' | 'numeracion_automatica';
537
+ type:
538
+ /** @deprecated no se pinta (la celda sale vacía): usa `type: 'text'` con `celda` e `imagen()`. */
539
+ 'image' | 'custom' | 'estado' | 'numeracion_automatica';
176
540
  /** @deprecated */
177
541
  readonly estados?: object[];
178
542
  }
179
- type ColumnaTabla<T> = ColumnaEstiloEstablecido<T> | ColumnaTexto<T> | ColumnaCheckbox<T> | ColumnaMoney<T> | ColumnaIcons<T> | ColumnaProgress<T> | ColumnaDate<T> | ColumnaNumber<T> | ColumnaExpandir<T> | ColumnaYesNo<T> | ColumnaOtros<T>;
543
+ type ColumnaTabla<T> = ColumnaEstiloEstablecido<T> | ColumnaTexto<T> | ColumnaCheckbox<T> | ColumnaMoney<T> | ColumnaIcons<T> | ColumnaProgress<T> | ColumnaDate<T> | ColumnaNumber<T> | ColumnaExpandir<T> | ColumnaArbol<T> | ColumnaYesNo<T> | ColumnaOtros<T>;
180
544
  interface PropiedadesText {
181
545
  separador?: string;
182
546
  cssContenedor?: string;
@@ -198,7 +562,13 @@ interface ColumnaIconsDef {
198
562
  interface IconsIcon {
199
563
  icon: string;
200
564
  iconSize?: string;
565
+ /** Tooltip del ícono (como `tooltip` en botones y piezas). */
566
+ tooltip?: string;
567
+ /** Campo del registro con el tooltip del ícono. */
568
+ tooltipField?: string;
569
+ /** @deprecated Usa `tooltip` (funciona igual; si vienen los dos, manda `tooltip`). */
201
570
  toolTip?: string;
571
+ /** @deprecated Usa `tooltipField` (funciona igual; si vienen los dos, manda `tooltipField`). */
202
572
  toolTipField?: string;
203
573
  contentCss?: string;
204
574
  cssClass?: string;
@@ -219,8 +589,33 @@ interface BotonMantenimiento {
219
589
  esIndependiente?: boolean;
220
590
  ignorarDerecho?: boolean;
221
591
  ignorarReadOnly?: boolean;
592
+ /** Contador del botón (círculo de Material sobre el botón; texto dentro en el segmentado). */
222
593
  badge?: string;
594
+ /**
595
+ * Qué cuenta el contador, para lectores de pantalla: "3 pendientes" con `'pendientes'`. Por
596
+ * defecto, "registros" ("1 registro"). No se ve: Material oculta el número a los lectores y lee esta descripción.
597
+ */
598
+ badgeDescripcion?: string;
223
599
  tooltip?: string;
600
+ /**
601
+ * Motivo que se muestra al pasar el cursor sobre el botón cuando está deshabilitado. Puede
602
+ * ser un texto o una función `(item, tablaRef) => string`, donde `item` es el registro
603
+ * seleccionado. Si no se da (o devuelve vacío), la tabla explica los casos que conoce:
604
+ * falta elegir un registro o falta el permiso; si no, queda el `tooltip` normal.
605
+ */
606
+ tooltipDeshabilitado?: TipoValorFuncion<string | null | undefined>;
607
+ /**
608
+ * Marca el botón como el elegido de su grupo (filtros de la fila secundaria, interruptores).
609
+ * Puede ser un booleano o una función `(item, tablaRef) => boolean`. Sin definir, el botón
610
+ * no es de los que se marcan y se pinta como siempre.
611
+ */
612
+ activo?: TipoValorFuncion<boolean>;
613
+ /**
614
+ * Botones consecutivos de una misma sección con el mismo `grupo` se dibujan como un control
615
+ * segmentado (borde común, divisores finos, el `activo` relleno y el `badge` como texto
616
+ * dentro). Sin `grupo`, el botón se ve como siempre.
617
+ */
618
+ grupo?: string;
224
619
  noContextual?: boolean;
225
620
  subItems?: BotonMantenimiento[];
226
621
  datosExtra?: any;
@@ -241,11 +636,69 @@ interface SeccionesBotonesMantenimiento {
241
636
  derecha?: BotonMantenimiento[];
242
637
  secundario?: BotonMantenimiento[];
243
638
  inferior?: BotonMantenimiento[];
639
+ /** Botones de solo ícono junto a Recargar (exportaciones). Con más de tres se agrupan en
640
+ * un menú "Exportar". Las exportaciones conocidas de `inferior` se mudan aquí solas
641
+ * (ver `exportacionArriba`). */
642
+ herramientas?: BotonMantenimiento[];
244
643
  [key: string]: BotonMantenimiento[] | undefined;
245
644
  }
246
645
  interface TablaMantenimientoSeccionBotones {
247
646
  [key: string]: SeccionesBotonesMantenimiento;
248
647
  }
648
+ /** Valores que se comparan para marcar el botón dinámico elegido. */
649
+ type ValorBotonDinamico = string | number | boolean | null;
650
+ /** Botón "Todos" que acompaña a los botones dinámicos. */
651
+ interface BotonDinamicoTodos {
652
+ label?: string;
653
+ /** Dónde va: al inicio (por defecto) o al final. */
654
+ posicion?: 'inicio' | 'fin';
655
+ /** Badge del botón: un valor, o `true` para la suma de los badges de los demás. */
656
+ badge?: string | number | true;
657
+ /** Valor que representa "todos" al comparar con `valorActivo`. Por defecto `null`
658
+ * (también cuenta `undefined`). */
659
+ valor?: ValorBotonDinamico;
660
+ tooltip?: string;
661
+ }
662
+ /**
663
+ * Configuración de `generarBotonesDinamicos`: un botón por registro, típicamente filtros de la
664
+ * fila `secundario`. Los nombres en inglés se conservan por compatibilidad con
665
+ * `ModuleFrameworkV2.generateDynamicButtons`.
666
+ */
667
+ interface ConfigBotonesDinamicos<T = any> {
668
+ /** `tipo` que llega a `opcionSelecionada` al pulsar cualquiera de ellos. */
669
+ tipo: string;
670
+ labelField: keyof T | ((item: T) => string);
671
+ tooltipField?: keyof T | ((item: T) => string);
672
+ badgeField?: keyof T | ((item: T) => number | string);
673
+ /** Clases propias de cada botón. Sin ellas, el aspecto lo pone la tabla (relleno el
674
+ * elegido, tono claro los demás). */
675
+ class?: string;
676
+ /** Botón "Todos": `true` para el de por defecto, o su configuración. */
677
+ includeAll?: boolean | BotonDinamicoTodos;
678
+ /** Qué va en `datosExtra.item`: el registro (`'all'` o sin definir) o uno de sus campos. */
679
+ extraDataField?: keyof T | 'all';
680
+ /**
681
+ * Campo del registro que se compara (con `===`) con `valorActivo` para saber cuál es el
682
+ * elegido. Va siempre junto con `valorActivo`: con uno solo, ningún botón se marca.
683
+ */
684
+ campoValor?: keyof T;
685
+ /**
686
+ * Valor elegido ahora, o una función que lo devuelve (se evalúa en cada pintado, así sigue a
687
+ * una señal o a un formulario). Para casos que no son "un campo igual a un valor", aplica
688
+ * `.map()` al resultado y pon `activo` a cada botón.
689
+ */
690
+ valorActivo?: ValorBotonDinamico | (() => ValorBotonDinamico | undefined);
691
+ /**
692
+ * `'chips'` (por defecto): botones redondeados separados con `ml-1`. `'segmentado'`: todos
693
+ * (también "Todos") van en un control segmentado, con `grupo` igual al `tipo`.
694
+ */
695
+ estilo?: 'chips' | 'segmentado';
696
+ /**
697
+ * Sin contador cuando vale 0 (el botón sigue). Por defecto `false`: el "0" se muestra, como
698
+ * siempre. Vale también para el contador de "Todos".
699
+ */
700
+ ocultarCero?: boolean;
701
+ }
249
702
 
250
703
  interface OpcionSeleccionada {
251
704
  readonly tableDataIndex?: number;
@@ -314,6 +767,16 @@ interface Archivo {
314
767
  }
315
768
 
316
769
  declare function capitalizarTexto(texto: string): string;
770
+ /**
771
+ * Un botón por registro, para filtros rápidos de la fila `secundario` (despachos, grupos…),
772
+ * con su conteo como badge y, si se pide, un botón "Todos" al inicio o al final.
773
+ *
774
+ * No pone colores: si se indica cuál es el elegido (`campoValor` + `valorActivo`),
775
+ * cada botón declara `activo` y la tabla pinta relleno el elegido y en tono claro los demás.
776
+ * Sin esas opciones los botones también declaran `activo` (en `false`), para que todos tengan
777
+ * el mismo aspecto de filtro.
778
+ */
779
+ declare function generarBotonesDinamicos<T = any>(data: T[] | null | undefined, config: ConfigBotonesDinamicos<T>): BotonMantenimiento[];
317
780
 
318
781
  declare class TablaMantenimientoService {
319
782
  get templateBotonesComunes(): BotonMantenimiento[];
@@ -327,8 +790,14 @@ interface MantenimientoFilaExtraData {
327
790
  esVisible?(item?: any): boolean;
328
791
  }
329
792
  type TiposControlBusqueda = 'query' | 'simple' | '';
330
- declare class TablaMantenimientoComponent<T> implements OnInit, AfterContentInit, OnChanges {
331
- private fb;
793
+ /** Un tramo de una sección de botones: un botón suelto o un control segmentado (`grupo`). */
794
+ interface TramoBotones {
795
+ grupo?: string;
796
+ botones: BotonMantenimiento[];
797
+ /** Margen del tramo respecto al anterior (`ml-1`, o el `m*-` del primer botón del grupo). */
798
+ margen: string;
799
+ }
800
+ declare class TablaMantenimientoComponent<T> implements OnInit, AfterContentInit, AfterViewInit, AfterViewChecked, OnChanges, ControlArbolTabla {
332
801
  overlay: Overlay;
333
802
  viewContainerRef: ViewContainerRef;
334
803
  protected tablaMantenimientoService: TablaMantenimientoService;
@@ -341,6 +810,11 @@ declare class TablaMantenimientoComponent<T> implements OnInit, AfterContentInit
341
810
  get templateBotonesComunes(): BotonMantenimiento[];
342
811
  get templateColumnasTabla(): ColumnaTabla<any>[];
343
812
  dataSuscription: Observable<any> | undefined;
813
+ /**
814
+ * @deprecated Componente que contiene la tabla. Solo sirve para el respaldo de selección
815
+ * `objThis.seleccionados[nombreColeccion]`, que también se retirará: usa `[(selectionModel)]`.
816
+ * Ya no es obligatorio; las pantallas que usan `selectionModel` no necesitan pasarlo.
817
+ */
344
818
  objThis: any;
345
819
  nombreColeccion: any;
346
820
  busquedaValor: _angular_core.InputSignal<string>;
@@ -352,6 +826,7 @@ declare class TablaMantenimientoComponent<T> implements OnInit, AfterContentInit
352
826
  filaExtraHeader: MantenimientoFilaExtraData | any;
353
827
  filaFooter: boolean;
354
828
  botonesCRUD: string;
829
+ /** @deprecated El doble clic ya llega por `opcionSelecionada` con tipo `seleccionar`. */
355
830
  dblclickItem: EventEmitter<any>;
356
831
  objBotonesCRUD: BotonMantenimiento[];
357
832
  classSeleccionado: string[];
@@ -361,20 +836,147 @@ declare class TablaMantenimientoComponent<T> implements OnInit, AfterContentInit
361
836
  opcionSelecionada: EventEmitter<any>;
362
837
  opcBusqueda: EventEmitter<any>;
363
838
  accionRecargar: EventEmitter<any>;
364
- set selectionModel(val: SelectionModel<any>);
365
- selectionModelChange: EventEmitter<SelectionModel<any>>;
839
+ /**
840
+ * Registro seleccionado. El nombre viene de cuando se pensó guardarlo en un
841
+ * `SelectionModel` del CDK; lo que viaja es la fila, y así lo usan las apps con el enlace
842
+ * de dos sentidos `[(selectionModel)]`.
843
+ */
844
+ set selectionModel(val: T | null | undefined);
845
+ selectionModelChange: EventEmitter<T | null>;
846
+ /**
847
+ * Cuando la selección cambia desde fuera (`[selectionModel]`, `seleccionarPorId()`,
848
+ * `irASeleccion()`), la tabla lleva la fila a la vista: con paginación en cliente va a la
849
+ * página que la contiene (según el orden y el filtro activos), limpia el buscador simple si la
850
+ * ocultaba, la desplaza a la vista si hace falta y la resalta un instante. Un clic, el teclado
851
+ * o una recarga que mantiene la misma fila no mueven nada. Con paginación en el servidor solo
852
+ * la desplaza si viene en la página cargada. Con `false` no se hace nada de esto. Sin el
853
+ * input, manda `provideTablaMantenimiento({seguirSeleccion})`, y si no hay, `true`.
854
+ */
855
+ seguirSeleccion: _angular_core.InputSignal<boolean | undefined>;
856
+ /** Si la tabla sigue la selección: el input, si no la configuración global, si no `true`. */
857
+ readonly debeSeguirSeleccion: _angular_core.Signal<boolean>;
858
+ /** Identificador (`propiedadSeleccion`) de la fila que falta llevar a la vista. */
859
+ private seleccionASeguir;
860
+ /** Si al seguir la selección se cambió de página: entonces la fila se resalta aunque ya se vea. */
861
+ private seguimientoCambioPagina;
366
862
  isRecargarUsed: boolean;
367
863
  filaExtraTemplate: TemplateRef<any> | undefined;
368
864
  paginator: MatPaginator;
865
+ /**
866
+ * Estático: la tabla no está dentro de un bloque condicional, y así existe antes de que se
867
+ * pinte la cabecera. Lo necesita el `provide: MatSort` del componente (columnas `custom`).
868
+ */
369
869
  sort: MatSort;
370
870
  exportarExcel: boolean;
371
- busquedaCompacta: _angular_core.InputSignal<boolean>;
871
+ /**
872
+ * Buscador reducido a un icono que abre un menú con el campo. `true` siempre, `false` nunca y
873
+ * `'auto'` (por defecto) cuando la banda de la tabla es angosta: decide el ancho de la tabla,
874
+ * no el de la ventana, así funciona también en paneles angostos.
875
+ */
876
+ busquedaCompacta: _angular_core.InputSignal<boolean | "auto">;
877
+ /** Ancho actual de la banda; lo mide un `ResizeObserver`. `null` mientras no se mide. */
878
+ private readonly anchoBanda;
879
+ /**
880
+ * Tramo de ancho de la banda, con los tamaños de contenedor de Tailwind (`@xl` = 36 rem,
881
+ * `@3xl` = 48 rem): `angosta` pasa el buscador a icono y los grupos de botones al menú ≡.
882
+ * Sin medir (SSR, pruebas sin `ResizeObserver`) cuenta como `amplia`.
883
+ */
884
+ readonly tramoBanda: _angular_core.Signal<"angosta" | "media" | "amplia">;
885
+ /** Si el buscador se muestra como icono en este momento. */
886
+ readonly busquedaEsCompacta: _angular_core.Signal<boolean>;
887
+ bandaTabla?: ElementRef<HTMLElement>;
888
+ contenedorTabla?: ElementRef<HTMLElement>;
889
+ /**
890
+ * Qué hace la tabla con las columnas cuando no caben en el ancho de su contenedor.
891
+ * - `'ajustar'` (por defecto): todas se pintan y el texto se parte, como siempre.
892
+ * - `'ocultar'`: oculta las de menor prioridad (ver `prioridad` en la columna) hasta que el
893
+ * resto quepa; avisa en el botón de columnas y las sigue exportando al Excel.
894
+ */
895
+ columnasSiNoCaben: _angular_core.InputSignal<"ajustar" | "ocultar">;
896
+ private readonly _columnasOcultasPorEspacio;
897
+ /** Columnas ocultas ahora mismo por falta de espacio (`property`), por si la pantalla quiere avisar. */
898
+ readonly columnasOcultasPorEspacio: _angular_core.Signal<ReadonlySet<string>>;
899
+ /** Ancho útil del contenedor de la tabla (sin la barra de desplazamiento). `null` mientras no se mide. */
900
+ private readonly anchoContenedor;
901
+ private readonly medirTexto;
902
+ /** Última medida de cada columna: la que se oculta ya no tiene celdas que medir. */
903
+ private readonly medidasColumnas;
904
+ /** Fuentes de la tabla, leídas en la última medición que tuvo cabecera. */
905
+ private fuentesTabla;
906
+ private cuadroCalculoColumnas;
907
+ /** Columnas candidatas del último cálculo, para notar cuándo cambia un `visible` dinámico. */
908
+ private firmaColumnas;
909
+ private readonly recalcularAlCambiarModo;
910
+ inputBusquedaCompacta?: ElementRef<HTMLInputElement>;
911
+ /**
912
+ * Ancho máximo del buscador (cualquier medida CSS). El alto no cambia. Por defecto, los
913
+ * 150 px de siempre.
914
+ */
915
+ busquedaAncho: _angular_core.InputSignal<string>;
916
+ /** Nombre de la hoja y del archivo del Excel. Por defecto, `nombreColeccion`. */
917
+ nombreExcel: _angular_core.InputSignal<string | undefined>;
918
+ /** Entrada animada de las filas, una por una. Con `false` aparecen de golpe. */
919
+ animarFilas: _angular_core.InputSignal<boolean>;
920
+ /**
921
+ * Barra de carga indeterminada entre la banda y la cabecera mientras es `true`. Sin el input
922
+ * (`undefined`) no se dibuja nada; con él, el hueco de la barra queda reservado para que la
923
+ * tabla no salte al cargar.
924
+ */
925
+ cargando: _angular_core.InputSignal<boolean | undefined>;
926
+ /**
927
+ * Las exportaciones (`TIPOS_EXPORTACION_TABLA`) van junto a Recargar, como íconos, aunque
928
+ * vengan en `inferior`. Con `false` se quedan donde la pantalla las puso. Sin el input, manda
929
+ * `provideTablaMantenimiento({exportacionArriba})`, y si no hay, `true`.
930
+ */
931
+ exportacionArriba: _angular_core.InputSignal<boolean | undefined>;
932
+ /** Si las exportaciones suben junto a Recargar: el input, si no la configuración global, si no `true`. */
933
+ readonly subeExportacion: _angular_core.Signal<boolean>;
934
+ /**
935
+ * Las cabeceras siguen la alineación de su contenido (texto a la izquierda, `text-right`
936
+ * a la derecha…), y en las `custom` se respeta `text-left`/`text-right` del `th`. Por
937
+ * defecto `false`: todas centradas, como siempre. Una columna puede pedirlo sola con
938
+ * `alineacionCabecera`.
939
+ */
940
+ alinearCabecerasConContenido: _angular_core.InputSignal<boolean>;
941
+ /**
942
+ * Colores de la tabla (fila elegida, botones `activo`, segmentados): `false` usa los colores
943
+ * estándar fijos; `true`, los del tema de la entidad (`--color-primary`). Sin definir, manda
944
+ * lo que diga `provideTablaMantenimiento({coloresTema})`, y si no hay, estándar.
945
+ */
946
+ coloresTema: _angular_core.InputSignal<boolean | undefined>;
947
+ private readonly configGlobal;
948
+ readonly usaColoresTema: _angular_core.Signal<boolean>;
949
+ private readonly configCabeceras;
950
+ private readonly sincronizarCabeceras;
372
951
  alturaFull: _angular_core.InputSignal<boolean>;
373
952
  pageSize: number;
374
953
  pageSizeOptions: number[];
954
+ /**
955
+ * @deprecated Entrega la instancia interna del `MatTableDataSource`, que ahora se reutiliza
956
+ * entre cargas: quien la guarde estará tocando el estado de la tabla por la espalda.
957
+ */
375
958
  dataSourceChange: EventEmitter<any>;
376
959
  resultados: EventEmitter<any>;
377
- dataSource: MatTableDataSource<T, MatPaginator>;
960
+ dataSource: TablaMantenimientoDataSource<T>;
961
+ /**
962
+ * Jerarquía: la tabla recibe la lista plana completa y la pinta como árbol (ver
963
+ * {@link ConfigArbolTabla}). Sin el input, nada cambia. La sangría y el botón de plegar van
964
+ * en una columna `type: 'arbol'` o, dentro de una `custom`, con `<jvs-tabla-arbol-celda>`.
965
+ */
966
+ arbol: _angular_core.InputSignal<ConfigArbolTabla<T> | null | undefined>;
967
+ private readonly aplicarArbol;
968
+ /**
969
+ * El buscador simple compara sin tildes ni mayúsculas. Es el mismo criterio que el de
970
+ * `MatTableDataSource` (todos los valores del registro, uno tras otro), con el texto
971
+ * normalizado a ambos lados. Quien quiera otro criterio puede cambiar `filterPredicate`.
972
+ */
973
+ private static crearDataSource;
974
+ /**
975
+ * Campos en los que busca el buscador simple. Por defecto, todos los del registro; conviene
976
+ * limitarlo cuando el registro trae datos de otros (p. ej. el nombre del padre), que harían
977
+ * coincidir filas por lo que no se ve.
978
+ */
979
+ busquedaCampos: _angular_core.InputSignal<string[] | null>;
378
980
  table: MatTable<T>;
379
981
  columnDefs: QueryList<MatColumnDef>;
380
982
  componenteCargadoTotalmente: boolean;
@@ -386,9 +988,16 @@ declare class TablaMantenimientoComponent<T> implements OnInit, AfterContentInit
386
988
  pageLength: null;
387
989
  };
388
990
  ignorarDerechos: boolean;
389
- derechosActuales: any;
991
+ private derechosDelPadre;
992
+ private _derechosActuales;
993
+ get derechosActuales(): any;
994
+ /**
995
+ * Permisos con los que se habilitan los botones. Normalmente se leen solos del `data` de la
996
+ * ruta, pero si la pantalla los pasa a mano, mandan los suyos: antes cada navegación
997
+ * sobrescribía lo que el padre acababa de poner.
998
+ */
999
+ set derechosActuales(val: any);
390
1000
  rows: QueryList<ElementRef<HTMLTableRowElement>>;
391
- rowFooter: ElementRef<HTMLTableRowElement>;
392
1001
  mouseEvent$: Subscription | undefined;
393
1002
  overlayRef: OverlayRef | undefined;
394
1003
  userMenu: TemplateRef<any>;
@@ -400,7 +1009,7 @@ declare class TablaMantenimientoComponent<T> implements OnInit, AfterContentInit
400
1009
  chkLista: DataModel;
401
1010
  bDireccionOrden: _angular_core.WritableSignal<number>;
402
1011
  mostrarBotonOrden: _angular_core.InputSignal<boolean>;
403
- constructor(fb: FormBuilder, overlay: Overlay, viewContainerRef: ViewContainerRef, tablaMantenimientoService: TablaMantenimientoService, cdRef: ChangeDetectorRef);
1012
+ constructor(overlay: Overlay, viewContainerRef: ViewContainerRef, tablaMantenimientoService: TablaMantenimientoService, cdRef: ChangeDetectorRef);
404
1013
  busquedaTipo: _angular_core.InputSignalWithTransform<TiposControlBusqueda, string>;
405
1014
  private _leyenda;
406
1015
  get leyenda(): {
@@ -416,15 +1025,104 @@ declare class TablaMantenimientoComponent<T> implements OnInit, AfterContentInit
416
1025
  set idTabla(val: string[] | string);
417
1026
  private _columnasTabla;
418
1027
  get columnasTabla(): ColumnaTabla<any>[];
1028
+ /**
1029
+ * Columnas a pintar, mezcladas con el catálogo del servicio.
1030
+ *
1031
+ * Devuelve una lista nueva con copias: antes transformaba el array del consumidor en su
1032
+ * sitio, así que su definición quedaba con el tipo cambiado (`estado` pasa a `icons`) y las
1033
+ * columnas `custom` marcadas como no visibles. Reutilizar esa misma definición en otra
1034
+ * tabla dejaba la columna `custom` oculta para siempre, porque la segunda pasada guardaba
1035
+ * como visibilidad original el `false` que había dejado la primera.
1036
+ */
419
1037
  set columnasTabla(val: ColumnaTabla<any>[]);
1038
+ /**
1039
+ * Las `custom` se ocultan hasta que aparece su `matColumnDef` en el contenido (si no, la tabla
1040
+ * fallaría al pintarlas). Aquí se registra cada definición en la tabla y se devuelve su
1041
+ * visibilidad a la columna. Se llama al iniciar el contenido, al cambiar las columnas y cuando
1042
+ * el consumidor agrega definiciones después (`columnDefs.changes`).
1043
+ */
1044
+ private confirmarColumnasCustom;
420
1045
  private _botonesMenu;
421
1046
  get botonesMenu(): SeccionesBotonesMantenimiento;
1047
+ /**
1048
+ * Los botones que tocan pintar. En solo lectura quedan los marcados con `ignorarReadOnly`,
1049
+ * y de los que tienen submenú quedan sus opciones permitidas.
1050
+ *
1051
+ * Devuelve estructuras nuevas y no toca `botonesMenu`. Antes filtraba sobre el propio
1052
+ * estado, y como la plantilla lo consulta seis veces por ciclo, cada lectura se comía lo
1053
+ * que quedaba: en solo lectura la tabla acababa sin ningún botón, ni siquiera los CRUD.
1054
+ * La condición de los submenús estaba además al revés, así que descartaba justo los
1055
+ * botones cuyas opciones sí estaban permitidas.
1056
+ */
422
1057
  get botonesMenuFinal(): SeccionesBotonesMantenimiento;
423
1058
  set botonesMenu(val: SeccionesBotonesMantenimiento);
1059
+ /**
1060
+ * Botones del menú ≡ en pantallas angostas. La fila secundaria se ve también ahí, así que
1061
+ * no se repite dentro del menú.
1062
+ */
1063
+ get listaMenuMovil(): BotonMantenimiento[];
424
1064
  get listaMenuCompleto(): BotonMantenimiento[];
1065
+ /** Si la columna se ofrece en el menú de columnas. `noMostrar` es el alias antiguo. */
1066
+ esColumnaEnLista(column: any): boolean;
1067
+ /**
1068
+ * Lo que el usuario eligió en el menú de columnas, por `property`. Va aparte para no pisar
1069
+ * la definición: antes se escribía `column.visible = true/false`, y una columna declarada
1070
+ * con una función (p. ej. visible según un filtro) dejaba de seguirla para siempre.
1071
+ */
1072
+ private visibilidadElegida;
1073
+ /** Muestra u oculta la columna por elección del usuario. */
1074
+ elegirVisibilidadColumna(column: any, visible: boolean): void;
1075
+ /**
1076
+ * Si la columna se pinta ahora mismo, sin escribir la respuesta dentro de la columna.
1077
+ * `paraExcel` no tiene en cuenta el ancho: lo que se oculta por falta de espacio se exporta.
1078
+ */
1079
+ esColumnaVisible(column: any, paraExcel?: boolean): boolean;
1080
+ /** `visible` (o el antiguo `esVisible()`) de la columna, sin elección del usuario ni espacio. */
1081
+ private visiblePorDefinicion;
1082
+ /** Si la columna está oculta por falta de espacio (para el menú de columnas). */
1083
+ ocultaPorEspacio(column: any): boolean;
1084
+ /** Tooltip del botón de columnas: con columnas ocultas por espacio, cuáles son. */
1085
+ tooltipColumnas(): string;
1086
+ /** Columnas que se pintarían si hubiera espacio: en la lista, con `visible` o marcadas por el usuario. */
1087
+ private columnasCandidatas;
1088
+ /** Recalcula qué columnas caben en el siguiente cuadro (una vez por cuadro). */
1089
+ private programarCalculoColumnas;
1090
+ /**
1091
+ * Mide el ancho natural de las columnas candidatas y oculta las que no caben. Sin medida del
1092
+ * contenedor no oculta nada. Las medidas son del ancho natural, no del pintado: mostrar u
1093
+ * ocultar una columna no cambia la entrada del cálculo, así que no hay realimentación.
1094
+ */
1095
+ private calcularColumnasPorEspacio;
1096
+ private fijarOcultasPorEspacio;
1097
+ /**
1098
+ * Columnas que toca pintar. Consultarlo no escribe en las columnas del consumidor: antes
1099
+ * copiaba `noMostrar` a `noMostrarEnLista` y fijaba `visible`, de modo que una columna
1100
+ * declarada con una función dejaba de ser dinámica en cuanto se pintaba la tabla una vez.
1101
+ *
1102
+ * Sigue escribiendo `sort` cuando hay fila extra, porque es el único canal por el que la
1103
+ * definición de columnas se entera de que no debe ofrecer el ordenamiento.
1104
+ */
425
1105
  get objVisibleColumns(): ColumnaTabla<any>[];
1106
+ /**
1107
+ * Columnas que recibe la definición de columnas. Con fila extra desplegable el
1108
+ * ordenamiento se bloquea, y eso se resuelve aquí entregando copias: antes se lograba
1109
+ * escribiendo `sort: false` dentro de la columna del consumidor, que quedaba marcada para
1110
+ * siempre aunque la tabla dejara de usar la fila extra.
1111
+ */
1112
+ get columnasParaDefinir(): ColumnaTabla<any>[];
1113
+ /**
1114
+ * Columnas del Excel: las visibles, menos las marcadas `excel.ocultar`, más las ocultas con
1115
+ * `excel.incluirOculta`, en el orden en que se declararon.
1116
+ */
1117
+ get columnasExcel(): ColumnaTabla<any>[];
426
1118
  get visibleColumns(): string[];
427
1119
  get tieneCheckbox(): false | _jvsoft_components_tabla_mantenimiento.ColumnaCheckbox<any>;
1120
+ /**
1121
+ * Última búsqueda del registro seleccionado, guardada para no repetirla. Vale mientras no
1122
+ * cambien ni la selección ni los datos: `classFila` consulta esto una vez por fila y por
1123
+ * ciclo, así que sin memoria una tabla de N filas hacía N búsquedas sobre N registros.
1124
+ */
1125
+ private cacheSeleccionado;
428
1126
  get buscarItemSeleccionado(): any;
429
1127
  get objSeleccionado(): any;
430
1128
  set objSeleccionado(val: any);
@@ -435,6 +1133,71 @@ declare class TablaMantenimientoComponent<T> implements OnInit, AfterContentInit
435
1133
  rowTooltip: (item: any) => string;
436
1134
  soloIconos?: TipoValorFuncion<boolean>;
437
1135
  ngOnInit(): void;
1136
+ /**
1137
+ * Si los datos llegaron antes de que existiera la vista (un `BehaviorSubject` con valor, una
1138
+ * señal con `toObservable`), `setData` no encontró paginador ni orden que enganchar y la tabla
1139
+ * pintaba todas las filas aunque el paginador dijera "1 – 25 de 100". Se enganchan aquí, salvo
1140
+ * que pagine el servidor (`iTotalRegistros`).
1141
+ */
1142
+ ngAfterViewInit(): void;
1143
+ ngAfterViewChecked(): void;
1144
+ /**
1145
+ * Selecciona la fila cuyo `idTabla` vale `valor` (uno o varios valores, en el orden de
1146
+ * `idTabla`) y la lleva a la vista. Pensado para después de guardar: el procedimiento devuelve
1147
+ * el id y la pantalla no tiene que buscar el registro. Si la fila todavía no está en los datos
1148
+ * (la recarga viene en camino), la selección queda fijada y se aplica, avisando al padre,
1149
+ * cuando lleguen. Devuelve si la fila ya estaba en los datos.
1150
+ */
1151
+ seleccionarPorId(valor: unknown | unknown[]): boolean;
1152
+ /**
1153
+ * Lleva a la vista la fila seleccionada ahora, aunque sea la misma de antes. Para después de
1154
+ * editar un registro que puede haber cambiado de posición (la lista se ordena por un campo que
1155
+ * se editó): la tabla por sí sola no se mueve cuando la selección no cambia.
1156
+ */
1157
+ irASeleccion(): void;
1158
+ /**
1159
+ * Si hay una fila por seguir y está en los datos, pone el paginador en su página (paginación
1160
+ * en cliente, según el orden y el filtro activos). Si el buscador simple la oculta, lo limpia.
1161
+ * Con paginación en el servidor no hay página que calcular: solo se desplazará si viene en la
1162
+ * página cargada. Devuelve si cambió de página.
1163
+ *
1164
+ * Se llama al fijar la selección y al llegar datos, nunca desde `ngAfterViewChecked`: mover
1165
+ * el paginador después de comprobar la vista daría NG0100 en desarrollo.
1166
+ */
1167
+ private irAPaginaDeSeleccion;
1168
+ /**
1169
+ * Segunda parte del seguimiento, cuando la fila ya está pintada: si no se ve, se desplaza a
1170
+ * la vista; si hubo que desplazarla o cambiar de página, se resalta un instante. Si no está
1171
+ * pintada todavía (otra página, datos por llegar) se vuelve a intentar en el siguiente ciclo.
1172
+ */
1173
+ private desplazarASeleccion;
1174
+ /**
1175
+ * Si la fila se ve entera: dentro de la ventana, de cualquier contenedor con scroll propio
1176
+ * que la envuelva, y no tapada por la cabecera fija de la tabla.
1177
+ */
1178
+ private filaALaVista;
1179
+ private resaltarFila;
1180
+ /** Filas desplegadas, por su identificador. El estado es de la tabla, no del registro. */
1181
+ private filasExpandidas;
1182
+ /** Se pasa a la definición de columnas, que pregunta por fila al pintar el icono. */
1183
+ readonly estaExpandidaFn: (item: any) => boolean;
1184
+ /**
1185
+ * Si la fila está desplegada. Además del estado propio se mira `isExpanded` dentro del
1186
+ * registro, porque varias pantallas lo traen puesto para abrir una fila de entrada
1187
+ * (archivo digital hace `firstRow.isExpanded = true` antes de entregar los datos).
1188
+ */
1189
+ estaExpandida(item: any): boolean;
1190
+ /**
1191
+ * Despliega o pliega la fila. El estado vive aquí.
1192
+ *
1193
+ * @deprecated El espejo `isExpanded` dentro del registro se mantiene solo por
1194
+ * compatibilidad y se retirará: las pantallas que lo leen (`*ngIf="row.isExpanded"`) o lo
1195
+ * escriben para abrir una fila de entrada deben pasar a `estaExpandida()` y
1196
+ * `alternarExpansion()`.
1197
+ */
1198
+ alternarExpansion(item: any): void;
1199
+ /** Toma del `data` de la ruta lo que la pantalla no haya pasado por entrada. */
1200
+ aplicarDerechosDeRuta(data: any): void;
438
1201
  ngAfterContentInit(): void;
439
1202
  ngOnChanges(changes: SimpleChanges): void;
440
1203
  trackByFn: (index: number, item: any) => string;
@@ -442,28 +1205,314 @@ declare class TablaMantenimientoComponent<T> implements OnInit, AfterContentInit
442
1205
  agregarBotonesExportacion(): void;
443
1206
  actualizarCrud(): void;
444
1207
  classFila(item: any): any[];
1208
+ /**
1209
+ * Memoria del tooltip por registro. La plantilla lo pide tres veces por fila (texto,
1210
+ * `matTooltipDisabled` y la clase `regTooltip`), y cada llamada ejecuta el `rowTooltip` del
1211
+ * consumidor. Se recalcula cuando cambian los datos.
1212
+ */
1213
+ private cacheTooltip;
445
1214
  procesarRowTooltip(item: any): string;
1215
+ private calcularRowTooltip;
446
1216
  subItemsActivos(btn: any, item: any): boolean;
447
- get noData(): any;
1217
+ /** Se arma una sola vez: la plantilla lo consume con `async`, y devolver un observable nuevo
1218
+ * en cada ciclo hacía que la tubería se desuscribiera y volviera a suscribirse sin parar. */
1219
+ private noData$;
1220
+ get noData(): Observable<boolean>;
1221
+ /** Texto escrito en el buscador, sin espacios de los extremos. Vacío si no se busca nada. */
1222
+ get textoBuscado(): string;
1223
+ /** Borra el texto del buscador: la tabla vuelve a filtrar (o a consultar) sin él. */
1224
+ limpiarBusqueda(): void;
448
1225
  onFilterChange(value: string): void;
1226
+ /**
1227
+ * Si el texto del buscador deja fuera la fila seleccionada, la selección se suelta y se avisa
1228
+ * al padre (`selectionModelChange` con `null`): así los botones no actúan sobre una fila que no
1229
+ * se ve. En árbol, una fila que queda como camino de una coincidencia (atenuada) sigue a la vista.
1230
+ *
1231
+ * Precedencia con `seguirSeleccion`: lo último que pasó manda. Si la pantalla fija una
1232
+ * selección que la búsqueda oculta, la tabla limpia la búsqueda (`irAPaginaDeSeleccion`); si
1233
+ * el usuario escribe un texto que oculta la selección, la selección se suelta. Una selección
1234
+ * fijada que aún no llegó en los datos no se suelta.
1235
+ */
1236
+ private soltarSeleccionOcultaPorBusqueda;
449
1237
  toggleColumnVisibility(column: any, event: any): void;
450
1238
  cargarData(retorno?: boolean): any;
451
1239
  toggleDireccionOrden(): void;
452
1240
  setData(data: any): void;
453
1241
  botonDisabled(btn: BotonMantenimiento, item: any): boolean | undefined;
1242
+ private esExportacion;
1243
+ /**
1244
+ * Margen del control segmentado: las clases de margen (`ml-2`, `mx-1`…) del primer botón del
1245
+ * grupo, que dentro del segmento no tendrían efecto. Así un grupo se separa de lo anterior
1246
+ * igual que un botón suelto.
1247
+ */
1248
+ margenSegmentado(botones: BotonMantenimiento[] | undefined | null): string;
1249
+ /**
1250
+ * Parte una sección en tramos: los botones consecutivos con el mismo `grupo` forman un
1251
+ * control segmentado; los demás van solos, como siempre. Del grupo quedan los visibles
1252
+ * (`esVisible`); un botón con submenú no entra en un grupo.
1253
+ */
1254
+ segmentosBotones(botones: BotonMantenimiento[] | undefined | null): TramoBotones[];
1255
+ /** Clases de un botón de la barra: las suyas y, si declara `activo`, el aspecto de filtro. */
1256
+ claseBotonBarra(btn: BotonMantenimiento, item: any): string;
1257
+ /** Clases de un ítem de menú (≡ o contextual): el elegido de su grupo va en negrita con una marca. */
1258
+ claseItemMenu(btn: BotonMantenimiento, item: any): string;
1259
+ /** Botones junto a Recargar: `herramientas` más las exportaciones de `inferior`. */
1260
+ get botonesHerramientas(): BotonMantenimiento[];
1261
+ /** Los que quedan en la barra de abajo. */
1262
+ get botonesInferior(): BotonMantenimiento[];
1263
+ /** Herramientas que se ven ahora (para decidir si se agrupan en el menú "Exportar"). */
1264
+ get botonesHerramientasVisibles(): BotonMantenimiento[];
1265
+ /**
1266
+ * Clases del botón de herramientas. Va solo con ícono, como Recargar: se quitan color, fondo,
1267
+ * borde y espaciado de la clase del botón (pensados para un botón con texto), y PDF va en rojo
1268
+ * y Excel en verde en todas las pantallas, para reconocerlos de un vistazo. El resto hereda el
1269
+ * color de la banda.
1270
+ */
1271
+ claseHerramienta(btn: BotonMantenimiento): string;
1272
+ /**
1273
+ * Ícono de un botón de herramientas. Los de PDF y Excel del catálogo (y las exportaciones
1274
+ * sin ícono) usan los de respaldo de la tabla, que no dependen del CDN de íconos.
1275
+ */
1276
+ iconoHerramienta(btn: BotonMantenimiento): string;
1277
+ /** Texto del botón: su `label`, el nombre del derecho o el tipo en palabras. */
1278
+ etiquetaBoton(btn: BotonMantenimiento): string;
1279
+ /** Si el botón está deshabilitado, con la misma regla que la plantilla. */
1280
+ estaBotonDeshabilitado(btn: BotonMantenimiento, item: any): boolean;
1281
+ /**
1282
+ * Por qué el botón está deshabilitado. Primero el `tooltipDeshabilitado` del botón; si no
1283
+ * hay, los casos que la tabla conoce. Vacío si no está deshabilitado o no se sabe.
1284
+ */
1285
+ motivoDeshabilitado(btn: BotonMantenimiento, item: any): string;
1286
+ /** Tooltip del botón habilitado: el `tooltip` o, si no, su texto. */
1287
+ tooltipBoton(btn: BotonMantenimiento): string;
1288
+ /**
1289
+ * Descripción del contador (`matBadgeDescription`) para lectores de pantalla: "3 registros"
1290
+ * ("1 registro") o con `badgeDescripcion`. Sin contador, vacía (Material no agrega nada).
1291
+ */
1292
+ descripcionContador(btn: BotonMantenimiento): string;
1293
+ /**
1294
+ * Si el botón es el elegido de su grupo. `null` cuando el botón no declara `activo`: así
1295
+ * no lleva `aria-pressed` y se pinta como siempre.
1296
+ */
1297
+ esBotonActivo(btn: BotonMantenimiento, item: any): boolean | null;
454
1298
  propiedadSeleccion(item: any): string;
455
1299
  esSeleccionActual(item: any): boolean;
1300
+ /**
1301
+ * `Supr` sobre la fila pide eliminar. Se ignora cuando la tecla viene de un campo de la
1302
+ * celda: ahí el usuario está borrando texto, no el registro.
1303
+ */
1304
+ teclaEliminarEnFila(item: any, evento: Event): void;
1305
+ /**
1306
+ * Espacio sobre la fila enfocada. Con columna de casillas marca o desmarca la suya, que es
1307
+ * lo que se espera de esa tecla en una lista con selección múltiple; sin casillas se
1308
+ * comporta como Enter y abre el registro.
1309
+ */
1310
+ teclaEspacioEnFila(item: any): void;
1311
+ /**
1312
+ * El teclado movió el foco a otra fila: se selecciona, pero sin avisar `ver`. Recorrer la
1313
+ * tabla con las flechas dispararía un aviso por fila, y los padres suelen cargar datos con él.
1314
+ */
1315
+ seleccionarFilaPorId(id: string): void;
1316
+ /**
1317
+ * Clic sobre una fila. `evento.detail` es el contador de clics del navegador: en un clic
1318
+ * suelto vale 1 y la selección alterna, así que volver a pulsar la fila la deselecciona.
1319
+ * El segundo clic de un doble clic llega con 2: ahí la selección se fuerza —alternar dejaba
1320
+ * la fila apagada justo al abrir el registro— y no se vuelve a avisar `ver`, porque los
1321
+ * consumidores que alternan su propia selección con ese evento acababan en desacuerdo con
1322
+ * la tabla.
1323
+ */
1324
+ /**
1325
+ * Doble clic sobre la fila. En solo lectura no dispara la acción: `permitirSeleccion` deja
1326
+ * elegir la fila, pero ni ese modo ni el solo lectura completo ejecutan nada.
1327
+ */
1328
+ dobleClicFila(item: any): void;
1329
+ clicFila(item: any, tableDataIndex: number, evento: MouseEvent): void;
456
1330
  seleccionarItem(item?: any, forzado?: boolean): void;
1331
+ /** Encabezado de una columna en el Excel. */
1332
+ private tituloExcel;
1333
+ /**
1334
+ * Filas del Excel tal como saldrían al pulsar `exportar_excel` (un objeto por fila, con el
1335
+ * encabezado de cada columna como clave), sin descargar nada. Sirve también para revisar el
1336
+ * Excel desde la consola o en pruebas.
1337
+ */
1338
+ datosExcel(): Record<string, any>[];
457
1339
  opcMenu(item: any, objMenu: OpcionSeleccionada, modal?: null, retorno?: boolean): 1 | OpcionSeleccionada;
458
1340
  emitirResultados(evento?: {}): void;
459
1341
  abrirMenuContextual({ x, y }: MouseEvent, user: any): void;
460
1342
  cerrarMenuContextual(): void;
1343
+ /**
1344
+ * Mide la banda (buscador y botones) y el contenedor de la tabla (columnas que caben). Sin
1345
+ * `ResizeObserver` (SSR, pruebas) la banda cuenta como amplia y no se oculta ninguna columna.
1346
+ */
1347
+ private observarAnchoBanda;
1348
+ /** Al abrir el menú del buscador compacto, el foco va al campo. */
1349
+ enfocarBusquedaCompacta(): void;
461
1350
  ejecutarBusquedaCompacta(): void;
462
1351
  emitirAccionRecargar(): void;
1352
+ /** Nivel, hijos, si está abierta y si es solo contexto. `null` sin `[arbol]`. */
1353
+ infoArbol(fila: any): InfoNodoArbolTabla | null;
1354
+ /** Pliega o despliega la fila. No cambia la selección. */
1355
+ alternarNodo(fila: any): void;
1356
+ /** Despliega (o pliega, con `false`) todas las ramas. */
1357
+ expandirTodoArbol(abrir?: boolean): void;
1358
+ sangriaArbol(): number;
463
1359
  protected readonly tipoValorFuncion: typeof tipoValorFuncion;
1360
+ protected readonly clasesCabecerasConContenido = "[&_th.mat-mdc-header-cell.text-left]:!text-left [&_th.mat-mdc-header-cell.text-left_.mat-sort-header-content]:!text-left [&_th.mat-mdc-header-cell.text-right]:!text-right [&_th.mat-mdc-header-cell.text-right_.mat-sort-header-content]:!text-right";
464
1361
  static ɵfac: _angular_core.ɵɵFactoryDeclaration<TablaMantenimientoComponent<any>, never>;
465
- static ɵcmp: _angular_core.ɵɵComponentDeclaration<TablaMantenimientoComponent<any>, "jvs-tabla-mantenimiento", never, { "dataSuscription": { "alias": "dataSuscription"; "required": false; }; "objThis": { "alias": "objThis"; "required": true; }; "nombreColeccion": { "alias": "nombreColeccion"; "required": true; }; "busquedaValor": { "alias": "ctrlBusquedaValue"; "required": false; "isSignal": true; }; "busquedaPlaceholder": { "alias": "ctrlBusquedaPlaceholder"; "required": false; "isSignal": true; }; "filtroCampos": { "alias": "filtroCampos"; "required": false; }; "paginador": { "alias": "paginador"; "required": false; }; "esTabla": { "alias": "esTabla"; "required": false; }; "readOnly": { "alias": "readOnly"; "required": false; }; "filaExtraHeader": { "alias": "filaExtraHeader"; "required": false; }; "filaFooter": { "alias": "filaFooter"; "required": false; }; "botonesCRUD": { "alias": "botonesCRUD"; "required": false; }; "objBotonesCRUD": { "alias": "objBotonesCRUD"; "required": false; }; "classSeleccionado": { "alias": "classSeleccionado"; "required": false; }; "classAnulado": { "alias": "classAnulado"; "required": false; }; "campoAnulado": { "alias": "campoAnulado"; "required": false; }; "campoAnuladoMensaje": { "alias": "campoAnuladoMensaje"; "required": false; }; "selectionModel": { "alias": "selectionModel"; "required": false; }; "filaExtraTemplate": { "alias": "filaExtraTemplate"; "required": false; }; "exportarExcel": { "alias": "exportarExcel"; "required": false; }; "busquedaCompacta": { "alias": "busquedaCompacta"; "required": false; "isSignal": true; }; "alturaFull": { "alias": "alturaFull"; "required": false; "isSignal": true; }; "pageSize": { "alias": "pageSize"; "required": false; }; "pageSizeOptions": { "alias": "pageSizeOptions"; "required": false; }; "derechosActuales": { "alias": "derechosActuales"; "required": false; }; "mostrarBotonOrden": { "alias": "mostrarBotonOrden"; "required": false; "isSignal": true; }; "busquedaTipo": { "alias": "ctrlBusqueda"; "required": false; "isSignal": true; }; "leyenda": { "alias": "leyenda"; "required": false; }; "idTabla": { "alias": "idTabla"; "required": true; }; "columnasTabla": { "alias": "columnasTabla"; "required": false; }; "botonesMenu": { "alias": "botonesMenu"; "required": false; }; "condicionesClaseFila": { "alias": "condicionesClaseFila"; "required": false; }; "rowTooltip": { "alias": "rowTooltip"; "required": false; }; "soloIconos": { "alias": "soloIconos"; "required": false; }; }, { "dblclickItem": "dblclickItem"; "opcionSelecionada": "opcionSelecionada"; "opcBusqueda": "opcBusqueda"; "accionRecargar": "accionRecargar"; "selectionModelChange": "selectionModelChange"; "dataSourceChange": "dataSourceChange"; "resultados": "resultados"; }, ["columnDefs"], ["[filtro]", "[objetosMenuPegado]", "[objetosMenu]", "[botonesFiltro]", "[botonesConfig]", "[cuerpo]", "[tableDefinitions]", "[appendTable]"], true, never>;
1362
+ static ɵcmp: _angular_core.ɵɵComponentDeclaration<TablaMantenimientoComponent<any>, "jvs-tabla-mantenimiento", never, { "dataSuscription": { "alias": "dataSuscription"; "required": false; }; "objThis": { "alias": "objThis"; "required": false; }; "nombreColeccion": { "alias": "nombreColeccion"; "required": true; }; "busquedaValor": { "alias": "ctrlBusquedaValue"; "required": false; "isSignal": true; }; "busquedaPlaceholder": { "alias": "ctrlBusquedaPlaceholder"; "required": false; "isSignal": true; }; "filtroCampos": { "alias": "filtroCampos"; "required": false; }; "paginador": { "alias": "paginador"; "required": false; }; "esTabla": { "alias": "esTabla"; "required": false; }; "readOnly": { "alias": "readOnly"; "required": false; }; "filaExtraHeader": { "alias": "filaExtraHeader"; "required": false; }; "filaFooter": { "alias": "filaFooter"; "required": false; }; "botonesCRUD": { "alias": "botonesCRUD"; "required": false; }; "objBotonesCRUD": { "alias": "objBotonesCRUD"; "required": false; }; "classSeleccionado": { "alias": "classSeleccionado"; "required": false; }; "classAnulado": { "alias": "classAnulado"; "required": false; }; "campoAnulado": { "alias": "campoAnulado"; "required": false; }; "campoAnuladoMensaje": { "alias": "campoAnuladoMensaje"; "required": false; }; "selectionModel": { "alias": "selectionModel"; "required": false; }; "seguirSeleccion": { "alias": "seguirSeleccion"; "required": false; "isSignal": true; }; "filaExtraTemplate": { "alias": "filaExtraTemplate"; "required": false; }; "exportarExcel": { "alias": "exportarExcel"; "required": false; }; "busquedaCompacta": { "alias": "busquedaCompacta"; "required": false; "isSignal": true; }; "columnasSiNoCaben": { "alias": "columnasSiNoCaben"; "required": false; "isSignal": true; }; "busquedaAncho": { "alias": "ctrlBusquedaAncho"; "required": false; "isSignal": true; }; "nombreExcel": { "alias": "nombreExcel"; "required": false; "isSignal": true; }; "animarFilas": { "alias": "animarFilas"; "required": false; "isSignal": true; }; "cargando": { "alias": "cargando"; "required": false; "isSignal": true; }; "exportacionArriba": { "alias": "exportacionArriba"; "required": false; "isSignal": true; }; "alinearCabecerasConContenido": { "alias": "alinearCabecerasConContenido"; "required": false; "isSignal": true; }; "coloresTema": { "alias": "coloresTema"; "required": false; "isSignal": true; }; "alturaFull": { "alias": "alturaFull"; "required": false; "isSignal": true; }; "pageSize": { "alias": "pageSize"; "required": false; }; "pageSizeOptions": { "alias": "pageSizeOptions"; "required": false; }; "arbol": { "alias": "arbol"; "required": false; "isSignal": true; }; "busquedaCampos": { "alias": "ctrlBusquedaCampos"; "required": false; "isSignal": true; }; "derechosActuales": { "alias": "derechosActuales"; "required": false; }; "mostrarBotonOrden": { "alias": "mostrarBotonOrden"; "required": false; "isSignal": true; }; "busquedaTipo": { "alias": "ctrlBusqueda"; "required": false; "isSignal": true; }; "leyenda": { "alias": "leyenda"; "required": false; }; "idTabla": { "alias": "idTabla"; "required": true; }; "columnasTabla": { "alias": "columnasTabla"; "required": false; }; "botonesMenu": { "alias": "botonesMenu"; "required": false; }; "condicionesClaseFila": { "alias": "condicionesClaseFila"; "required": false; }; "rowTooltip": { "alias": "rowTooltip"; "required": false; }; "soloIconos": { "alias": "soloIconos"; "required": false; }; }, { "dblclickItem": "dblclickItem"; "opcionSelecionada": "opcionSelecionada"; "opcBusqueda": "opcBusqueda"; "accionRecargar": "accionRecargar"; "selectionModelChange": "selectionModelChange"; "dataSourceChange": "dataSourceChange"; "resultados": "resultados"; }, ["columnDefs"], ["[filtro]", "[objetosMenuPegado]", "[objetosMenu]", "[botonesFiltro]", "[botonesConfig]", "[cuerpo]", "[tableDefinitions]", "[appendTable]"], true, never>;
1363
+ }
1364
+
1365
+ interface TablaMantenimientoConfig {
1366
+ derechos?: any;
1367
+ /**
1368
+ * Colores de la tabla (fila elegida, botones `activo`, segmentados y su badge): `false` (por
1369
+ * defecto) usa los colores estándar fijos, iguales en todas las pantallas; `true` usa los
1370
+ * del tema de la entidad (`--color-primary` y `--color-primary-contrast`). Cada tabla puede
1371
+ * cambiarlo con su input `coloresTema`.
1372
+ */
1373
+ coloresTema?: boolean;
1374
+ /**
1375
+ * Las exportaciones (PDF, Excel…) suben como íconos junto a Recargar (por defecto `true`). Con
1376
+ * `false`, en toda la app se quedan donde cada pantalla las puso. Cada tabla puede cambiarlo con
1377
+ * su input `exportacionArriba`.
1378
+ */
1379
+ exportacionArriba?: boolean;
1380
+ /**
1381
+ * Cuando la selección cambia desde fuera, la tabla lleva la fila a la vista (por defecto
1382
+ * `true`). Con `false` no lo hace en ninguna tabla de la app. Cada tabla puede cambiarlo con su
1383
+ * input `seguirSeleccion`.
1384
+ */
1385
+ seguirSeleccion?: boolean;
1386
+ }
1387
+
1388
+ /**
1389
+ * Configuración global de `jvs-tabla-mantenimiento` para toda la app. Sin proveerla, la tabla
1390
+ * usa sus valores por defecto (p. ej. colores estándar).
1391
+ */
1392
+ declare const TABLA_MANTENIMIENTO_CONFIG: InjectionToken<TablaMantenimientoConfig>;
1393
+ /**
1394
+ * Cablea `TABLA_MANTENIMIENTO_CONFIG` en el `app.config` de la app.
1395
+ *
1396
+ * @example
1397
+ * // Todas las tablas con los colores del tema de la entidad (`--color-primary`):
1398
+ * provideTablaMantenimiento({coloresTema: true})
1399
+ *
1400
+ * @example
1401
+ * // Un MF que prefiere el comportamiento de antes en todas sus tablas:
1402
+ * provideTablaMantenimiento({exportacionArriba: false, seguirSeleccion: false})
1403
+ */
1404
+ declare function provideTablaMantenimiento(config: TablaMantenimientoConfig): EnvironmentProviders;
1405
+
1406
+ /**
1407
+ * Retardo (ms) de los tooltips de las piezas y del recorte: al pasar el cursor por una fila con
1408
+ * varias marcas no se abren y cierran tooltips sin pausa. Solo en `<jvs-tabla-celda>`: los botones
1409
+ * de la tabla siguen inmediatos.
1410
+ */
1411
+ declare const RETARDO_TOOLTIP_CELDA = 400;
1412
+ /** Pieza lista para pintar: la pieza, si va precedida de un espacio y sus clases. */
1413
+ interface PiezaPintada {
1414
+ pieza: PiezaCelda;
1415
+ espacio: boolean;
1416
+ clase: string;
1417
+ /** Texto para lectores de pantalla (`ariaLabel` o el tooltip). */
1418
+ oculto: string;
1419
+ /** Nota en línea después de otra pieza: va precedida de "·". */
1420
+ punto: boolean;
466
1421
  }
1422
+ /**
1423
+ * Pinta las piezas de una celda declarativa (`celda` en las columnas `text` y `arbol`). Sirve
1424
+ * también dentro de una columna `custom`, o fuera de la tabla (una leyenda), para que una pieza se
1425
+ * vea igual en todas partes:
1426
+ *
1427
+ * ```html
1428
+ * <jvs-tabla-celda [piezas]="[row.cNombre, nota(row.cSigla)]" [fila]="row"></jvs-tabla-celda>
1429
+ * ```
1430
+ *
1431
+ * Los tooltips son de Material y su texto se repite oculto (clase `jvs-celda-oculto`) para los
1432
+ * lectores de pantalla; la medición de `columnasSiNoCaben` no lo cuenta. Un ícono con `click` es un
1433
+ * botón que no selecciona la fila.
1434
+ */
1435
+ declare class TablaCeldaComponent {
1436
+ /** Lo que devolvió `celda(row)`: texto, pieza o lista de ellos. */
1437
+ piezas: _angular_core.InputSignal<Celda>;
1438
+ /** El registro de la fila: lo recibe el `click` de los íconos. */
1439
+ fila: _angular_core.InputSignal<any>;
1440
+ /** Líneas máximas; con más, se recorta y el texto completo va al tooltip. */
1441
+ lineas: _angular_core.InputSignal<number | null | undefined>;
1442
+ protected readonly retardo = 400;
1443
+ readonly pintadas: _angular_core.Signal<PiezaPintada[]>;
1444
+ readonly claseRecorte: _angular_core.Signal<string>;
1445
+ readonly textoCompleto: _angular_core.Signal<string>;
1446
+ pulsar(pieza: PiezaIcono, evento: Event): void;
1447
+ static ɵfac: _angular_core.ɵɵFactoryDeclaration<TablaCeldaComponent, never>;
1448
+ static ɵcmp: _angular_core.ɵɵComponentDeclaration<TablaCeldaComponent, "jvs-tabla-celda", never, { "piezas": { "alias": "piezas"; "required": false; "isSignal": true; }; "fila": { "alias": "fila"; "required": false; "isSignal": true; }; "lineas": { "alias": "lineas"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
1449
+ }
1450
+
1451
+ /** Una pieza con un atajo por tono: `pieza.exito(…)` es `pieza(…, {tono: 'exito'})`. */
1452
+ type ConTonos<F extends (...a: any[]) => PiezaCelda> = F & PorTono<F>;
1453
+ /** Texto principal; con `negrita` o `tono`. Un texto suelto (`'Sí'`) equivale a `texto('Sí')`. */
1454
+ declare const texto: ConTonos<(t: string | number | null | undefined, o?: OpcionesTono & OpcionesExcel & OpcionesClase & {
1455
+ negrita?: boolean;
1456
+ }) => PiezaTexto>;
1457
+ /**
1458
+ * Nota gris; después de otra pieza va precedida de "·" ("ACTA · AC"), sola es solo texto gris
1459
+ * ("Sin usuarios"). Sin texto devuelve `false`, para escribir `nota(row.cCorto)` sin `@if`. No lleva tono.
1460
+ */
1461
+ declare const nota: (t: string | number | null | undefined, o?: {
1462
+ bloque?: boolean;
1463
+ } & OpcionesExcel & OpcionesClase) => PiezaNota | false;
1464
+ /**
1465
+ * Badge de estado ("Inactivo", "Oculto"…). Neutro si no se dice el tono; con `icono`, un ícono de
1466
+ * 10 px delante del texto (`badge.exito('Firmado', {icono: 'roundCheck'})`).
1467
+ */
1468
+ declare const badge: ConTonos<(t: string, o?: OpcionesPieza & {
1469
+ icono?: string;
1470
+ }) => PiezaBadge>;
1471
+ /** Marca corta (abreviatura) con su significado en el tooltip. Primaria si no se dice el tono. */
1472
+ declare const marca: ConTonos<(t: string, tooltip: string, o?: OpcionesPieza) => PiezaMarca>;
1473
+ /** Marca con un ícono en lugar de abreviatura. Primaria si no se dice el tono. */
1474
+ declare const marcaIcono: ConTonos<(icono: string, tooltip: string, o?: OpcionesPieza) => PiezaMarca>;
1475
+ /**
1476
+ * Ícono de 12 px (14 px con `tamano: 'grande'`), del color del texto si no se dice el tono; con
1477
+ * `click`, es un botón que no selecciona la fila.
1478
+ */
1479
+ declare const icono: ConTonos<(nombre: string, o?: OpcionesPieza & {
1480
+ tamano?: TamanoIconoCelda;
1481
+ click?: (row: any) => void;
1482
+ }) => PiezaIcono>;
1483
+ /** Imagen de 20 px (avatar), redonda salvo `redonda: false`. */
1484
+ declare const imagen: (src: string, alt: string, o?: {
1485
+ redonda?: boolean;
1486
+ } & OpcionesClase) => PiezaImagen;
1487
+ /** Cierra la línea: lo que sigue va debajo. */
1488
+ declare const salto: PiezaSalto;
1489
+ /**
1490
+ * Lista plana de piezas: los textos y números sueltos pasan a `texto`, y se descartan `false`,
1491
+ * `null`, `undefined` y los textos vacíos.
1492
+ */
1493
+ declare function normalizarCelda(celda: Celda | null | undefined): PiezaCelda[];
1494
+ /**
1495
+ * Texto plano de una celda, para el Excel y las pruebas: textos, notas (con "·" si van en línea
1496
+ * después de otra pieza, como en pantalla), badges y marcas con texto, separados por un espacio.
1497
+ * Íconos, imágenes, saltos y las piezas con `soloPantalla` no cuentan.
1498
+ */
1499
+ declare function textoCelda(celda: Celda | null | undefined): string;
1500
+
1501
+ declare const CLASES_TONO: Readonly<Record<TonoCelda, {
1502
+ readonly fondo: string;
1503
+ readonly texto: string;
1504
+ }>>;
1505
+ /** Clases de fondo y texto de un tono, para pintar con el mismo color fuera de la tabla (fichas, leyendas). */
1506
+ declare const claseTono: (tono: TonoCelda) => string;
1507
+ /**
1508
+ * Clases completas de un badge para HTML fuera de la tabla (la ficha de un panel, un contador):
1509
+ * `'celda'` (12 px, el de la fila) o `'ficha'` (18 px, paneles). Forma y tono juntos:
1510
+ *
1511
+ * ```ts
1512
+ * fichaExito: claseBadge('exito', 'ficha') // <span [class]="cls.fichaExito">Activo</span>
1513
+ * ```
1514
+ */
1515
+ declare const claseBadge: (tono: TonoCelda, tamano?: "celda" | "ficha") => string;
467
1516
 
468
- export { ProgressBarComponent, TablaMantenimientoComponent, TablaMantenimientoService };
469
- export type { Archivo, BotonDialog, BotonMantenimiento, ColumnaCheckbox, ColumnaDate, ColumnaEstiloEstablecido, ColumnaExpandir, ColumnaIcons, ColumnaIconsDef, ColumnaMoney, ColumnaNumber, ColumnaOtros, ColumnaProgress, ColumnaTabla, ColumnaTablaReporte, ColumnaTexto, ColumnaYesNo, DataServidor, DialogDatosRecibidos, EstilosBarra, IconsIcon, IncluyeTablaMantenimiento, MantenimientoFilaExtraData, OpcMenuEvent, OpcionSeleccionada, PopoverConfig, PropiedadesProgressBar, PropiedadesText, SeccionesBotonesMantenimiento, TablaMantenimientoSeccionBotones, TiposColumnasNuevo, TiposOpciones };
1517
+ export { CLASES_TONO, CONTROL_ARBOL_TABLA, ProgressBarComponent, RETARDO_TOOLTIP_CELDA, TABLA_MANTENIMIENTO_CONFIG, TONOS, TablaArbolCeldaComponent, TablaCeldaComponent, TablaMantenimientoComponent, TablaMantenimientoDataSource, TablaMantenimientoService, badge, claseBadge, claseTono, generarBotonesDinamicos, icono, imagen, marca, marcaIcono, normalizarCelda, nota, provideTablaMantenimiento, salto, texto, textoCelda };
1518
+ export type { AlineacionColumna, Archivo, BotonDialog, BotonDinamicoTodos, BotonMantenimiento, Celda, ColumnaArbol, ColumnaCheckbox, ColumnaDate, ColumnaEstiloEstablecido, ColumnaExpandir, ColumnaIcons, ColumnaIconsDef, ColumnaMoney, ColumnaNumber, ColumnaOtros, ColumnaProgress, ColumnaTabla, ColumnaTablaExcel, ColumnaTablaReporte, ColumnaTexto, ColumnaYesNo, ConTonos, ConfigArbolTabla, ConfigBotonesDinamicos, ControlArbolTabla, DataServidor, DialogDatosRecibidos, ElementoCelda, EstilosBarra, IconsIcon, IncluyeTablaMantenimiento, InfoNodoArbolTabla, MantenimientoFilaExtraData, OpcMenuEvent, OpcionSeleccionada, OpcionesClase, OpcionesExcel, OpcionesPieza, OpcionesTono, PiezaBadge, PiezaCelda, PiezaIcono, PiezaImagen, PiezaMarca, PiezaNota, PiezaSalto, PiezaTexto, PopoverConfig, PorTono, PropiedadesProgressBar, PropiedadesText, SeccionesBotonesMantenimiento, TablaMantenimientoConfig, TablaMantenimientoSeccionBotones, TamanoIconoCelda, TiposColumnasNuevo, TiposOpciones, TonoCelda, TramoBotones, ValorBotonDinamico };