ngx-dsxlibrary 1.0.61 → 1.0.62

package/fesm2022/ngx-dsxlibrary.mjs

@@ -465,19 +465,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 +531,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 +564,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 +629,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 +645,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 +703,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 +748,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 +1129,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,