tuain-ng-forms-lib 17.3.7 → 17.4.0

package/lib/interfaces/section.interface.d.ts

@@ -0,0 +1,56 @@
+import type { Observable } from 'rxjs';
+import type { IFormPropagate, IFormElement } from './piece.interface';
+import type { IField } from './field.interface';
+import type { IAction } from './action.interface';
+import type { ITable } from './table.interface';
+/**
+ * Contrato público de una subsección de formulario, que agrupa los elementos
+ * (campos, tablas, acciones) que se renderizan juntos.
+ * Implementado por {@link RecordFormSubSection}.
+ */
+export interface ISubSection extends IFormPropagate {
+    customRender: string | null;
+    subsectionId: string | null;
+    subsectionCode: string | null;
+    subsectionTitle: string | null;
+    readonly subSectionElements: IFormElement[];
+    readonly subSectionFields: IField[];
+    readonly subSectionTables: ITable[];
+    readonly subSectionActions: IAction[];
+    readonly elementsArray: Record<string, IFormElement>;
+    active: boolean;
+    getField(name: string): IField | undefined;
+    getFields(): IField[];
+    getFieldNames(): string[];
+    getActions(): IAction[];
+    getActionNames(): string[];
+    activate(): void;
+    inactivate(): void;
+}
+/**
+ * Contrato público de una sección de formulario, contenedora de subsecciones
+ * y con gestión de activación/inactivación (navegación entre secciones).
+ * Implementado por {@link RecordFormSection}.
+ */
+export interface ISection extends IFormPropagate {
+    readonly code: string | null;
+    readonly activation: Observable<string>;
+    readonly inactivation: Observable<string>;
+    active: boolean;
+    sectionId: string | null;
+    sectionCode: string | null;
+    sectionTitle: string | null;
+    title: string | null;
+    readonly subSections: ISubSection[];
+    readonly subSectionsObj: Record<string, ISubSection>;
+    activate(): void;
+    inactivate(): void;
+    getVisibleSubsections(state?: string): ISubSection[];
+    getSubsection(subSectionCode: string): ISubSection | null;
+    activateSubSection(subSectionCode: string): void;
+    getFields(): IField[];
+    getActions(): IAction[];
+    getActionNames(): string[];
+    getFieldNames(): string[];
+    getField(name: string): IField | null;
+}

package/lib/interfaces/sse-live-connection.interface.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Evento recibido del servidor a través del stream SSE.
+ * El backend envía un objeto JSON por mensaje; `eventClass` identifica el tipo.
+ */
+export interface SseServerEvent {
+    eventClass?: string;
+    eventType?: string;
+    eventDetail?: any;
+    [key: string]: any;
+}
+/** Logger mínimo opcional; cada app puede inyectar el suyo. */
+export interface SseLogger {
+    debug?(message: string, ...args: any[]): void;
+    warn?(message: string, ...args: any[]): void;
+}
+/**
+ * Configuración que cada app provee mediante el token `SSE_LIVE_CONNECTION_CONFIG`.
+ *
+ * Desacopla el servicio de la librería del `EventManager`, el logger y la
+ * configuración concretos de cada app (la lib no puede importar el
+ * `defaultConfig`, `AppLoggerService` ni el `EventManagerService` de cada app).
+ */
+export interface SseLiveConnectionConfig {
+    /** URL base del gateway, p. ej. `"https://host:puerto"`. */
+    buildUrl(): string;
+    /** Path del endpoint del stream. Default: `"/liveconnect/stream"`. */
+    streamPath?: string;
+    /**
+     * Credencial a enviar en el header `Authorization` al abrir el stream.
+     * Normalmente el `sessionId`; el gateway resuelve `userId`/grupos server-side
+     * (a diferencia del Socket.IO anterior, el cliente ya no auto-asigna esos campos).
+     * Puede ser asíncrona por si hay que refrescar un token.
+     */
+    getAuthToken(sessionData: any): string | Promise<string>;
+    /**
+     * Esquema del header de autenticación. Default: `"Bearer"`.
+     * Se envía como `Authorization: <scheme> <token>`. Si es `""`, se envía el token crudo.
+     */
+    authScheme?: string;
+    /** Allow-list de `eventClass` que pueden re-emitirse al bus de eventos. */
+    allowedEvents: ReadonlySet<string> | string[];
+    /** Re-emite al bus de la app un evento ya validado (o el evento de fin de sesión). */
+    emit(eventClass: string, eventData: SseServerEvent | null): void;
+    /**
+     * Nombre del evento de fin de sesión, emitido ante un `sessionReplaced` ajeno.
+     * Default: `"sessionEnded"`.
+     */
+    sessionEndedEventName?: string;
+    /** Habilita el manejo del evento de lifecycle `sessionReplaced`. Default: `true`. */
+    handleSessionReplaced?: boolean;
+    /** Logger opcional. */
+    logger?: SseLogger;
+    /**
+     * Mantener el stream abierto aunque el documento esté oculto. Default: `true`
+     * (la app controla el ciclo de vida explícitamente; en móvil vía `appStateChange`).
+     * Si es `false`, el stream se cierra al ocultarse la vista y se reabre al volver.
+     */
+    keepOpenWhenHidden?: boolean;
+}

package/lib/interfaces/table.interface.d.ts

@@ -0,0 +1,139 @@
+import type { Observable } from 'rxjs';
+import type { IFormPiece, IFormElement } from './piece.interface';
+import type { TableSorting } from './form-config.interface';
+import type { FilterDef, FilterSetup } from '../classes/forms/table/column';
+import type { TableEvent, TableActionEvent } from '../classes/forms/table/table';
+/**
+ * Contrato público de una columna de tabla.
+ * Implementado por {@link RecordTableColumn}.
+ */
+export interface ITableColumn extends IFormPiece {
+    fieldCode: string;
+    fieldTitle: string;
+    fieldType: string;
+    fieldAlignment: string;
+    fieldFormat: string;
+    sortable: boolean;
+    searchable: boolean;
+    sortDirections: string[];
+    filterVisible: boolean;
+    filterDef: FilterDef | null;
+    filterSetup: FilterSetup | null;
+    readonly filterDefinition: FilterDef | null;
+    readonly filter: FilterSetup | null;
+    readonly options: any[] | null;
+    setSearchable(searchable?: boolean): void;
+    hideFilter(): void;
+    addFilterDefinition(filterDefinition: any): void;
+    addFilter(columnValues: any, operator: string | null): void;
+    removeFilter(): void;
+    setSortDirections(ascend: boolean, descend: boolean): void;
+}
+/**
+ * Contrato público de una acción de tabla (inline, global o de selección).
+ * Implementado por {@link TableAction}.
+ */
+export interface ITableAction extends IFormPiece {
+    readonly actionCode: string;
+    readonly actionTitle: string;
+    readonly iconName: string;
+    readonly actionType: string;
+    readonly actionClass: string;
+    readonly stateField: string;
+    readonly newState: string;
+    readonly backend: boolean;
+    readonly restrictedOnField: string | null;
+    readonly restrictedOnValue: string | null;
+    readonly restrictedOnOperator: string | null;
+}
+/**
+ * Contrato público de un registro de tabla.
+ * Implementado por {@link TableRecordData}.
+ */
+export interface ITableRecord {
+    recordId: string | null;
+    selected: boolean;
+    recordData: Record<string, any>;
+    readonly recordIdKey: string | null;
+    toggleSelect(): void;
+    select(): void;
+    unselect(): void;
+    getFieldValue(fieldCode: string): any;
+    hasPattern(words: string[], columnObj: any): boolean;
+    hasCondition(columnFilters: any[]): boolean;
+}
+/**
+ * Contrato público de una tabla de registros, con acceso a sus columnas,
+ * acciones de tabla y registros.
+ * Implementado por {@link RecordTable}.
+ */
+export interface ITable extends IFormElement {
+    readonly tableCode: string;
+    readonly code: string;
+    tableTitle: string;
+    readonly columns: ITableColumn[];
+    readonly columnNames: string[];
+    readonly tableRecords: ITableRecord[];
+    readonly visibleRecords: ITableRecord[];
+    readonly tableRecordObj: Record<string, ITableRecord>;
+    selectable: boolean;
+    selectionBackend: boolean;
+    selectionField: string;
+    allSelected: boolean;
+    currentPage: number;
+    totalPages: number;
+    requestedPage: number;
+    recordsPerPage: number;
+    totalRecordsNumber: number;
+    recordsNumber: number;
+    sorting: TableSorting;
+    waiting: boolean;
+    clientPaging: boolean;
+    sortable: boolean;
+    globalSearch: boolean;
+    globalFilterString: string;
+    restrictedId: any;
+    readonly currentFilter: any;
+    readonly inlineActionTrigger: Observable<TableEvent>;
+    readonly globalActionTrigger: Observable<TableEvent>;
+    readonly selectionActionTrigger: Observable<TableEvent>;
+    readonly recordSelectionTrigger: Observable<TableEvent>;
+    readonly getDataTrigger: Observable<TableEvent>;
+    getLayout(): string | null;
+    setLayout(layout: string): void;
+    hasActions(): boolean;
+    getSelectedRecords(): (string | null)[];
+    activateGlobalSearch(): void;
+    inactivateGlobalSearch(): void;
+    columnDefinition(fieldCode: string): ITableColumn;
+    putOnWait(): void;
+    freeWaiting(): void;
+    setWidget(widget: any): void;
+    notifyGlobalAction(actionCode: string): void;
+    notifyInlineAction(tableActionEvent: TableActionEvent): void;
+    notifyRecordSelection(recordId: any): void;
+    notifySelectionAction(actionCode: string): void;
+    notifyGetDataAction(requestedPage?: number | null): null;
+    clean(): void;
+    selectAll(): boolean;
+    unSelectAll(): boolean;
+    setTableRecords(tableRecords: any[], append?: boolean, prepend?: boolean): void;
+    appendRecords(records: any[]): void;
+    prependRecords(records: any[]): void;
+    replaceRecords(records: any[]): void;
+    setTableAppend(append: boolean): void;
+    changePage(requestedPage: number): void;
+    updateFromServer(tableReceived: any): void;
+    getTableRecord(recordId: any): ITableRecord | null;
+    getAction(actionCode: string): ITableAction | null;
+    getActions(actionClass?: string, actionTypes?: string[] | null): ITableAction[];
+    setFilterById(id: any): void;
+    cleanIdFilter(): void;
+    setGlobalFilterString(text: string, notifyComponent?: boolean): void;
+    addFilterDefinition(columnName: string, filterDefinition: any): void;
+    getFilteredRecords(): ITableRecord[];
+    getColumnFilter(columnName: string): FilterSetup | null;
+    addColumnFilter(columnName: string, columnValues: any | any[], operator?: string | null): void;
+    removeColumnFilter(columnName: string): void;
+    sort(columnName: string, direction: string): void;
+}

package/lib/services/file-manager.service.d.ts

@@ -1,9 +1,9 @@
 import * as i0 from "@angular/core";
 export declare class LibFileManagementService {
-    openFile(fileBase64Data: string, fileName: string, fileType: string): void;
-    saveFileFromURL(fileUrl: string, fileName?: string | null, fileType?: string | null): void;
-    saveFile(fileBase64Data: string | Blob, fileName: string, fileType: string): void;
-    printPdfFile(pdfBufferData: ArrayBuffer | Blob): void;
+    openFile(_fileBase64Data: string, _fileName: string, _fileType: string): void;
+    saveFileFromURL(_fileUrl: string, _fileName?: string | null, _fileType?: string | null): void;
+    saveFile(_fileBase64Data: string | Blob, _fileName: string, _fileType: string): void;
+    printPdfFile(_pdfBufferData: ArrayBuffer | Blob): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<LibFileManagementService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<LibFileManagementService>;
 }

package/lib/services/form-manager.service.d.ts

@@ -12,9 +12,9 @@ export interface FormStackItem {
 export declare class LibFormManagerService {
     pageStack: FormStackItem[];
     constructor();
-    getFormDefinition(formCode: string): any;
-    execServerAction(actionDetail: any): any;
-    goToForm(formCode: string, token: string, subject: string | null): void;
+    getFormDefinition(_formCode: string): any;
+    execServerAction(_actionDetail: any): any;
+    goToForm(_formCode: string, _token: string, _subject: string | null): void;
     loadStack(): Promise<void>;
     saveStack(): void;
     cleanStack(): void;

package/lib/services/icon-dictionary.service.d.ts

@@ -156,5 +156,5 @@ export declare const iconDictionary: {
  * @deprecated Since v17. Use BaseIconResolverService with ICON_RESOLVER token instead. Will be removed in v19.
  */
 export declare class IconDictionaryService {
-    mapIcon: (iconName: string) => string;
+    mapIcon: (iconName: string) => string | null;
 }

package/lib/services/sse-live-connection.service.d.ts

@@ -0,0 +1,48 @@
+import { fetchEventSource } from '@microsoft/fetch-event-source';
+import * as i0 from "@angular/core";
+/**
+ * Canal de eventos servidor→cliente sobre Server-Sent Events (SSE).
+ *
+ * Reemplaza al `LiveConnectionService` basado en Socket.IO que vivía duplicado
+ * en cada app. El uso siempre fue unidireccional (un único handshake y luego
+ * solo recepción), así que SSE encaja sin perder funcionalidad y además gana
+ * reconexión automática nativa.
+ *
+ * El servicio es agnóstico de la app: toda la integración (URL, token de auth,
+ * allow-list, re-emisión al bus, logger) llega por `SSE_LIVE_CONNECTION_CONFIG`.
+ * El ciclo de vida (cuándo abrir/cerrar) lo controla cada app llamando
+ * `open()`/`close()` — típicamente atado a `sessionEstablished`/`sessionEnded`,
+ * y en móvil además al `appStateChange` de Capacitor.
+ */
+export declare class SseLiveConnectionService {
+    private readonly _config;
+    private _abort;
+    private _currentSessionId;
+    private _connected;
+    isConnected(): boolean;
+    /**
+     * Abre el stream SSE para la sesión dada (cierra cualquier stream anterior).
+     * El handshake viaja en el header `Authorization`, no en la URL.
+     */
+    open(sessionData: any): Promise<void>;
+    /**
+     * Punto de indirección (seam) sobre `fetchEventSource`: permite sustituirlo en
+     * tests (`fetchEventSource` es un binding ESM de solo lectura, no espiable).
+     * En producción delega directamente en la librería.
+     */
+    protected openEventSource(url: Parameters<typeof fetchEventSource>[0], options: Parameters<typeof fetchEventSource>[1]): Promise<void>;
+    /** Cierra el stream actual (idempotente). */
+    close(): void;
+    private _buildStreamUrl;
+    private _allowedSet;
+    /**
+     * Maneja el evento de lifecycle `sessionReplaced` (otra apertura de sesión
+     * para el mismo usuario). Si el `newSessionId` difiere de la sesión local,
+     * emite el evento de fin de sesión para forzar logout. Se ejecuta antes del
+     * filtro de allow-list porque no se re-emite al bus genérico.
+     * Devuelve `true` cuando consume el evento.
+     */
+    private _handleSessionReplaced;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SseLiveConnectionService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SseLiveConnectionService>;
+}

package/lib/tokens/sse-live-connection.token.d.ts

@@ -0,0 +1,7 @@
+import { InjectionToken } from '@angular/core';
+import { SseLiveConnectionConfig } from '../interfaces/sse-live-connection.interface';
+/**
+ * Token con el que cada app provee su configuración del stream SSE.
+ * Sigue el mismo patrón que `ICON_RESOLVER`.
+ */
+export declare const SSE_LIVE_CONNECTION_CONFIG: InjectionToken<SseLiveConnectionConfig>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tuain-ng-forms-lib",
-  "version": "17.3.7",
+  "version": "17.4.0",
   "description": "Componentes y Clases Angular para la gestión de formularios TUAIN",
   "author": "Mauricio Méndez, Imix Consulting",
   "license": "MIT",
@@ -22,6 +22,7 @@
     "rxjs": "^7.5.0"
   },
   "dependencies": {
+    "@microsoft/fetch-event-source": "^2.0.1",
     "nanoid": "^4.0.0",
     "tslib": "^2.4.0",
     "yn": "^5.0.0"

package/public-api.d.ts

@@ -1,5 +1,6 @@
 export * from './lib/interfaces/index';
 export * from './lib/tokens/icon-resolver.token';
+export * from './lib/tokens/sse-live-connection.token';
 export * from './lib/classes/forms/piece';
 export * from './lib/classes/forms/piece-propagate';
 export * from './lib/classes/forms/element';
@@ -30,4 +31,5 @@ export * from './lib/services/form-manager.service';
 export * from './lib/services/file-manager.service';
 export * from './lib/services/icon-dictionary.service';
 export * from './lib/services/base-icon-resolver.service';
+export * from './lib/services/sse-live-connection.service';
 export * from './lib/tuain-ng-forms-lib.module';