tuain-ng-forms-lib 17.3.7 → 19.0.1

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,67 @@
+/**
+ * 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;
+    /**
+     * Nombre del evento a emitir ante un `sessionClosed` del servidor (el gateway ordenó cerrar ESTA
+     * sesión porque expiró/dejó de ser válida). Permite mostrar un mensaje propio antes del logout.
+     * Default: `sessionEndedEventName` (o `"sessionEnded"`).
+     */
+    sessionClosedEventName?: string;
+    /** Habilita el manejo del evento de lifecycle `sessionReplaced`. Default: `true`. */
+    handleSessionReplaced?: boolean;
+    /** Habilita el manejo del evento de control `sessionClosed` (cierre ordenado por el servidor). Default: `true`. */
+    handleSessionClosed?: 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,56 @@
+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;
+    /**
+     * Maneja el evento de control `sessionClosed` dirigido a ESTA sesión (el gateway lo envía con
+     * recipientType 'session' al detectar que la sesión expiró/dejó de ser válida). Ordena cerrar la
+     * sesión en el navegador. Se ejecuta antes del allow-list porque no se re-emite al bus genérico.
+     * Emite `sessionClosedEventName` (o, en su defecto, el de fin de sesión) para que la app muestre
+     * su propio mensaje antes del logout. Devuelve `true` cuando consume el evento.
+     */
+    private _handleSessionClosed;
+    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": "19.0.1",
   "description": "Componentes y Clases Angular para la gestión de formularios TUAIN",
   "author": "Mauricio Méndez, Imix Consulting",
   "license": "MIT",
@@ -15,13 +15,14 @@
     "Angular"
   ],
   "peerDependencies": {
-    "@angular/common": "^17.0.0",
-    "@angular/core": "^17.0.0",
-    "@angular/forms": "^17.0.0",
-    "@angular/router": "^17.0.0",
+    "@angular/common": "^19.0.0",
+    "@angular/core": "^19.0.0",
+    "@angular/forms": "^19.0.0",
+    "@angular/router": "^19.0.0",
     "rxjs": "^7.5.0"
   },
   "dependencies": {
+    "@microsoft/fetch-event-source": "^2.0.1",
     "nanoid": "^4.0.0",
     "tslib": "^2.4.0",
     "yn": "^5.0.0"
@@ -34,8 +35,6 @@
     },
     ".": {
       "types": "./index.d.ts",
-      "esm2022": "./esm2022/tuain-ng-forms-lib.mjs",
-      "esm": "./esm2022/tuain-ng-forms-lib.mjs",
       "default": "./fesm2022/tuain-ng-forms-lib.mjs"
     }
   },

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';

package/esm2022/lib/classes/forms/action.mjs

@@ -1,112 +0,0 @@
-import { Subject, takeUntil } from 'rxjs';
-import { ElementType, HEADER } from './form.constants';
-import { FormElement } from './element';
-const attrs = {
-    actionCode: { name: '_actionCode', propagate: 'actionCode' },
-    actionName: { name: '_actionName', propagate: 'actionName' },
-    iconName: { name: '_iconName', propagate: 'iconName' },
-    inProgress: { name: '_inProgress', propagate: 'inProgress' },
-    restrictedOnField: { name: '_restrictedOnField', propagate: 'restrictedOnField' },
-    restrictedOnOperator: { name: '_restrictedOnOperator', propagate: 'restrictedOnOperator' },
-    restrictedOnValue: { name: '_restrictedOnValue', propagate: 'restrictedOnValue' },
-};
-export class FormAction extends FormElement {
-    _actionActivated = new Subject();
-    _actionCode = '';
-    _actionName = '';
-    _iconName = '';
-    _inProgress = false;
-    _newState;
-    _backend;
-    _restrictedOnField = null;
-    _restrictedOnOperator = null;
-    _restrictedOnValue = null;
-    constructor(actionDefinition, formConfig) {
-        super(actionDefinition, formConfig);
-        this.elementType = ElementType.Action;
-        this.setAttr(attrs.actionCode, actionDefinition.actionCode ? actionDefinition.actionCode.toString() : '');
-        this.setAttr(attrs.actionName, actionDefinition.actionTitle);
-        this.setAttr(attrs.iconName, actionDefinition.iconName || '');
-        this.setAttr(attrs.restrictedOnField, actionDefinition.fieldRestrictedCode?.toString() ?? null);
-        if (this._restrictedOnField) {
-            this.setAttr(attrs.restrictedOnOperator, actionDefinition.operatorRestricted || '');
-            this.setAttr(attrs.restrictedOnValue, actionDefinition.valueRestricted ?? '');
-        }
-        this._backend = actionDefinition?.serverAction ?? false;
-        this._newState = actionDefinition?.newState;
-        this.setCustomAttribute('location', actionDefinition.position || HEADER);
-    }
-    get actionCode() { return this._actionCode; }
-    get actionName() { return this._actionName; }
-    get iconName() { return this._iconName; }
-    get inProgress() { return this._inProgress; }
-    get newState() { return this._newState; }
-    get backend() { return this._backend; }
-    get restrictedOnField() { return this._restrictedOnField; }
-    get restrictedOnOperator() { return this._restrictedOnOperator; }
-    get restrictedOnValue() { return this._restrictedOnValue; }
-    set actionCode(actionCode) { this.setAttr(attrs.actionCode, actionCode); }
-    set actionName(actionName) { this.setAttr(attrs.actionName, actionName); }
-    set iconName(iconName) { this.setAttr(attrs.iconName, iconName); }
-    set inProgress(inProgress) { this.setAttr(attrs.inProgress, inProgress); }
-    set newState(newState) { this._newState = newState; }
-    set backend(backend) { this._backend = backend; }
-    set restrictedOnField(restrictedOnField) { this.setAttr(attrs.restrictedOnField, restrictedOnField); }
-    set restrictedOnOperator(restrictedOnOperator) { this.setAttr(attrs.restrictedOnOperator, restrictedOnOperator); }
-    set restrictedOnValue(restrictedOnValue) { this.setAttr(attrs.restrictedOnValue, restrictedOnValue); }
-    start() { this.inProgress = true; }
-    stop() { this.inProgress = false; }
-    connectWithParentForm(form, formChangeSubject) {
-        super.connectWithParentForm(form, formChangeSubject);
-        if (this._restrictedOnField) {
-            const relatedField = this._form.fields?.[this._restrictedOnField];
-            if (relatedField) {
-                relatedField.editionFinish
-                    .pipe(takeUntil(this.destroy$))
-                    .subscribe({
-                    next: (event) => this.updateRestrictedVisibility(event),
-                    error: (err) => console.error(`Error en restricted visibility subscription: ${err}`)
-                });
-                relatedField.editionPartial
-                    .pipe(takeUntil(this.destroy$))
-                    .subscribe({
-                    next: (event) => this.updateRestrictedVisibility(event),
-                    error: (err) => console.error(`Error en restricted visibility subscription: ${err}`)
-                });
-            }
-        }
-    }
-    updateRestrictedVisibility(event) {
-        const newVisible = this._absoluteVisible && this.viewOnState(this._formState);
-        (this._visible !== newVisible) && this.setVisibility(newVisible);
-    }
-    viewOnState(state) {
-        const actionVisible = (this.visibleStates && state) ? this.visibleStates.includes(state) : false;
-        if (actionVisible && this._form && this._restrictedOnField) {
-            const relatedField = this._form.fields?.[this._restrictedOnField];
-            if (relatedField) {
-                const fieldValue = relatedField.value;
-                if ((this._restrictedOnOperator === '==' && fieldValue !== this._restrictedOnValue)
-                    || (this._restrictedOnOperator === '!=' && fieldValue === this._restrictedOnValue)) {
-                    return false;
-                }
-            }
-        }
-        return actionVisible;
-    }
-    get actionActivated() { return this._actionActivated.asObservable(); }
-    notifyActivation() { this._actionActivated.next(this._actionCode); }
-    updateFromServer(receivedAction) {
-        for (const propertyName in receivedAction) {
-            if (propertyName !== 'actionCode' && propertyName !== 'actionId') {
-                try {
-                    this[propertyName] = receivedAction[propertyName];
-                }
-                catch (e) {
-                    console.log(`Error actualizando la propiedad ${propertyName} de la acción ${this.actionCode}. ${e}`);
-                }
-            }
-        }
-    }
-}
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"action.js","sourceRoot":"","sources":["../../../../../../projects/tuain-ng-forms-lib/src/lib/classes/forms/action.ts"],"names":[],"mappings":"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","sourcesContent":["import { Observable, Subject, takeUntil } from 'rxjs';\nimport { ElementType, HEADER } from './form.constants';\nimport { FormElement } from './element';\nimport { ActionDefinition, IFormConfig } from '../../interfaces/form-config.interface';\n\nconst attrs = {\n  actionCode: { name: '_actionCode', propagate: 'actionCode' },\n  actionName: { name: '_actionName', propagate: 'actionName' },\n  iconName: { name: '_iconName', propagate: 'iconName' },\n  inProgress: { name: '_inProgress', propagate: 'inProgress' },\n  restrictedOnField: { name: '_restrictedOnField', propagate: 'restrictedOnField' },\n  restrictedOnOperator: { name: '_restrictedOnOperator', propagate: 'restrictedOnOperator' },\n  restrictedOnValue: { name: '_restrictedOnValue', propagate: 'restrictedOnValue' },\n}\n\nexport class FormAction extends FormElement {\n  private readonly _actionActivated = new Subject<string>();\n  private _actionCode: string = '';\n  private _actionName: string = '';\n  private _iconName: string = '';\n  private _inProgress = false;\n  private _newState: string;\n  private _backend: boolean;\n  private _restrictedOnField: string | null = null;\n  private _restrictedOnOperator: string | null = null;\n  private _restrictedOnValue: string | null = null;\n\n  constructor(actionDefinition: ActionDefinition, formConfig: IFormConfig) {\n    super(actionDefinition, formConfig);\n    this.elementType = ElementType.Action;\n    this.setAttr(attrs.actionCode, actionDefinition.actionCode ? actionDefinition.actionCode.toString() : '');\n    this.setAttr(attrs.actionName, actionDefinition.actionTitle);\n    this.setAttr(attrs.iconName, actionDefinition.iconName || '');\n    this.setAttr(attrs.restrictedOnField, actionDefinition.fieldRestrictedCode?.toString() ?? null);\n    if (this._restrictedOnField) {\n      this.setAttr(attrs.restrictedOnOperator, actionDefinition.operatorRestricted || '');\n      this.setAttr(attrs.restrictedOnValue, actionDefinition.valueRestricted ?? '');\n    }\n    this._backend = actionDefinition?.serverAction ?? false;\n    this._newState = actionDefinition?.newState;\n    this.setCustomAttribute('location', actionDefinition.position || HEADER);\n  }\n\n  get actionCode(): string { return this._actionCode; }\n  get actionName(): string { return this._actionName; }\n  get iconName(): string { return this._iconName; }\n  get inProgress(): boolean { return this._inProgress; }\n  get newState(): string { return this._newState; }\n  get backend(): boolean { return this._backend; }\n  get restrictedOnField(): string | null { return this._restrictedOnField; }\n  get restrictedOnOperator(): string | null { return this._restrictedOnOperator; }\n  get restrictedOnValue(): string | null { return this._restrictedOnValue; }\n\n  set actionCode(actionCode) { this.setAttr(attrs.actionCode, actionCode); }\n  set actionName(actionName) { this.setAttr(attrs.actionName, actionName); }\n  set iconName(iconName) { this.setAttr(attrs.iconName, iconName); }\n  set inProgress(inProgress) { this.setAttr(attrs.inProgress, inProgress); }\n  set newState(newState) { this._newState = newState; }\n  set backend(backend) { this._backend = backend; }\n  set restrictedOnField(restrictedOnField) { this.setAttr(attrs.restrictedOnField, restrictedOnField); }\n  set restrictedOnOperator(restrictedOnOperator) { this.setAttr(attrs.restrictedOnOperator, restrictedOnOperator); }\n  set restrictedOnValue(restrictedOnValue) { this.setAttr(attrs.restrictedOnValue, restrictedOnValue); }\n\n  start(): void { this.inProgress = true; }\n  stop(): void { this.inProgress = false; }\n\n  override connectWithParentForm(form: any, formChangeSubject: any): void {\n    super.connectWithParentForm(form, formChangeSubject);\n    if (this._restrictedOnField) {\n      const relatedField = this._form.fields?.[this._restrictedOnField];\n      if (relatedField) {\n        relatedField.editionFinish\n          .pipe(takeUntil(this.destroy$))\n          .subscribe({\n            next: (event: any) => this.updateRestrictedVisibility(event),\n            error: (err: any) => console.error(`Error en restricted visibility subscription: ${err}`)\n          });\n        relatedField.editionPartial\n          .pipe(takeUntil(this.destroy$))\n          .subscribe({\n            next: (event: any) => this.updateRestrictedVisibility(event),\n            error: (err: any) => console.error(`Error en restricted visibility subscription: ${err}`)\n          });\n      }\n    }\n  }\n\n  updateRestrictedVisibility(event: any): void {\n    const newVisible = this._absoluteVisible && this.viewOnState(this._formState);\n    (this._visible !== newVisible) && this.setVisibility(newVisible);\n  }\n\n  override viewOnState(state: string): boolean {\n    const actionVisible = (this.visibleStates && state) ? this.visibleStates.includes(state) : false;\n    if (actionVisible && this._form && this._restrictedOnField) {\n      const relatedField = this._form.fields?.[this._restrictedOnField];\n      if (relatedField) {\n        const fieldValue = relatedField.value;\n        if ((this._restrictedOnOperator === '==' && fieldValue !== this._restrictedOnValue)\n          || (this._restrictedOnOperator === '!=' && fieldValue === this._restrictedOnValue)) {\n          return false;\n        }\n      }\n    }\n    return actionVisible;\n  }\n\n  get actionActivated(): Observable<string> { return this._actionActivated.asObservable(); }\n\n  notifyActivation(): void { this._actionActivated.next(this._actionCode); }\n\n  updateFromServer(receivedAction: any): void {\n    for (const propertyName in receivedAction) {\n      if (propertyName !== 'actionCode' && propertyName !== 'actionId') {\n        try {\n          (this as any)[propertyName] = receivedAction[propertyName];\n        } catch (e) {\n          console.log(`Error actualizando la propiedad ${propertyName} de la acción ${this.actionCode}. ${e}`);\n        }\n      }\n    }\n  }\n}\n"]}

package/esm2022/lib/classes/forms/element.mjs

@@ -1,25 +0,0 @@
-import { FormPiecePropagate } from './piece-propagate';
-import { ElementType } from './form.constants';
-export class FormElement extends FormPiecePropagate {
-    elementType = null;
-    constructor(elementDefinition, formConfig) {
-        super(elementDefinition, formConfig);
-    }
-    setAttr(attr, value) {
-        const { name: attrName, propagate: name } = attr;
-        try {
-            const currentValue = this[attrName];
-            if (currentValue !== value) {
-                this[attrName] = value;
-                name && this.propagateAttribute(name, value);
-            }
-        }
-        catch (e) {
-            console.log(`Atributo ${attrName} no presente o valor ${value} inconsistente. ${e}`);
-        }
-    }
-    isField() { return this.elementType === ElementType.Field; }
-    isAction() { return this.elementType === ElementType.Action; }
-    isTable() { return this.elementType === ElementType.Table; }
-}
-//# sourceMappingURL=data:application/json;base64,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