ngx-dsxlibrary 1.0.61 → 1.0.63

package/fesm2022/ngx-dsxlibrary.mjs

@@ -20,7 +20,6 @@ import { JwtHelperService } from '@auth0/angular-jwt';
 import { CookieService } from 'ngx-cookie-service';
 import { CommonModule } from '@angular/common';
 import { AccordionModule } from 'primeng/accordion';
-import { MessageService } from 'primeng/api';
 import { AutoCompleteModule } from 'primeng/autocomplete';
 import { AutoFocusModule } from 'primeng/autofocus';
 import { AvatarModule } from 'primeng/avatar';
@@ -220,6 +219,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.6", ngImpor
 
 class AlertaService {
     toastrService = inject(ToastrService);
+    //private primeMessageService = inject(MessageService);
     /**
      * @param {number} toastrType - 1. Success 2. Info 3. Warning 4. Error
      * @param {string} toastrTitle - Titulo de la alerta
@@ -369,22 +369,27 @@ class AlertaService {
         }
         return Swal.fire(alertConfig);
     }
-    configureTimer(config, showConfirmButton, timer) {
-        if (!showConfirmButton && timer > 0) {
-            config.timer = timer;
-            config.timerProgressBar = true;
-        }
-    }
-    //notifyAlertSuccess(message: string) {
-    //  this._notyf.success({
-    //    message: message,
-    //    duration: 1500,
-    //    position: {
-    //      x: 'center',
-    //      y: 'top'
-    //    }
-    //  });
-    //}
+    // private configureTimer(
+    //   config: SweetAlertOptions,
+    //   showConfirmButton: boolean,
+    //   timer: number
+    // ) {
+    //   if (!showConfirmButton && timer > 0) {
+    //     config.timer = timer;
+    //     config.timerProgressBar = true;
+    //   }
+    // }
+    // No se puede utilizar por conflicto con primeng
+    // notyfAlert(message: string) {
+    //   this.notyf.success({
+    //     message: message,
+    //     duration: 1500,
+    //     position: {
+    //       x: 'center',
+    //       y: 'top',
+    //     },
+    //   });
+    // }
     toastrHttpResponse(response) {
         const time = 3000;
         const align = 'toast-top-center';
@@ -465,19 +470,54 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.6", ngImpor
 
 /**
  * Servicio para gestionar los parámetros de seguridad de la aplicación.
- * Permite cargar los parámetros desde la API, mantenerlos en memoria, y acceder
- * a sus valores de forma segura evitando `undefined` en los componentes.
+ * Permite cargar los parámetros desde la API, mantenerlos en memoria, acceder y comparar valores de forma segura.
+ * Utiliza tipado genérico para los nombres de parámetros y cache interno para optimizar consultas repetidas.
+ *
+ * @template T Tipo de los nombres de parámetros permitidos (usualmente un union type de string)
  */
 class ParameterValuesService {
-    /** Parámetros iniciales inyectados mediante INITIAL_PARAMETERS */
+    /**
+     * Parámetros iniciales inyectados mediante INITIAL_PARAMETERS.
+     * Se usan para validar y mapear los parámetros recibidos de la API.
+     */
     initialParameters = inject(INITIAL_PARAMETERS);
-    /** Servicio que contiene el método getParameterSecurity() */
+    /**
+     * Cache interno para optimizar la comparación de valores de parámetros.
+     * La clave es una combinación de nombre e índice, el valor es el resultado de la consulta.
+     */
+    parameterCache = new Map();
+    alertedParams = new Set();
+    /**
+     * Servicio que contiene el método getParameterSecurity() para obtener los parámetros desde la API.
+     */
     apiService = inject(SecurityService);
-    /** Señal que contiene los parámetros cargados */
-    _dataParameter = signal(this.initialParameters, ...(ngDevMode ? [{ debugName: "_dataParameter" }] : []));
-    /** Flag que indica si ya se cargaron los parámetros desde la API */
+    /**
+     * Señal reactiva que contiene los parámetros cargados y permite actualizaciones automáticas.
+     */
+    _dataParameter = signal(this.initializeData(), ...(ngDevMode ? [{ debugName: "_dataParameter" }] : []));
+    /**
+     * Flag que indica si ya se cargaron los parámetros desde la API.
+     */
     _loaded = false;
-    /** ===================== GETTERS/SETTERS ===================== */
+    /**
+     * Inicializa los datos de parámetros usando los valores inyectados.
+     * @returns Array de parámetros iniciales tipados
+     */
+    initializeData() {
+        return this.initialParameters.map((param) => this.createMyParameterValue(param.parameterName, param.values));
+    }
+    /**
+     * Crea una instancia de MyParameterValues tipada y segura.
+     * @param parameterName Nombre del parámetro
+     * @param values Valores asociados al parámetro
+     * @returns Objeto MyParameterValues
+     */
+    createMyParameterValue(parameterName, values) {
+        return {
+            parameterName,
+            values: [...values],
+        };
+    }
     /**
      * Devuelve los parámetros actuales como un array de solo lectura.
      */
@@ -496,7 +536,6 @@ class ParameterValuesService {
         }
         this._dataParameter.set(values);
     }
-    /** ===================== MÉTODOS PRINCIPALES ===================== */
     /**
      * Carga los parámetros desde la API.
      * Si ya se cargaron y force=false, devuelve la copia en memoria.
@@ -530,7 +569,53 @@ class ParameterValuesService {
     refreshParameters() {
         return this.loadParameters(true);
     }
-    /** ===================== MÉTODOS PRIVADOS ===================== */
+    /**
+     * Crea una copia segura y mutable de los parámetros actuales.
+     * @returns Array de parámetros
+     */
+    createSafeCopy() {
+        return this.dataParameter.map((item) => this.createMyParameterValue(item.parameterName, [...item.values]));
+    }
+    /**
+     * Mapea los parámetros recibidos de la API a objetos tipados y seguros.
+     * @param apiParameters Parámetros recibidos desde la API
+     * @returns Array de MyParameterValues
+     */
+    mapToMyParameterValues(apiParameters) {
+        const initialNames = this.initialParameters.map((p) => p.parameterName);
+        return apiParameters
+            .filter((param) => initialNames.includes(param.parameterName))
+            .map((param) => {
+            // Función de conversión type-safe
+            return this.convertToTypedParameter(param);
+        })
+            .filter((param) => param !== null);
+    }
+    /**
+     * Convierte un parámetro de la API a un objeto tipado, validando el nombre.
+     * @param param Parámetro recibido de la API
+     * @returns Objeto MyParameterValues o null si no es válido
+     */
+    convertToTypedParameter(param) {
+        const initialParam = this.initialParameters.find((p) => p.parameterName === param.parameterName);
+        if (!initialParam) {
+            return null;
+        }
+        // Conversión segura con verificación
+        if (this.isValidParameterName(param.parameterName)) {
+            return this.createMyParameterValue(param.parameterName, param.parameterValues?.map((v) => v.value) ?? []);
+        }
+        return null;
+    }
+    /**
+     * Verifica si un nombre de parámetro es válido según los parámetros iniciales.
+     * @param name Nombre a validar
+     * @returns true si es válido
+     */
+    isValidParameterName(name) {
+        // Verifica que el nombre esté en los parámetros iniciales
+        return this.initialParameters.some((param) => param.parameterName === name);
+    }
     /**
      * Valida que los parámetros devueltos por la API coincidan con los iniciales.
      * Muestra errores o advertencias en consola si existen diferencias.
@@ -549,21 +634,6 @@ class ParameterValuesService {
             console.warn(`Cantidad distinta: iniciales=${initialNames.length}, api=${apiNames.length}`);
         }
     }
-    /**
-     * Transforma un array de ParameterSecurity en MyParameterValues
-     * @param apiParameters Parámetros recibidos desde la API
-     * @returns Array de MyParameterValues
-     */
-    mapToMyParameterValues(apiParameters) {
-        const initialNames = this.initialParameters.map((p) => p.parameterName);
-        return apiParameters
-            .filter((param) => initialNames.includes(param.parameterName))
-            .map((param) => ({
-            parameterName: param.parameterName,
-            values: param.parameterValues?.map((v) => v.value) ?? [],
-        }));
-    }
-    /** ===================== HELPERS SEGUROS ===================== */
     /**
      * Obtiene un valor específico de un parámetro.
      * Devuelve `defaultValue` si no existe o el índice es inválido.
@@ -580,14 +650,35 @@ class ParameterValuesService {
         return param.values[index];
     }
     /**
-     * Compara un valor específico con un valor esperado.
+     * Compara un valor específico con un valor esperado, usando cache para optimizar llamadas repetidas.
      * @param parameterName Nombre del parámetro
      * @param expectedValue Valor esperado
      * @param index Índice del valor dentro del array (default: 0)
      * @returns true si coincide, false en caso contrario
      */
     isParameterValue(parameterName, expectedValue, index = 0) {
-        return this.getValue(parameterName, index) === expectedValue;
+        const cacheKey = `${String(parameterName)}_${index}`;
+        // Validación: si el parámetro no existe, muestra mensaje solo una vez y corta el flujo
+        const paramExists = this.dataParameter.some((p) => p.parameterName === parameterName);
+        if (!paramExists) {
+            if (!this.alertedParams.has(parameterName)) {
+                window.alert(`Error: El parámetro '${parameterName}' no existe.`);
+                this.alertedParams.add(parameterName);
+            }
+            return false;
+        }
+        if (!this.parameterCache.has(cacheKey)) {
+            //console.log('Parametro: ' + parameterName);
+            const value = this.getValue(parameterName, index);
+            this.parameterCache.set(cacheKey, value);
+        }
+        return this.parameterCache.get(cacheKey) === expectedValue;
+    }
+    /**
+     * Limpia el cache interno de comparaciones de parámetros.
+     */
+    clearParameterCache() {
+        this.parameterCache.clear();
     }
     /**
      * Verifica si un parámetro tiene al menos un valor.
@@ -617,7 +708,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.6", ngImpor
         }] });
 
 class NavbarDsxComponent {
-    _securityService = inject(SecurityService);
+    //private _securityService = inject(SecurityService);
     _parameterSecurityService = inject(ParameterValuesService);
     _alertaService = inject(AlertaService);
     logoWidth = input('300', ...(ngDevMode ? [{ debugName: "logoWidth" }] : []));
@@ -662,7 +753,7 @@ class NavbarDsxComponent {
                 console.error('Error al actualizar parámetros de SeguridadIT', err);
                 this._alertaService.toastrAlerts(3, 'SeguridadIT', 'Error al actualizar parámetros!', 2);
             },
-            complete: () => '',
+            complete: () => this._parameterSecurityService.clearParameterCache(),
         });
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: NavbarDsxComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
@@ -1043,13 +1134,6 @@ function createInitialCache(cacheKeys) {
     return Object.fromEntries(Object.values(cacheKeys).map((key) => [key, false]));
 }
 
-const INITIAL_PARAMETERS_FOR_TYPE = [
-    'pCreate',
-    'pRead',
-    'pUpdate',
-    'pDelete',
-];
-
 class DsxAddToolsModule {
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: DsxAddToolsModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
     static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.1.6", ngImport: i0, type: DsxAddToolsModule, imports: [JsonValuesDebujComponent], exports: [CommonModule,
@@ -1071,6 +1155,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.6", ngImpor
                         JsonValuesDebujComponent,
                         ReactiveFormsModule,
                     ],
+                    providers: [],
                 }]
         }] });
 
@@ -1140,7 +1225,7 @@ class PrimeNgModule {
             ToastModule,
             ToggleButtonModule,
             TooltipModule] });
-    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: PrimeNgModule, providers: [MessageService], imports: [AccordionModule,
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: PrimeNgModule, imports: [AccordionModule,
             AutoCompleteModule,
             AutoFocusModule,
             AvatarGroupModule,
@@ -1178,7 +1263,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.6", ngImpor
                     declarations: [],
                     imports: [],
                     exports: [...PRIME_NG_MODULES],
-                    providers: [MessageService],
+                    providers: [],
                 }]
         }] });
 
@@ -1459,39 +1544,38 @@ class UtilityAddService {
      *
      * @template T - El tipo genérico del modelo a procesar.
      * @param form - El formulario reactivo de Angular del que se obtendrán los valores.
-     * @param campos - Un array de objetos que especifican los campos de fecha y el tipo de conversión a aplicar. Cada objeto debe contener:
+     * @param campos - Uno o más objetos que especifican los campos de fecha y el tipo de conversión a aplicar. Cada objeto debe contener:
      *   - `nombre`: El nombre del campo de fecha en el modelo.
      *   - `tipo`: El tipo de conversión que se debe aplicar (por ejemplo, `'short'` o `'zh'`).
-     * @param fieldName - (Opcional) El nombre de un campo específico en el formulario que contiene los datos. Si no se proporciona, se obtendrán todos los valores del formulario.
-     * @returns Un objeto del tipo `typeModel<T>` que contiene un array `values` con los datos procesados y las conversiones de fecha aplicadas.
-     * @throws Error - Si el campo especificado no existe en el formulario, o si un campo de fecha especificado no existe en los datos.
+     * @returns Un objeto del tipo `typeModel<T>` con los datos procesados y las conversiones de fecha aplicadas.
+     * @throws Error - Si el campo de fecha especificado no existe en los datos del formulario.
+     *
+     * @example
+     * // Procesar varios campos de fecha
+     * const precioValues = service.sanitizarModelo<ItemPrecioModel>(
+     *   form,
+     *   { nombre: 'fechaInicio', tipo: 'short' },
+     *   { nombre: 'fechaFin', tipo: 'zh' }
+     * );
      */
-    sanitizarModelo(form, campos, fieldName) {
-        // Obtén los valores del formulario: un campo específico o todos los valores
-        const rawData = fieldName
-            ? form.get(fieldName)?.getRawValue()
-            : form.getRawValue();
+    sanitizarModelo(form, ...campos) {
+        // Obtén todos los valores del formulario
+        const rawData = form.getRawValue();
         if (!rawData) {
-            const errorMessage = fieldName
-                ? `El campo "${fieldName}" no existe en el formulario.`
-                : `El formulario no tiene valores.`;
-            throw new Error(errorMessage);
+            throw new Error('El formulario no tiene valores.');
         }
         // Procesa los valores sin envolver en un arreglo
-        const updatedValue = { ...rawData }; // Esto es un objeto, no un array
+        const updatedValue = { ...rawData };
         // Itera sobre los campos de fecha especificados para realizar las conversiones
         campos.forEach(({ nombre, tipo }) => {
-            // Verifica si el campo de fecha existe en el valor
             if (!(nombre in updatedValue)) {
                 throw new Error(`El campo "${nombre}" no existe en el valor.`);
             }
-            // Realiza la conversión de la fecha si tiene un valor
             updatedValue[nombre] = updatedValue[nombre]
-                ? this.convertirFecha(updatedValue[nombre], tipo) // Llama a la función genérica de conversión
+                ? this.convertirFecha(updatedValue[nombre], tipo)
                 : null;
         });
-        // Retorna el objeto con los valores procesados, no un arreglo
-        return updatedValue; // Devuelves un objeto con los valores, no un array
+        return updatedValue;
     }
     /**
      * Convierte una fecha al formato especificado.
@@ -1504,6 +1588,26 @@ class UtilityAddService {
      * @returns La fecha convertida como string según el tipo especificado.
      * @throws Error - Si el tipo de conversión no es válido o soportado.
      */
+    /**
+     * Convierte una fecha al formato especificado.
+     *
+     * @param fecha - La fecha en formato string que se desea convertir.
+     *                Debe estar en un formato reconocible por `Date` o en ISO 8601.
+     * @param tipo - El tipo de conversión a realizar. Actualmente soporta:
+     *               - `'short'`: Convierte la fecha a un formato corto (YYYY-MM-DD).
+     *               - `'zh'`: Convierte la fecha considerando la zona horaria configurada.
+     *               - `'iso'`: Convierte la fecha a formato ISO 8601 (string).
+     * @returns La fecha convertida como string según el tipo especificado.
+     * @throws Error - Si el tipo de conversión no es válido o soportado.
+     *
+     * @example
+     * // Formato corto
+     * service.convertirFecha('2025-08-21', 'short'); // '2025-08-21'
+     * // Zona horaria
+     * service.convertirFecha('2025-08-21', 'zh'); // '2025-08-21T00:00:00-06:00' (ejemplo)
+     * // Formato ISO
+     * service.convertirFecha('2025-08-21', 'iso'); // '2025-08-21T00:00:00.000Z'
+     */
     convertirFecha(fecha, tipo) {
         switch (tipo) {
             case 'short':
@@ -1512,6 +1616,11 @@ class UtilityAddService {
             case 'zh':
                 // Implementación para zonas horarias
                 return this.convertirFechaSegunZonaHoraria(fecha);
+            case 'iso': {
+                // Convertir a Date y luego a string ISO
+                const date = this.convertirFechaISOString(fecha);
+                return date ? date.toISOString() : null;
+            }
             default:
                 throw new Error(`Tipo de conversión desconocido: ${tipo}`);
         }