@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.
- package/.storybook/tema-demo.css +194 -0
- package/dialog-flotante/README.md +21 -1
- package/fesm2022/jvsoft-components-dialog-flotante.mjs +18 -12
- package/fesm2022/jvsoft-components-dialog-flotante.mjs.map +1 -1
- package/fesm2022/jvsoft-components-filtro-busqueda.mjs +11 -2
- package/fesm2022/jvsoft-components-filtro-busqueda.mjs.map +1 -1
- package/fesm2022/jvsoft-components-lista-arbol.mjs +58 -17
- package/fesm2022/jvsoft-components-lista-arbol.mjs.map +1 -1
- package/fesm2022/jvsoft-components-lista-detalle.mjs +70 -0
- package/fesm2022/jvsoft-components-lista-detalle.mjs.map +1 -0
- package/fesm2022/jvsoft-components-luces-navidad.mjs +2 -2
- package/fesm2022/jvsoft-components-luces-navidad.mjs.map +1 -1
- package/fesm2022/jvsoft-components-menu.mjs +4 -1
- package/fesm2022/jvsoft-components-menu.mjs.map +1 -1
- package/fesm2022/jvsoft-components-tabla-mantenimiento-components-progress-bar.mjs +2 -5
- package/fesm2022/jvsoft-components-tabla-mantenimiento-components-progress-bar.mjs.map +1 -1
- package/fesm2022/jvsoft-components-tabla-mantenimiento.mjs +2605 -394
- package/fesm2022/jvsoft-components-tabla-mantenimiento.mjs.map +1 -1
- package/fesm2022/jvsoft-components.mjs +1 -0
- package/fesm2022/jvsoft-components.mjs.map +1 -1
- package/lista-arbol/README.md +17 -1
- package/lista-detalle/README.md +85 -0
- package/package.json +6 -2
- package/src/styles/base-jvsoft-components.css +714 -15
- package/tabla-mantenimiento/README.md +628 -0
- package/tabla-mantenimiento/tabla-mantenimiento.component.scss +31 -0
- package/types/jvsoft-components-dialog-flotante.d.ts +2 -0
- package/types/jvsoft-components-filtro-busqueda.d.ts +6 -0
- package/types/jvsoft-components-lista-arbol.d.ts +19 -2
- package/types/jvsoft-components-lista-detalle.d.ts +44 -0
- package/types/jvsoft-components-menu.d.ts +1 -0
- package/types/jvsoft-components-tabla-mantenimiento-components-progress-bar.d.ts +1 -2
- package/types/jvsoft-components-tabla-mantenimiento.d.ts +1070 -21
- 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,
|
|
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
|
|
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, { "
|
|
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
|
-
|
|
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:
|
|
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
|
-
|
|
331
|
-
|
|
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
|
-
|
|
365
|
-
|
|
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
|
-
|
|
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:
|
|
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
|
-
|
|
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(
|
|
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
|
-
|
|
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":
|
|
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 };
|