Es correcta esta forma de implementar un funcion que recibe funciones en Typescript /...

En mi proyecto de Angular, tengo un servicio que gestiona los Modal del framework MDBootstrap. Y cree otro servicio adicional para gestionar un Modal de confirmación. El cual le cree un método que recibe el mensaje a mostrar, y dos funciones, onConfirm y onCancel, ambos son opcionales.

ModalService

import { Injectable } from '@angular/core';
import { MdbModalConfig } from 'mdb-angular-ui-kit/modal';
import { MdbModalService, MdbModalRef } from 'mdb-angular-ui-kit/modal';

@Injectable({
providedIn: 'root'
})

export class ModalService {
private modalRef: MdbModalRef<any> | null = null;

constructor(
private modalService: MdbModalService,
) { }

/**
* Método para abrir un modal genérico
* @param component - Componente que se mostrará en el modal
* @param data - Datos opcionales que se pasan al modal
* @param modalClass - Clase CSS opcional para personalizar el modal
* @returns MdbModalRef - Referencia del modal abierto
*/
abrirModal(component: any, config: MdbModalConfig<any>): MdbModalRef<any> {
this.modalRef = this.modalService.open(component, config);
return this.modalRef;
}

/**
* Método para cerrar el modal actualmente abierto
*/
cerrarModal(message?: string): void {
if (this.modalRef) {
this.modalRef.close(message);
this.modalRef = null;
}
}


/**
* Método para verificar si hay un modal abierto
* @returns boolean - Verdadero si hay un modal abierto
*/
modalActivo(): boolean {
return this.modalRef !== null;
}

}


ModalConfirmService

import { Injectable } from '@angular/core';
import { ModalService } from './modal.service';
import { ModalConfirmComponent } from '../components/modal-confirm/modal-confirm.component';

interface ModalConfirmData {
message: string;
onConfirm?: () => void;
onCancel?: () => void;
}

@Injectable({
providedIn: 'root'
})
export class ModalConfirmService {
constructor(
private modalService: ModalService,
) {}

/**
* Método para abrir un modal de confirmación
* @param message - Mensaje a mostrar en el modal
* @param onConfirm - Función a ejecutar si se confirma el modal
* @param onCancel - Función a ejecutar si se cancela el modal
*/
abrirModalConfirm(modalConfirmData: ModalConfirmData): void {
this.modalService.abrirModal(ModalConfirmComponent, {
data: {
message: modalConfirmData.message,
}
}).onClose.subscribe((status: string) => {
if (status === 'accepted' && modalConfirmData.onConfirm) {
modalConfirmData.onConfirm();
} else if (modalConfirmData.onCancel) {
modalConfirmData.onCancel();
}
});
}
}


Implementación

this.modalConfirmService.abrirModalConfirm({
message,
onConfirm: () => // HACER ALGO SI SE CONFIRMA,
onCancel: () => // HACER ALGO SI SE CANCELA
})


Necesito saber si el desarrollo del método abrirModalConfirm esta bien desarrollada, me refiero a las buenas practicas, o debiese ocupar un Promise?

Continue reading...