@jvsoft/utils 0.0.13-alpha.5 → 1.0.0-alpha.10

package/fesm2022/jvsoft-utils.mjs

@@ -1,27 +1,24 @@
-import { Validators, FormGroup, FormControl, FormArray } from '@angular/forms';
-import { untilDestroyed } from '@ngneat/until-destroy';
-import { startWith, debounceTime, tap, isObservable, switchMap, of, finalize } from 'rxjs';
+import { Validators, FormGroup, FormControl, FormArray, NG_VALIDATORS, NgControl, FormControlName } from '@angular/forms';
+import * as i0 from '@angular/core';
+import { inject, DestroyRef, Pipe, input, forwardRef, Directive, computed, Component, TemplateRef, Injectable, ElementRef, ViewContainerRef, HostListener, output, effect, untracked, signal } from '@angular/core';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import { tap, startWith, debounceTime, isObservable, switchMap, of, finalize, Subject, merge, distinctUntilChanged, map as map$1 } from 'rxjs';
 import { map } from 'rxjs/operators';
 import { Buffer } from 'buffer';
 import CryptoJS from 'crypto-js';
-import { formatDate } from '@angular/common';
+import * as i1$1 from '@angular/common';
+import { formatDate, CommonModule } from '@angular/common';
 import { saveAs } from 'file-saver';
 import { ReactiveFormConfig } from '@rxweb/reactive-form-validators';
 import moment from 'moment';
 import swal from 'sweetalert2';
 import { jwtDecode } from 'jwt-decode';
-import * as i0 from '@angular/core';
-import { Pipe } from '@angular/core';
 import * as i1 from '@angular/platform-browser';
+import { Overlay, OverlayPositionBuilder } from '@angular/cdk/overlay';
+import { ComponentPortal } from '@angular/cdk/portal';
+import { ToastrService } from 'ngx-toastr';
+import { format } from 'date-fns';
 
-/**
- * Realiza una fusión profunda entre dos objetos, sin modificar el original.
- * Si el valor en target no es un objeto, lo reemplaza directamente.
- *
- * @param source - Objeto fuente que se clonará y fusionará.
- * @param target - Objeto destino cuyos valores se fusionarán.
- * @returns Un nuevo objeto con la fusión profunda.
- */
 function deepMerge(source, target) {
     // Crea un clon profundo sin usar JSON.parse(JSON.stringify)
     let cloneSource = deepClone(source);
@@ -43,12 +40,7 @@ function deepMerge(source, target) {
     }
     return cloneSource; // Retorna el clon y no modifica el original
 }
-/**
- * Realiza una clonación profunda de un objeto, manejando funciones, fechas y arrays.
- *
- * @param obj - Objeto a clonar.
- * @returns Una copia profunda del objeto.
- */
+// Función de clonación profunda que maneja funciones, fechas y otros tipos especiales
 function deepClone(obj) {
     if (obj === null || typeof obj !== 'object') {
         return obj; // Devuelve el valor si no es un objeto
@@ -74,7 +66,6 @@ function deepClone(obj) {
 /**
  * Busca un elemento en un array o jerarquía de objetos según un campo y valor especificado.
  *
- * @param datosFn - Objeto con los parámetros de búsqueda: items, campo, valor y opcionalmente campoHijo.
  * @returns El elemento encontrado o undefined si no existe.
  */
 function buscarPorCampo(datosFn) {
@@ -101,33 +92,13 @@ function buscarPorCampo(datosFn) {
     // Si no se encuentra nada, retorna undefined
     return undefined;
 }
-/**
- * Suma los valores de las propiedades especificadas de un objeto.
- *
- * @param item - Objeto con las propiedades a sumar.
- * @param campos - Array de nombres de las propiedades a sumar.
- * @returns La suma de los valores de las propiedades.
- */
 function sumarPropiedades(item, campos) {
     const datosSumar = campos.map(campo => (item[campo] * 1));
     return datosSumar.reduce((a, b) => a + b, 0);
 }
-/**
- * Verifica si el valor proporcionado es un número válido.
- *
- * @param value - Valor a verificar.
- * @returns true si es un número, false en caso contrario.
- */
 function esNumero(value) {
     return !isNaN(Number(value));
 }
-/**
- * Suma los valores de las propiedades especificadas en un array de objetos.
- *
- * @param arrayObjetos - Array de objetos a procesar.
- * @param campos - Array de nombres de las propiedades a sumar.
- * @returns Objeto con la suma de cada propiedad.
- */
 function sumarObjetos(arrayObjetos, campos) {
     return arrayObjetos.reduce((accumulator, item) => {
         campos.forEach(campo => {
@@ -139,22 +110,9 @@ function sumarObjetos(arrayObjetos, campos) {
         return accumulator;
     }, {});
 }
-/**
- * Obtiene los valores únicos de un array.
- *
- * @param array - Array de valores.
- * @returns Array con los valores únicos.
- */
 function getUniqueValues(array) {
     return array.filter((currentValue, index, arr) => (arr.indexOf(currentValue) === index));
 }
-/**
- * Obtiene los objetos únicos de un array según una propiedad específica.
- *
- * @param objetos - Array de objetos.
- * @param campo - Nombre de la propiedad para determinar unicidad.
- * @returns Array de objetos únicos por la propiedad.
- */
 function getUniqueValuesByProperty(objetos, campo) {
     const objetosUnicos = {};
     objetos.forEach(objeto => {
@@ -170,14 +128,6 @@ function getUniqueValuesByProperty(objetos, campo) {
     // Convertir el objeto de claves únicas de vuelta a una lista de objetos
     return Object.values(objetosUnicos);
 }
-/**
- * Ordena un array de valores numéricos o alfabéticos.
- *
- * @param array - Array a ordenar.
- * @param numeros - Si es true, ordena como números.
- * @param sentido - 'ASC' para ascendente, 'DESC' para descendente.
- * @returns Array ordenado.
- */
 function ordenarArray(array, numeros = false, sentido = 'ASC') {
     if (numeros) {
         if (sentido != 'ASC') {
@@ -187,24 +137,9 @@ function ordenarArray(array, numeros = false, sentido = 'ASC') {
     }
     return array.sort((a, b) => (a > b) ? 1 : ((b > a) ? -1 : 0));
 }
-/**
- * Ordena un array de objetos por una propiedad específica.
- *
- * @param objData - Array de objetos a ordenar.
- * @param propiedad - Propiedad por la que se ordena.
- * @param numeros - (Obsoleto) Si es true, ordena como números.
- * @returns Array ordenado.
- */
 function ordenarPorPropiedad(objData, propiedad, /**@deprecated*/ numeros = false) {
     return ordenarPorPropiedades(objData, { propiedades: [propiedad], direcciones: ['asc'] });
 }
-/**
- * Ordena un array de objetos por varias propiedades y direcciones.
- *
- * @param arr - Array de objetos a ordenar.
- * @param options - Opciones con propiedades y direcciones de orden.
- * @returns Array ordenado.
- */
 function ordenarPorPropiedades(arr, options) {
     const { propiedades, direcciones = [] } = options;
     const orden = direcciones.map(d => d === 'desc' ? -1 : 1);
@@ -224,13 +159,6 @@ function ordenarPorPropiedades(arr, options) {
         }, 0);
     });
 }
-/**
- * Agrupa los elementos de un array según una clave o función de clave.
- *
- * @param array - Array de objetos a agrupar.
- * @param key - Propiedad o función para agrupar.
- * @returns Objeto con los grupos por clave.
- */
 function groupBy(array, key) {
     const keyFn = key instanceof Function ? key : (obj) => obj[key];
     return array.reduce((objectsByKeyValue, obj) => {
@@ -239,13 +167,6 @@ function groupBy(array, key) {
         return objectsByKeyValue;
     }, {});
 }
-/**
- * Agrupa y anida los elementos de un array según una lista de propiedades.
- *
- * @param arr - Array de objetos a agrupar.
- * @param properties - Propiedades para agrupar de forma anidada.
- * @returns Objeto anidado por los grupos de propiedades.
- */
 function nestGroupsBy(arr, properties) {
     const fnGroupBy = (conversions, property2) => {
         return conversions.reduce((acc, obj) => {
@@ -319,13 +240,6 @@ function eliminarColumnaPorIndex(data, columnIndex) {
         return newRow;
     });
 }
-/**
- * Elimina elementos duplicados de un array de objetos según claves específicas.
- *
- * @param array - Array de objetos.
- * @param claves - Claves para determinar unicidad. Si no se especifica, compara todo el objeto.
- * @returns Array sin duplicados.
- */
 function eliminarDuplicados(array, claves) {
     const unicos = new Map();
     for (const item of array) {
@@ -338,14 +252,6 @@ function eliminarDuplicados(array, claves) {
     }
     return Array.from(unicos.values());
 }
-/**
- * Elimina elementos de un array origen que estén presentes en otro array, según claves específicas.
- *
- * @param origen - Array original.
- * @param elementosAEliminar - Elementos a eliminar del array origen.
- * @param claves - Claves para comparar los objetos. Si no se especifica, compara todo el objeto.
- * @returns Array filtrado sin los elementos eliminados.
- */
 function eliminarElementos(origen, elementosAEliminar, claves) {
     const clavesSet = new Set();
     for (const item of elementosAEliminar) {
@@ -361,41 +267,12 @@ function eliminarElementos(origen, elementosAEliminar, claves) {
         return !clavesSet.has(key);
     });
 }
-
-/**
- * Devuelve un valor de visualización para un elemento buscado.
- * Compatible con listas simples, objetos y campos múltiples.
- */
-function mostrarValorEnBusqueda(campos, idxSel) {
-    const buscarEnLista = (lista) => {
-        if (!lista)
-            return null;
-        if (campos.campoId === '*object*' || campos.campoId === '*objeto*') {
-            return lista.find((x) => JSON.stringify(x).trim() === JSON.stringify(idxSel).trim());
-        }
-        return lista.find((x) => x[campos.campoId] === idxSel);
-    };
-    const impDataMostrar = () => {
-        let vD = buscarEnLista(campos.lista) || (campos.opcExtra && buscarEnLista(campos.opcExtra));
-        if (!vD)
-            return '';
-        if (Array.isArray(campos.campoValue)) {
-            return campos.campoValue.map((vCampo) => vD[vCampo] ?? '').join(' - ').trim();
-        }
-        return (vD[campos.campoValue] ?? '').trim();
-    };
-    if (esNumero(idxSel)) {
-        if ((idxSel > 0 && campos.lista?.length) || (idxSel && typeof idxSel === 'object')) {
-            return impDataMostrar();
-        }
-    }
-    else if (campos.lista?.length) {
-        return impDataMostrar();
-    }
-    return '';
-}
 /**
- * Filtra datos locales de un array basado en un valor de búsqueda.
+ * Filtra datos localmente según un valor de búsqueda
+ * @param data - Array de datos a filtrar
+ * @param value - Valor de búsqueda
+ * @param campoBuscar - Campo(s) por el cual buscar
+ * @returns Array filtrado
  */
 function filtrarDatosLocal(data, value, campoBuscar) {
     if (!value)
@@ -414,32 +291,286 @@ function filtrarDatosLocal(data, value, campoBuscar) {
         });
     });
 }
+
 /**
- * Vincula un FormControl a datos locales para autocompletado.
+ * Intenta obtener el DestroyRef desde el llamador (objThis/control)
+ * o inyectándolo si estamos en un contexto de inyección.
  */
-function changeSelectData(objThis, { formControl, data, campoBuscar, variableResultado }) {
-    objThis.filtrados[variableResultado] = formControl.valueChanges.pipe(untilDestroyed(objThis)).pipe(startWith(''), map(value => data ? filtrarDatosLocal(data, value, campoBuscar) : []));
+function obtenerDestroyRef(caller, manualDRef, fnName = 'N/A') {
+    let dRef = manualDRef || caller?.['destroyRef'] || caller?.['_destroyRef'];
+    if (!dRef) {
+        try {
+            dRef = inject(DestroyRef, { optional: true });
+        }
+        catch (e) {
+            console.warn(`${fnName}: Falló inject(DestroyRef) (fuera del contexto de inyección). Pasa el destroyRef explícitamente o decláralo en el componente para habilitar la limpieza.`);
+        }
+    }
+    return dRef ?? undefined;
+}
+function mostrarValorEnBusqueda(campos, idxSel) {
+    const impDataMostrar = () => {
+        let vD;
+        if (campos.campoId == '*object*' || campos.campoId == '*objeto*') {
+            console.log(campos);
+            vD = campos.lista.find((x) => JSON.stringify(x).trim() == JSON.stringify(idxSel).trim());
+            console.log(vD);
+        }
+        else {
+            vD = campos.lista.find((x) => x[campos.campoId] == idxSel);
+        }
+        if (!vD && campos.opcExtra) {
+            console.log('eval ', campos.opcExtra);
+            if (campos.campoId == '*object*' || campos.campoId == '*objeto*') {
+                console.log(campos);
+                vD = campos.opcExtra.find((x) => JSON.stringify(x).trim() == JSON.stringify(idxSel).trim());
+                console.log(vD);
+            }
+            else {
+                vD = campos.opcExtra.find((x) => x[campos.campoId] == idxSel);
+            }
+        }
+        if (vD) {
+            let txtFinal = '';
+            if (Array.isArray(campos.campoValue)) {
+                campos.campoValue.forEach((vCampo, idx) => {
+                    txtFinal += (vD[vCampo] ?? '');
+                    if (idx < campos.campoValue.length - 1) {
+                        txtFinal += ' - ';
+                    }
+                });
+            }
+            else {
+                txtFinal = vD[campos.campoValue] ?? '';
+            }
+            return txtFinal.trim();
+        }
+        else {
+            console.log('ASSSSS ----- SSSS ');
+        }
+        return '';
+    };
+    if (esNumero(idxSel)) {
+        if (idxSel > 0 && campos.lista?.length > 0) {
+            return impDataMostrar();
+        }
+        else if (idxSel && typeof idxSel == 'object') {
+            return impDataMostrar();
+        }
+    }
+    else {
+        if (campos.lista?.length > 0) {
+            return impDataMostrar();
+        }
+    }
+    return '';
+}
+/**
+ * @deprecated Use JvsAutocompleteDirective en su lugar para un enfoque más declarativo y robusto.
+ */
+function changeSelectData(objThis, dataFiltro) {
+    const dRef = obtenerDestroyRef(objThis, dataFiltro.destroyRef, 'changeSelectData');
+    objThis['filtrados'][dataFiltro.variableResultado] = dataFiltro.formControl.valueChanges.pipe(dRef ? takeUntilDestroyed(dRef) : tap(() => { })).pipe(startWith(''), map(value => {
+        const varN = dataFiltro.data;
+        if (varN) {
+            if (value) {
+                return varN.map(x => x).filter(dat => {
+                    if (Array.isArray(dataFiltro.campoBuscar)) {
+                        let encontrado = false;
+                        for (const vCampo of dataFiltro.campoBuscar) {
+                            // console.log(vCampo, value, dat[vCampo]);
+                            if (isNaN(Number(value))) {
+                                // NO ES NUMERO
+                                if (value && dat[vCampo] && dat[vCampo].toLowerCase().includes(value?.toString().toLowerCase())) {
+                                    encontrado = true;
+                                    break;
+                                }
+                            }
+                            else {
+                                if (value && dat[vCampo] && dat[vCampo].toString().includes(value?.toString())) {
+                                    encontrado = true;
+                                    break;
+                                }
+                            }
+                        }
+                        return encontrado;
+                    }
+                    else {
+                        if (isNaN(Number(value))) {
+                            return dat[dataFiltro.campoBuscar].toLowerCase().includes(value?.toString().toLowerCase());
+                        }
+                        else {
+                            return dat[dataFiltro.campoBuscar].toString().includes(value?.toString());
+                        }
+                    }
+                });
+            }
+            return varN;
+        }
+        return false;
+    }));
 }
 /**
- * Vincula un FormControl a datos locales obtenidos de dataServidor o dataServidorSuscripcion.
+ * @deprecated Use JvsAutocompleteDirective en su lugar para un enfoque más declarativo y robusto.
  */
-function changeSelect(control, formControl, tipo, campoBuscar, campoFiltro = null) {
-    const filtro = campoFiltro ?? tipo;
-    control.filtrados[filtro] = formControl.valueChanges.pipe(untilDestroyed(control)).pipe(startWith(''), map(value => {
+function changeSelect(control, formControl, tipo, campoBuscar, campoFiltro = null, destroyRef) {
+    // console.log(formControl);
+    // const formGroup = formControl.parent.controls;
+    // console.warn( Object.keys(formGroup).find(name => formControl === formGroup[name]) || null );
+    if (!campoFiltro) {
+        campoFiltro = tipo;
+    }
+    const dRef = obtenerDestroyRef(control, destroyRef, 'changeSelect');
+    control['filtrados'][campoFiltro ?? '__'] = formControl.valueChanges.pipe(dRef ? takeUntilDestroyed(dRef) : tap(() => { })).pipe(startWith(''), map(value => {
+        // console.warn(value);
         const partes = tipo.split('.');
-        const varN = control.dataServidor?.[partes[0]]?.[partes[1]] ??
-            control.dataServidor?.[tipo] ??
-            control.dataServidorSuscripcion?.[tipo]?.getValue();
-        return varN ? filtrarDatosLocal(varN, value, campoBuscar) : [];
+        let varN;
+        if (control['dataServidor']) {
+            varN = (partes.length > 1) ? control['dataServidor'][partes[0]][partes[1]] : control['dataServidor'][tipo];
+        }
+        else if (control['dataServidorSuscripcion']) {
+            varN = control['dataServidorSuscripcion'][tipo].getValue();
+        }
+        if (varN) {
+            if (value) {
+                return varN.map((x) => x).filter((dat) => {
+                    if (Array.isArray(campoBuscar)) {
+                        let encontrado = false;
+                        for (const vCampo of campoBuscar) {
+                            // console.log(vCampo, value, dat[vCampo]);
+                            if (isNaN(Number(value))) {
+                                // NO ES NUMERO
+                                if (value && dat[vCampo] && dat[vCampo].toLowerCase().includes(value?.toString().toLowerCase())) {
+                                    encontrado = true;
+                                    break;
+                                }
+                            }
+                            else {
+                                if (value && dat[vCampo] && dat[vCampo].toString().includes(value?.toString())) {
+                                    encontrado = true;
+                                    break;
+                                }
+                            }
+                        }
+                        return encontrado;
+                    }
+                    else {
+                        if (isNaN(Number(value))) {
+                            return dat[campoBuscar].toLowerCase().includes(value?.toString().toLowerCase());
+                        }
+                        else {
+                            return dat[campoBuscar].toString().includes(value?.toString());
+                        }
+                    }
+                });
+            }
+            return varN;
+        }
+        return false;
     }));
 }
+/**
+ * @deprecated Use JvsAutocompleteDirective en su lugar para un enfoque más declarativo y robusto.
+ */
+function changeSelectDataApi(objThis, dataFiltro) {
+    if (!dataFiltro.variableResultado) {
+        dataFiltro.variableResultado = dataFiltro.tipoReq;
+    }
+    const idFiltrado = dataFiltro.variableResultado;
+    const dRef = obtenerDestroyRef(objThis, dataFiltro.destroyRef, 'changeSelectDataApi');
+    dataFiltro.formControl.valueChanges.pipe(dRef ? takeUntilDestroyed(dRef) : tap(() => { }), debounceTime(500), tap(() => {
+        objThis.filtrados[dataFiltro.variableResultado + 'tmp'] = isObservable(objThis.filtrados[idFiltrado]) ? [] : objThis.filtrados[idFiltrado] || [];
+        if (objThis.filtrados[idFiltrado] !== objThis.filtrados[idFiltrado + 'tmp']) {
+            objThis.filtrados[idFiltrado] = [];
+        }
+        objThis.isLoading = true;
+    }), switchMap(value => {
+        if (dataFiltro.campoId) {
+            const busquedaActual2 = objThis.filtrados[idFiltrado + 'tmp'].findIndex((item) => item[dataFiltro.campoId ?? '--'] === value);
+            if (busquedaActual2 >= 0) {
+                return of({ [dataFiltro.tipoReq]: objThis.filtrados[idFiltrado + 'tmp'] });
+            }
+        }
+        return !value || value.length < (dataFiltro.minLength ?? 3) ? [] : (dataFiltro.queryService.getDataMethod('GET', dataFiltro.tipoReq, {
+            ...(dataFiltro.dataExtra ?? {}),
+            ...(dataFiltro.dataExtraVariable ? Object.fromEntries(dataFiltro.dataExtraVariable.map((objData) => [objData.campo, objData.ctrlValue.value])) : {}),
+            txtBuscar: value,
+        }, dataFiltro.anonimo).pipe(finalize(() => objThis.isLoading = false)));
+    })).subscribe((data) => {
+        objThis.filtrados[idFiltrado] = data[dataFiltro.tipoReq] ?? [];
+    });
+}
+/**
+ * @deprecated Use JvsAutocompleteDirective en su lugar para un enfoque más declarativo y robusto.
+ */
+function changeSelectApi(control, queryService, formControl, tipo, dataExtra = {}, dataExtraVariable = null, minLength = 1, anonimo = false, destroyRef) {
+    const dRef = obtenerDestroyRef(control, destroyRef, 'changeSelectApi');
+    formControl.valueChanges.pipe(dRef ? takeUntilDestroyed(dRef) : tap(() => { }), debounceTime(500), tap((value) => {
+        control['filtrados'][tipo + 'tmp'] = isObservable(control['filtrados'][tipo]) ? [] : control['filtrados'][tipo];
+        if (control['filtrados'][tipo] != control['filtrados'][tipo + 'tmp']) {
+            control['filtrados'][tipo] = [];
+        }
+        control['isLoading'] = true;
+    }), switchMap(value => {
+        const formGroup = formControl.parent?.controls;
+        const nombreControl = Object.keys(formGroup).find(name => formControl === formGroup[name]) || null;
+        if (nombreControl && control['filtrados'][tipo + 'tmp'] && control['filtrados'][tipo + 'tmp'].length > 0) {
+            const busquedaActual = control['filtrados'][tipo + 'tmp'].findIndex((item) => item[nombreControl] == value);
+            if (busquedaActual >= 0) {
+                const vRet = {};
+                vRet[tipo] = control['filtrados'][tipo + 'tmp'];
+                control['isLoading'] = false;
+                return of(vRet);
+            }
+        }
+        if (!value || value.length < minLength) {
+            return [];
+        }
+        const dataExtraVariableData = {};
+        if (dataExtraVariable) {
+            // @ts-ignore
+            for (const objData of dataExtraVariable) {
+                dataExtraVariableData[objData.campo] = objData.ctrlValue.value;
+            }
+        }
+        return queryService.getDataMethod('GET', tipo, { ...dataExtra, ...dataExtraVariableData, ...{ txtBuscar: value } }, anonimo).pipe(finalize(() => {
+            control['isLoading'] = false;
+        }));
+    })).subscribe((data) => {
+        if (data[tipo] == undefined) {
+            control['filtrados'][tipo] = [];
+        }
+        else {
+            control['filtrados'][tipo] = data[tipo];
+        }
+    });
+}
+/**
+ * Comprueba si un valor es una Promesa
+ * @param valor - Valor a verificar
+ * @returns true si es una Promise
+ */
+function esPromise(valor) {
+    return !!valor && typeof valor.then === 'function';
+}
+/**
+ * Selecciona todo el texto de un input
+ * @param event - Evento del input
+ */
+function seleccionarTextoInput$1(event) {
+    event.target.select();
+}
 /**
  * Función genérica para vincular un FormControl con datos desde API o Promise.
  * Preparada para migrar a signals en el futuro.
  */
+/**
+ * @deprecated Use JvsAutocompleteDirective en su lugar para un enfoque más declarativo y robusto.
+ */
 function changeSelectReformateado(config) {
-    const { objThis, tipoReq, formControl, queryService, campoId, minLength = 3, dataExtra = {}, dataExtraVariable = [], anonimo = false, variableResultado = tipoReq, } = config;
-    formControl.valueChanges.pipe(debounceTime(500), tap(() => {
+    const { objThis, tipoReq, formControl, queryService, campoId, minLength = 3, dataExtra = {}, dataExtraVariable = [], anonimo = false, variableResultado = tipoReq, destroyRef } = config;
+    const dRef = obtenerDestroyRef(objThis, destroyRef, 'changeSelectReformateado');
+    formControl.valueChanges.pipe(dRef ? takeUntilDestroyed(dRef) : tap(() => { }), debounceTime(500), tap(() => {
         objThis.filtrados[variableResultado + 'tmp'] = isObservable(objThis.filtrados[variableResultado])
             ? []
             : objThis.filtrados[variableResultado] || [];
@@ -459,10 +590,11 @@ function changeSelectReformateado(config) {
             objThis.isLoading = false;
             return of({ [tipoReq]: [] });
         }
-        const extraVars = Object.fromEntries(dataExtraVariable.map(v => [v.campo, v.ctrlValue.value]));
+        const extraVars = Object.fromEntries(dataExtraVariable.map((v) => [v.campo, v.ctrlValue.value]));
         const query = queryService.getDataMethod('GET', tipoReq, { ...dataExtra, ...extraVars, txtBuscar: value }, anonimo);
         if (esPromise(query)) {
-            return query.then((data) => ({ [tipoReq]: data[tipoReq] ?? [] }))
+            return query
+                .then((data) => ({ [tipoReq]: data[tipoReq] ?? [] }))
                 .finally(() => { objThis.isLoading = false; });
         }
         return query.pipe(finalize(() => { objThis.isLoading = false; }));
@@ -470,54 +602,138 @@ function changeSelectReformateado(config) {
         objThis.filtrados[variableResultado] = data[tipoReq] ?? [];
     });
 }
+
+function seleccionarTextoInput(event) {
+    event.target.select();
+}
+
 /**
- * Alias para compatibilidad.
+ * Codifica un string a base64 (método legacy)
+ * @param val - String a codificar
+ * @returns String codificado en base64
+ * @deprecated Use encodeBase64String() en su lugar
  */
-function changeSelectDataApi(objThis, dataFiltro) {
-    return changeSelectReformateado({
-        objThis,
-        tipoReq: dataFiltro.tipoReq,
-        formControl: dataFiltro.formControl,
-        queryService: dataFiltro.queryService,
-        campoId: dataFiltro.campoId,
-        minLength: dataFiltro.minLength,
-        dataExtra: dataFiltro.dataExtra,
-        dataExtraVariable: dataFiltro.dataExtraVariable,
-        anonimo: dataFiltro.anonimo,
-        variableResultado: dataFiltro.variableResultado,
-    });
+function b64Encode(val) {
+    return Buffer.from(val, 'binary').toString('base64');
 }
 /**
- * Alias para compatibilidad.
+ * Decodifica un string desde base64 (método legacy)
+ * @param val - String en base64 a decodificar
+ * @returns String decodificado
+ * @deprecated Use decodeBase64String() en su lugar
  */
-function changeSelectApi(control, queryService, formControl, tipo, dataExtra = {}, dataExtraVariable = null, minLength = 1, anonimo = false) {
-    return changeSelectReformateado({
-        objThis: control,
-        tipoReq: tipo,
-        formControl,
-        queryService,
-        minLength,
-        dataExtra,
-        dataExtraVariable: dataExtraVariable ?? [],
-        anonimo,
-    });
+function b64Decode(val) {
+    return Buffer.from(val, 'base64').toString('binary');
 }
 /**
- * Comprueba si un valor es una Promesa.
+ * Codificar string a Base64 (UTF-8 seguro)
+ * @param str - String a codificar
+ * @returns String codificado en base64
+ *
+ * @example
+ * ```typescript
+ * const encoded = encodeBase64String('Hola Mundo ñ');
+ * // encoded: "SG9sYSBNdW5kbyDDsQ=="
+ * ```
  */
-function esPromise(valor) {
-    return !!valor && typeof valor.then === 'function';
+function encodeBase64String(str) {
+    const encoder = new TextEncoder();
+    const bytes = encoder.encode(str);
+    let binary = '';
+    bytes.forEach(b => binary += String.fromCharCode(b));
+    return btoa(binary);
 }
-
-function seleccionarTextoInput(event) {
-    event.target.select();
+/**
+ * Decodificar Base64 a string (UTF-8 seguro)
+ * @param b64 - String en base64 a decodificar
+ * @returns String decodificado
+ *
+ * @example
+ * ```typescript
+ * const decoded = decodeBase64String('SG9sYSBNdW5kbyDDsQ==');
+ * // decoded: "Hola Mundo ñ"
+ * ```
+ */
+function decodeBase64String(b64) {
+    const binary = atob(b64);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) {
+        bytes[i] = binary.charCodeAt(i);
+    }
+    const decoder = new TextDecoder();
+    return decoder.decode(bytes);
 }
-
-function b64Encode(val) {
-    return Buffer.from(val, 'binary').toString('base64');
+/**
+ * Codificar un objeto a base64 (UTF-8 seguro)
+ * @param obj - Objeto a codificar
+ * @returns String codificado en base64
+ *
+ * @example
+ * ```typescript
+ * const obj = { nombre: 'Juan', edad: 25 };
+ * const encoded = encodeBase64Object(obj);
+ * ```
+ */
+function encodeBase64Object(obj) {
+    return encodeBase64String(JSON.stringify(obj));
 }
-function b64Decode(val) {
-    return Buffer.from(val, 'base64').toString('binary');
+/**
+ * Decodificar un base64 y obtener el objeto original
+ * @param b64 - String en base64 a decodificar
+ * @returns Objeto decodificado
+ *
+ * @example
+ * ```typescript
+ * const obj = decodeBase64Object<{ nombre: string, edad: number }>(encoded);
+ * // obj: { nombre: 'Juan', edad: 25 }
+ * ```
+ */
+function decodeBase64Object(b64) {
+    return JSON.parse(decodeBase64String(b64));
+}
+/**
+ * Codificar archivo a Base64 (retorna solo el contenido, sin "data:...")
+ * @param file - Archivo o Blob a codificar
+ * @returns Promise con el string en base64
+ *
+ * @example
+ * ```typescript
+ * const file = event.target.files[0];
+ * const base64 = await encodeBase64File(file);
+ * // base64: "iVBORw0KGgoAAAANSUhEUgAA..."
+ * ```
+ */
+function encodeBase64File(file) {
+    return new Promise((resolve, reject) => {
+        const reader = new FileReader();
+        reader.onload = () => {
+            const result = reader.result;
+            resolve(result.split(',')[1]); // quita el prefijo "data:...;base64,"
+        };
+        reader.onerror = reject;
+        reader.readAsDataURL(file);
+    });
+}
+/**
+ * Decodificar Base64 a Blob (para reconstruir archivos en Angular)
+ * @param b64 - String en base64
+ * @param mimeType - Tipo MIME del archivo (opcional)
+ * @returns Blob con el contenido decodificado
+ *
+ * @example
+ * ```typescript
+ * const blob = decodeBase64ToBlob(base64String, 'image/png');
+ * const url = URL.createObjectURL(blob);
+ * // Usar url para mostrar imagen o descargar
+ * ```
+ */
+function decodeBase64ToBlob(b64, mimeType = 'application/octet-stream') {
+    const byteChars = atob(b64);
+    const byteNumbers = new Array(byteChars.length);
+    for (let i = 0; i < byteChars.length; i++) {
+        byteNumbers[i] = byteChars.charCodeAt(i);
+    }
+    return new Blob([new Uint8Array(byteNumbers)], { type: mimeType });
 }
 
 function getBrowserName() {
@@ -583,6 +799,147 @@ function formatearFechaCadena(fecha) {
     return new Date(year, month, day);
 }
 
+/**
+ * Configuración global para las utilidades de logging
+ */
+let isProductionMode = false;
+/**
+ * Configura el modo de producción para las utilidades de logging
+ * @param production - true si está en modo producción, false para desarrollo
+ *
+ * @example
+ * ```typescript
+ * import { setProductionMode } from '@jvsoft/utils';
+ * import { environment } from './environments/environment';
+ *
+ * setProductionMode(environment.production);
+ * ```
+ */
+function setProductionMode(production) {
+    isProductionMode = production;
+}
+/**
+ * Obtiene el estado actual del modo de producción
+ * @returns true si está en modo producción, false en desarrollo
+ */
+function isProduction() {
+    return isProductionMode;
+}
+/**
+ * Muestra mensajes de log solo en modo desarrollo
+ * @param args - Argumentos a mostrar en consola
+ *
+ * @example
+ * ```typescript
+ * devLog('Usuario cargado:', usuario);
+ * devLog('Estado:', { activo: true, rol: 'admin' });
+ * ```
+ */
+function devLog(...args) {
+    if (!isProductionMode) {
+        console.log(...args);
+    }
+}
+/**
+ * Muestra advertencias solo en modo desarrollo
+ * @param args - Argumentos a mostrar como advertencia
+ *
+ * @example
+ * ```typescript
+ * devWarn('Función deprecada, usar nuevaFuncion() en su lugar');
+ * ```
+ */
+function devWarn(...args) {
+    if (!isProductionMode) {
+        console.warn(...args);
+    }
+}
+/**
+ * Muestra errores en consola (siempre, incluso en producción)
+ * @param args - Argumentos a mostrar como error
+ *
+ * @example
+ * ```typescript
+ * devError('Error al cargar datos:', error);
+ * ```
+ */
+function devError(...args) {
+    console.error(...args);
+}
+/**
+ * Crea un grupo de logs solo en modo desarrollo
+ * @param label - Etiqueta del grupo
+ * @param collapsed - Si el grupo debe estar colapsado por defecto
+ *
+ * @example
+ * ```typescript
+ * devGroup('Datos del usuario');
+ * devLog('Nombre:', usuario.nombre);
+ * devLog('Email:', usuario.email);
+ * devGroupEnd();
+ * ```
+ */
+function devGroup(label, collapsed = false) {
+    if (!isProductionMode) {
+        if (collapsed) {
+            console.groupCollapsed(label);
+        }
+        else {
+            console.group(label);
+        }
+    }
+}
+/**
+ * Cierra el grupo de logs actual
+ */
+function devGroupEnd() {
+    if (!isProductionMode) {
+        console.groupEnd();
+    }
+}
+/**
+ * Muestra una tabla en consola solo en modo desarrollo
+ * @param data - Datos a mostrar en formato tabla
+ *
+ * @example
+ * ```typescript
+ * devTable([
+ *   { nombre: 'Juan', edad: 25 },
+ *   { nombre: 'María', edad: 30 }
+ * ]);
+ * ```
+ */
+function devTable(data) {
+    if (!isProductionMode) {
+        console.table(data);
+    }
+}
+/**
+ * Inicia un temporizador solo en modo desarrollo
+ * @param label - Etiqueta del temporizador
+ *
+ * @example
+ * ```typescript
+ * devTime('carga-datos');
+ * // ... código a medir
+ * devTimeEnd('carga-datos'); // Muestra: carga-datos: 123.45ms
+ * ```
+ */
+function devTime(label) {
+    if (!isProductionMode) {
+        console.time(label);
+    }
+}
+/**
+ * Finaliza un temporizador y muestra el tiempo transcurrido
+ * @param label - Etiqueta del temporizador
+ */
+function devTimeEnd(label) {
+    if (!isProductionMode) {
+        console.timeEnd(label);
+    }
+}
+
 function maskEmail(email) {
     const [user, domain] = email.split("@");
     if (user.length <= 2) {
@@ -1791,18 +2148,607 @@ function zeroFill(value, digitos, ...args) {
     return new ZeroFillPipe().transform(value, digitos, args);
 }
 
+class JvsDisplayWithPipe {
+    /**
+     * Retorna una función compatible con [displayWith] de MatAutocomplete.
+     * @param lista La lista de objetos donde buscar.
+     * @param campoId El nombre del campo que coincide con el valor del control (ej: 'iCarreraId').
+     * @param campoValue El nombre del campo (o campos) a mostrar (ej: 'cCarreraNombre' o ['cCodigo', 'cNombre']).
+     * @param opcExtra Lista opcional de objetos extra donde buscar si no se encuentra en la lista principal.
+     */
+    transform(lista, campoId, campoValue, opcExtra) {
+        return (idxSel) => {
+            if (idxSel === null || idxSel === undefined || !lista) {
+                return '';
+            }
+            const impDataMostrar = (vD) => {
+                if (!vD)
+                    return '';
+                if (Array.isArray(campoValue)) {
+                    return campoValue
+                        .map(field => vD[field] ?? '')
+                        .filter(val => !!val)
+                        .join(' - ');
+                }
+                return vD[campoValue]?.toString() || '';
+            };
+            // Buscar en la lista principal
+            let item;
+            if (campoId === '*object*' || campoId === '*objeto*') {
+                item = lista.find(x => JSON.stringify(x).trim() === JSON.stringify(idxSel).trim());
+            }
+            else {
+                item = lista.find(x => x[campoId] == idxSel);
+            }
+            // Si no se encuentra, buscar en opcExtra
+            if (!item && opcExtra) {
+                if (campoId === '*object*' || campoId === '*objeto*') {
+                    item = opcExtra.find(x => JSON.stringify(x).trim() === JSON.stringify(idxSel).trim());
+                }
+                else {
+                    item = opcExtra.find(x => x[campoId] == idxSel);
+                }
+            }
+            return item ? impDataMostrar(item).trim() : '';
+        };
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: JvsDisplayWithPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "19.2.14", ngImport: i0, type: JvsDisplayWithPipe, isStandalone: true, name: "jvsDisplayWith" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: JvsDisplayWithPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'jvsDisplayWith',
+                    standalone: true
+                }]
+        }] });
+
 // export * from './otros';
 
+class AutocompleteMatchValidatorDirective {
+    opciones = input([], { alias: 'jvsAutocompleteMatch' });
+    formControlName = input();
+    idLista = input();
+    validate(control) {
+        const idLista = this.idLista() ?? this.formControlName();
+        const value = control.value;
+        const opciones = this.opciones();
+        if (!value)
+            return null;
+        if (!opciones) {
+            console.error('Debe definir opciones para el validador jvsAutocompleteMatch');
+            return { itemSelected: true };
+        }
+        const encontrado = opciones.some(item => typeof value === 'object'
+            ? item[idLista] === value[idLista]
+            : item[idLista] === value);
+        return encontrado ? null : { itemSelected: true };
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: AutocompleteMatchValidatorDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "19.2.14", type: AutocompleteMatchValidatorDirective, isStandalone: true, selector: "[jvsAutocompleteMatch]", inputs: { opciones: { classPropertyName: "opciones", publicName: "jvsAutocompleteMatch", isSignal: true, isRequired: false, transformFunction: null }, formControlName: { classPropertyName: "formControlName", publicName: "formControlName", isSignal: true, isRequired: false, transformFunction: null }, idLista: { classPropertyName: "idLista", publicName: "idLista", isSignal: true, isRequired: false, transformFunction: null } }, providers: [
+            {
+                provide: NG_VALIDATORS,
+                useExisting: forwardRef(() => AutocompleteMatchValidatorDirective),
+                multi: true,
+            },
+        ], ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: AutocompleteMatchValidatorDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[jvsAutocompleteMatch]',
+                    providers: [
+                        {
+                            provide: NG_VALIDATORS,
+                            useExisting: forwardRef(() => AutocompleteMatchValidatorDirective),
+                            multi: true,
+                        },
+                    ],
+                    standalone: true
+                }]
+        }] });
+
+class JvsPopoverPanelComponent {
+    content = input(null);
+    templateContent = input(null);
+    context = input(null);
+    customClass = input('');
+    baseClasses = 'bg-white shadow-md rounded border-sm border-gray-700 p-1 mat-elevation-z4';
+    combinedClasses = computed(() => {
+        return `${this.baseClasses} ${this.customClass()}`.trim();
+    });
+    isTemplate() {
+        return !!this.templateContent();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: JvsPopoverPanelComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "19.2.14", type: JvsPopoverPanelComponent, isStandalone: true, selector: "jvs-popover-panel", inputs: { content: { classPropertyName: "content", publicName: "content", isSignal: true, isRequired: false, transformFunction: null }, templateContent: { classPropertyName: "templateContent", publicName: "templateContent", isSignal: true, isRequired: false, transformFunction: null }, context: { classPropertyName: "context", publicName: "context", isSignal: true, isRequired: false, transformFunction: null }, customClass: { classPropertyName: "customClass", publicName: "customClass", isSignal: true, isRequired: false, transformFunction: null } }, ngImport: i0, template: `
+        <div [class]="combinedClasses()">
+            <ng-container *ngIf="isTemplate(); else htmlContent">
+                <ng-container *ngTemplateOutlet="templateContent(); context: context()"></ng-container>
+            </ng-container>
+            <ng-template #htmlContent>
+                <div [innerHTML]="content()"></div>
+            </ng-template>
+        </div>
+    `, isInline: true, styles: [":host{display:block}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1$1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i1$1.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: JvsPopoverPanelComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'jvs-popover-panel', standalone: true, imports: [CommonModule], template: `
+        <div [class]="combinedClasses()">
+            <ng-container *ngIf="isTemplate(); else htmlContent">
+                <ng-container *ngTemplateOutlet="templateContent(); context: context()"></ng-container>
+            </ng-container>
+            <ng-template #htmlContent>
+                <div [innerHTML]="content()"></div>
+            </ng-template>
+        </div>
+    `, styles: [":host{display:block}\n"] }]
+        }] });
+
+class JvsPopoverService {
+    overlay = inject(Overlay);
+    overlayPositionBuilder = inject(OverlayPositionBuilder);
+    overlayRef = null;
+    open(element, content, options = {}) {
+        this.close();
+        const positionStrategy = this.overlayPositionBuilder
+            .flexibleConnectedTo(element)
+            .withPositions([
+            {
+                originX: 'center',
+                originY: options.position === 'top' ? 'top' : 'bottom',
+                overlayX: 'center',
+                overlayY: options.position === 'top' ? 'bottom' : 'top',
+                offsetY: options.position === 'top' ? -8 : 8
+            }
+        ]);
+        this.overlayRef = this.overlay.create({
+            positionStrategy,
+            scrollStrategy: this.overlay.scrollStrategies.reposition(),
+            hasBackdrop: false
+        });
+        const portal = new ComponentPortal(JvsPopoverPanelComponent, options.viewContainerRef);
+        const containerRef = this.overlayRef.attach(portal);
+        if (content instanceof TemplateRef) {
+            containerRef.setInput('templateContent', content);
+        }
+        else {
+            containerRef.setInput('content', content);
+        }
+        if (options.customClass) {
+            containerRef.setInput('customClass', options.customClass);
+        }
+        if (options.context) {
+            containerRef.setInput('context', options.context);
+        }
+        return this.overlayRef;
+    }
+    close() {
+        if (this.overlayRef) {
+            this.overlayRef.detach();
+            this.overlayRef.dispose();
+            this.overlayRef = null;
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: JvsPopoverService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: JvsPopoverService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: JvsPopoverService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+class JvsPopoverDirective {
+    popoverService = inject(JvsPopoverService);
+    elementRef = inject(ElementRef);
+    viewContainerRef = inject(ViewContainerRef);
+    content = input(null, { alias: 'jvsPopover' });
+    context = input(null);
+    trigger = input('hover');
+    position = input('bottom');
+    customClass = input('');
+    onMouseEnter() {
+        if (this.trigger() === 'hover') {
+            this.show();
+        }
+    }
+    onMouseLeave() {
+        if (this.trigger() === 'hover') {
+            this.hide();
+        }
+    }
+    onClick() {
+        if (this.trigger() === 'click') {
+            this.show();
+        }
+    }
+    onFocus() {
+        if (this.trigger() === 'focus') {
+            this.show();
+        }
+    }
+    onBlur() {
+        if (this.trigger() === 'focus') {
+            this.hide();
+        }
+    }
+    ngOnDestroy() {
+        this.hide();
+    }
+    show() {
+        const content = this.content();
+        if (!content)
+            return;
+        this.popoverService.open(this.elementRef.nativeElement, content, {
+            position: this.position(),
+            customClass: this.customClass(),
+            viewContainerRef: this.viewContainerRef,
+            context: this.context()
+        });
+    }
+    hide() {
+        this.popoverService.close();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: JvsPopoverDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "19.2.14", type: JvsPopoverDirective, isStandalone: true, selector: "[jvsPopover]", inputs: { content: { classPropertyName: "content", publicName: "jvsPopover", isSignal: true, isRequired: false, transformFunction: null }, context: { classPropertyName: "context", publicName: "context", isSignal: true, isRequired: false, transformFunction: null }, trigger: { classPropertyName: "trigger", publicName: "trigger", isSignal: true, isRequired: false, transformFunction: null }, position: { classPropertyName: "position", publicName: "position", isSignal: true, isRequired: false, transformFunction: null }, customClass: { classPropertyName: "customClass", publicName: "customClass", isSignal: true, isRequired: false, transformFunction: null } }, host: { listeners: { "mouseenter": "onMouseEnter()", "mouseleave": "onMouseLeave()", "click": "onClick()", "focusin": "onFocus()", "focusout": "onBlur()" } }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: JvsPopoverDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[jvsPopover]',
+                    standalone: true
+                }]
+        }], propDecorators: { onMouseEnter: [{
+                type: HostListener,
+                args: ['mouseenter']
+            }], onMouseLeave: [{
+                type: HostListener,
+                args: ['mouseleave']
+            }], onClick: [{
+                type: HostListener,
+                args: ['click']
+            }], onFocus: [{
+                type: HostListener,
+                args: ['focusin']
+            }], onBlur: [{
+                type: HostListener,
+                args: ['focusout']
+            }] } });
+
+class JvsPopoverListenerDirective {
+    popoverService = inject(JvsPopoverService);
+    elementRef = inject(ElementRef);
+    trigger = input('hover');
+    onMouseOver(event) {
+        if (this.trigger() !== 'hover')
+            return;
+        const target = this.findPopoverTarget(event.target);
+        if (target) {
+            const content = target.getAttribute('data-jvs-popover');
+            if (content) {
+                this.popoverService.open(target, content, {
+                    position: target.getAttribute('data-jvs-position') || 'bottom',
+                    customClass: target.getAttribute('data-jvs-class') || ''
+                });
+            }
+        }
+    }
+    onMouseOut(event) {
+        if (this.trigger() !== 'hover')
+            return;
+        this.popoverService.close();
+    }
+    onClick(event) {
+        if (this.trigger() !== 'click')
+            return;
+        const target = this.findPopoverTarget(event.target);
+        if (target) {
+            const content = target.getAttribute('data-jvs-popover');
+            if (content) {
+                this.popoverService.open(target, content, {
+                    position: target.getAttribute('data-jvs-position') || 'bottom',
+                    customClass: target.getAttribute('data-jvs-class') || ''
+                });
+            }
+        }
+    }
+    findPopoverTarget(el) {
+        while (el && el !== this.elementRef.nativeElement) {
+            if (el.hasAttribute('data-jvs-popover')) {
+                return el;
+            }
+            el = el.parentElement;
+        }
+        return null;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: JvsPopoverListenerDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "19.2.14", type: JvsPopoverListenerDirective, isStandalone: true, selector: "[jvsPopoverListener]", inputs: { trigger: { classPropertyName: "trigger", publicName: "trigger", isSignal: true, isRequired: false, transformFunction: null } }, host: { listeners: { "mouseover": "onMouseOver($event)", "mouseout": "onMouseOut($event)", "click": "onClick($event)" } }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: JvsPopoverListenerDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[jvsPopoverListener]',
+                    standalone: true
+                }]
+        }], propDecorators: { onMouseOver: [{
+                type: HostListener,
+                args: ['mouseover', ['$event']]
+            }], onMouseOut: [{
+                type: HostListener,
+                args: ['mouseout', ['$event']]
+            }], onClick: [{
+                type: HostListener,
+                args: ['click', ['$event']]
+            }] } });
+
+class JvsAutocompleteDirective {
+    destroyRef = inject(DestroyRef);
+    ngControl = inject(NgControl, { optional: true });
+    focus$ = new Subject();
+    // Signal-based Inputs
+    data = input(null);
+    fields = input('');
+    typeReq = input('');
+    queryService = input(null);
+    minLength = input(3);
+    dataExtra = input({});
+    anonimo = input(false);
+    debounce = input(300);
+    // Modern Outputs
+    filtered = output();
+    loading = output();
+    onFocus() {
+        this.focus$.next();
+    }
+    ngOnInit() {
+        const control = this.ngControl;
+        if (!control || !control.valueChanges) {
+            console.warn('JvsAutocompleteDirective: No se encontró ngControl o valueChanges. Asegúrate de que el input tenga un formControl o formControlName.');
+            return;
+        }
+        // Si es data local, bajamos el debounce por defecto a 0 si no se ha especificado
+        const isLocal = this.data() && !this.typeReq();
+        const actualDebounce = (isLocal && this.debounce() === 300) ? 0 : this.debounce();
+        merge(control.valueChanges.pipe(debounceTime(actualDebounce)), this.focus$).pipe(takeUntilDestroyed(this.destroyRef), startWith(control.value), distinctUntilChanged(), tap(() => {
+            if (this.typeReq())
+                this.loading.emit(true);
+        }), switchMap(() => {
+            const value = control.value;
+            // Si el valor es un objeto (proviene de seleccionar una opción), no volvemos a filtrar
+            if (typeof value === 'object' && value !== null) {
+                if (this.typeReq())
+                    this.loading.emit(false);
+                return of(null);
+            }
+            if (this.typeReq() && this.queryService()) {
+                return this.fetchApi(value?.toString() || '');
+            }
+            else if (this.data()) {
+                const res = this.filterLocal(value?.toString() || '');
+                return of(res);
+            }
+            if (this.typeReq())
+                this.loading.emit(false);
+            return of([]);
+        })).subscribe((result) => {
+            if (result !== null) {
+                this.filtered.emit(result);
+            }
+        });
+    }
+    filterLocal(value) {
+        const data = this.data();
+        if (!value)
+            return data || [];
+        const search = value.toLowerCase();
+        const rawFields = this.fields();
+        const fields = Array.isArray(rawFields) ? rawFields : [rawFields];
+        return (data || []).filter(item => {
+            return fields.some(field => {
+                const val = item[field];
+                return val && val.toString().toLowerCase().includes(search);
+            });
+        });
+    }
+    fetchApi(value) {
+        const typeReq = this.typeReq();
+        const queryService = this.queryService();
+        if (!value || value.length < this.minLength()) {
+            this.loading.emit(false);
+            return of([]);
+        }
+        return queryService.getDataMethod('GET', typeReq, {
+            ...this.dataExtra(),
+            txtBuscar: value
+        }, this.anonimo()).pipe(map$1((res) => res[typeReq] ?? []), finalize(() => this.loading.emit(false)));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: JvsAutocompleteDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "19.2.14", type: JvsAutocompleteDirective, isStandalone: true, selector: "[jvsAutocomplete]", inputs: { data: { classPropertyName: "data", publicName: "data", isSignal: true, isRequired: false, transformFunction: null }, fields: { classPropertyName: "fields", publicName: "fields", isSignal: true, isRequired: false, transformFunction: null }, typeReq: { classPropertyName: "typeReq", publicName: "typeReq", isSignal: true, isRequired: false, transformFunction: null }, queryService: { classPropertyName: "queryService", publicName: "queryService", isSignal: true, isRequired: false, transformFunction: null }, minLength: { classPropertyName: "minLength", publicName: "minLength", isSignal: true, isRequired: false, transformFunction: null }, dataExtra: { classPropertyName: "dataExtra", publicName: "dataExtra", isSignal: true, isRequired: false, transformFunction: null }, anonimo: { classPropertyName: "anonimo", publicName: "anonimo", isSignal: true, isRequired: false, transformFunction: null }, debounce: { classPropertyName: "debounce", publicName: "debounce", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { filtered: "filtered", loading: "loading" }, host: { listeners: { "focus": "onFocus()" } }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: JvsAutocompleteDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[jvsAutocomplete]',
+                    standalone: true
+                }]
+        }], propDecorators: { onFocus: [{
+                type: HostListener,
+                args: ['focus']
+            }] } });
+
+class AutoSelectFirstDirective {
+    ngControl = inject(NgControl, { optional: true });
+    fcName = inject(FormControlName, { optional: true });
+    toastr = inject(ToastrService, { optional: true });
+    // Inputs using Signals
+    options = input(null, { alias: 'jvsAutoSelectFirst' });
+    jvsIdKey = input(null);
+    jvsEmptyMsg = input('Lista sin elementos');
+    onAutoSelect = output();
+    constructor() {
+        effect(() => {
+            const currentOptions = this.options();
+            const idKey = this.jvsIdKey();
+            const emptyMsg = this.jvsEmptyMsg();
+            if (currentOptions === null)
+                return;
+            const optionsArray = Array.isArray(currentOptions) ? currentOptions : [];
+            if (optionsArray.length > 0) {
+                untracked(() => {
+                    const control = this.ngControl?.control;
+                    const currentValue = control?.value;
+                    // Only autoselect if empty
+                    if (control && (currentValue === null || currentValue === undefined || currentValue === '')) {
+                        const firstItem = optionsArray[0];
+                        let valueToSet;
+                        // Resolve key
+                        let effectiveKey = idKey;
+                        // Default to formControlName if not provided
+                        if (!effectiveKey && this.fcName) {
+                            effectiveKey = this.fcName.name;
+                        }
+                        if (effectiveKey) {
+                            if (Array.isArray(effectiveKey)) {
+                                // Composite key: build an object with the specified keys
+                                valueToSet = {};
+                                effectiveKey.forEach(key => {
+                                    valueToSet[key] = firstItem[key];
+                                });
+                            }
+                            else {
+                                valueToSet = firstItem[effectiveKey];
+                            }
+                        }
+                        else {
+                            // Use whole item if no key resolution possible
+                            valueToSet = firstItem;
+                        }
+                        control.setValue(valueToSet);
+                        this.onAutoSelect.emit(firstItem);
+                    }
+                });
+            }
+            else if (emptyMsg && this.toastr) {
+                this.toastr.warning(emptyMsg, 'Filtrado');
+            }
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: AutoSelectFirstDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "19.2.14", type: AutoSelectFirstDirective, isStandalone: true, selector: "[jvsAutoSelectFirst]", inputs: { options: { classPropertyName: "options", publicName: "jvsAutoSelectFirst", isSignal: true, isRequired: false, transformFunction: null }, jvsIdKey: { classPropertyName: "jvsIdKey", publicName: "jvsIdKey", isSignal: true, isRequired: false, transformFunction: null }, jvsEmptyMsg: { classPropertyName: "jvsEmptyMsg", publicName: "jvsEmptyMsg", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { onAutoSelect: "onAutoSelect" }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: AutoSelectFirstDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[jvsAutoSelectFirst]',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [] });
+
+class RelojService {
+    // El offset es la diferencia: ServerTime - LocalTime (performance.now())
+    offset = signal(0);
+    STORAGE_KEY = 'srv_clock_offset';
+    // Signal que cambia cada segundo para forzar la reactividad del reloj
+    ticker = signal(0);
+    // Hora actual calculada basándose en performance.now() para evitar drift y suspensión
+    timestamp = computed(() => {
+        this.ticker(); // Dependencia reactiva para que el computed se ejecute cada segundo
+        // performance.now() es monotónico, Date.now() es manipulable por el usuario
+        // Usamos Date.now() inicialmente pero ajustado por el offset calculado
+        return Date.now() + this.offset();
+    });
+    date = computed(() => new Date(this.timestamp()));
+    dateTime = computed(() => {
+        return format(this.date(), "yyyy-MM-dd'T'HH:mm");
+    });
+    constructor() {
+        this.cargarOffsetInicial();
+        this.escucharCambiosOtrasPestanas();
+        this.iniciarVigilanteWarp();
+        // Iniciar el ticker que mantiene el reloj vivo
+        setInterval(() => {
+            this.ticker.update(n => n + 1);
+        }, 1000);
+    }
+    /**
+     * Sincroniza el reloj interno con una hora oficial del servidor.
+     * Calculamos el offset respecto al tiempo local actual.
+     */
+    sincronizar(serverTime) {
+        const srvTime = new Date(serverTime).getTime();
+        const lclTime = Date.now();
+        const nuevoOffset = srvTime - lclTime;
+        this.offset.set(nuevoOffset);
+        localStorage.setItem(this.STORAGE_KEY, nuevoOffset.toString());
+        this.estaSincronizado.set(true);
+    }
+    /**
+     * Fuerza que la próxima petición HTTP pida la hora al servidor.
+     * Útil tras reconexiones de socket o detecciones de warp.
+     */
+    forzarSincronizacion() {
+        this.estaSincronizado.set(false);
+    }
+    estaSincronizado = signal(false);
+    get sincronizado() { return this.estaSincronizado(); }
+    cargarOffsetInicial() {
+        const guardado = localStorage.getItem(this.STORAGE_KEY);
+        if (guardado) {
+            this.offset.set(parseInt(guardado, 10));
+        }
+    }
+    escucharCambiosOtrasPestanas() {
+        window.addEventListener('storage', (event) => {
+            if (event.key === this.STORAGE_KEY && event.newValue) {
+                this.offset.set(parseInt(event.newValue, 10));
+            }
+        });
+    }
+    /**
+     * Monitoriza saltos bruscos en el tiempo (suspensión o cambio manual de hora).
+     * Si detectamos un "warp", podríamos pedir una sincronización forzada.
+     */
+    iniciarVigilanteWarp() {
+        let lastPerformance = performance.now();
+        let lastDate = Date.now();
+        setInterval(() => {
+            const currentPerformance = performance.now();
+            const currentDate = Date.now();
+            const perfDelta = currentPerformance - lastPerformance;
+            const dateDelta = currentDate - lastDate;
+            // Si la diferencia entre deltas es mayor a 2s (ajustable), hubo un warp
+            if (Math.abs(perfDelta - dateDelta) > 2000) {
+                console.warn('[RelojService] Salto temporal detectado (Warp). Se recomienda sincronizar.');
+                this.forzarSincronizacion();
+            }
+            lastPerformance = currentPerformance;
+            lastDate = currentDate;
+        }, 5000);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: RelojService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: RelojService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: RelojService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [] });
+
+/*
+ * Public API Surface of utils services
+ */
+
 /*
  * Public API Surface of utils
  */
-// export * from './functions/common.function';
-// export * from './lib/utils.component';
-// export * from './lib/utils.service';
 
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { DataEnListaPipe, DataModel, DateDiffStringPipe, FiltroPipe, FormControlIsRequiredPipe, JsonParsePipe, NoSanitizePipe, TipoValorFuncionPipe, ZeroFillPipe, b64Decode, b64Encode, buscarPorCampo, changeSelect, changeSelectApi, changeSelectData, changeSelectDataApi, changeSelectReformateado, convertirBytes, dataEnLista, dateDiffString, deepClone, deepMerge, delLocalStorage, desencriptar, downLoadFileStream, eliminarColumnaPorIndex, eliminarDuplicados, eliminarElementos, encriptar, esNumero, establecerQuitarRequired, extraerDominio, formControlIsRequired, formatearFecha, formatearFechaCadena, formatearFechaFormato, generateRandomString, getBrowserName, getCambiarPwd, getDataArchivoFromPath, getFormValidationErrors, getLocalStorage, getUniqueValues, getUniqueValuesByProperty, groupBy, inicializarVariablesSessionStorage, isEmail, jwtToken, jwtTokenData, jwtTokenExpiracion, jwtTokenExpiracionFaltante, localStorageKeys, markAsTouchedWithoutEmitEvent, maskEmail, mensajeAlerta, mensajeConfirmacion, mensajeTimer, mensajeToast, mensajesDeError, mensajesErrorFormControl, mostrarValorEnBusqueda, nestGroupsBy, numberToWords, objectPropertiesBoolean, objectPropertiesToType, obtenerHostDesdeUrl, obtenerMimeType, obtenerUltimoOrden, ordenarArray, ordenarPorPropiedad, ordenarPorPropiedades, roundToDecimal, sanitizarNombreArchivo, seleccionarTextoInput, setCambiarPwd, setControlDesdeLista, setJwtTokenData, setLocalStorage, sumarObjetos, sumarPropiedades, tipoValorFuncion, toFormData, transformarFechasPorNombreDeCampo, verificarRUC, zeroFill };
+export { AutoSelectFirstDirective, AutocompleteMatchValidatorDirective, DataEnListaPipe, DataModel, DateDiffStringPipe, FiltroPipe, FormControlIsRequiredPipe, JsonParsePipe, JvsAutocompleteDirective, JvsDisplayWithPipe, JvsPopoverDirective, JvsPopoverListenerDirective, JvsPopoverPanelComponent, JvsPopoverService, NoSanitizePipe, RelojService, TipoValorFuncionPipe, ZeroFillPipe, b64Decode, b64Encode, buscarPorCampo, changeSelect, changeSelectApi, changeSelectData, changeSelectDataApi, changeSelectReformateado, convertirBytes, dataEnLista, dateDiffString, decodeBase64Object, decodeBase64String, decodeBase64ToBlob, deepClone, deepMerge, delLocalStorage, desencriptar, devError, devGroup, devGroupEnd, devLog, devTable, devTime, devTimeEnd, devWarn, downLoadFileStream, eliminarColumnaPorIndex, eliminarDuplicados, eliminarElementos, encodeBase64File, encodeBase64Object, encodeBase64String, encriptar, esNumero, esPromise, establecerQuitarRequired, extraerDominio, filtrarDatosLocal, formControlIsRequired, formatearFecha, formatearFechaCadena, formatearFechaFormato, generateRandomString, getBrowserName, getCambiarPwd, getDataArchivoFromPath, getFormValidationErrors, getLocalStorage, getUniqueValues, getUniqueValuesByProperty, getValueByPath, groupBy, inicializarVariablesSessionStorage, isEmail, isProduction, jwtToken, jwtTokenData, jwtTokenExpiracion, jwtTokenExpiracionFaltante, localStorageKeys, markAsTouchedWithoutEmitEvent, maskEmail, mensajeAlerta, mensajeConfirmacion, mensajeTimer, mensajeToast, mensajesDeError, mensajesErrorFormControl, mostrarValorEnBusqueda, nestGroupsBy, numberToWords, objectPropertiesBoolean, objectPropertiesToType, obtenerHostDesdeUrl, obtenerMimeType, obtenerUltimoOrden, ordenarArray, ordenarPorPropiedad, ordenarPorPropiedades, roundToDecimal, sanitizarNombreArchivo, seleccionarTextoInput, setCambiarPwd, setControlDesdeLista, setJwtTokenData, setLocalStorage, setProductionMode, sumarObjetos, sumarPropiedades, tipoValorFuncion, toFormData, transformarFechasPorNombreDeCampo, verificarRUC, zeroFill };
 //# sourceMappingURL=jvsoft-utils.mjs.map