@jvsoft/utils 1.0.0-alpha.7 → 1.0.0-alpha.9

package/fesm2022/jvsoft-utils-functions.mjs

@@ -0,0 +1,1744 @@
+import { inject, DestroyRef } from '@angular/core';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import { tap, startWith, debounceTime, isObservable, switchMap, of, finalize } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { Buffer } from 'buffer';
+import CryptoJS from 'crypto-js';
+import { formatDate } from '@angular/common';
+import { saveAs } from 'file-saver';
+import { Validators, FormGroup, FormControl, FormArray } from '@angular/forms';
+import { ReactiveFormConfig } from '@rxweb/reactive-form-validators';
+import moment from 'moment';
+import swal from 'sweetalert2';
+import { jwtDecode } from 'jwt-decode';
+
+function deepMerge(source, target) {
+    // Crea un clon profundo sin usar JSON.parse(JSON.stringify)
+    let cloneSource = deepClone(source);
+    if (typeof target !== 'object' || target === null) {
+        return target;
+    }
+    if (typeof cloneSource !== 'object' || cloneSource === null) {
+        cloneSource = Array.isArray(target) ? [] : {};
+    }
+    for (const key of Object.keys(target)) {
+        const targetValue = target[key];
+        const sourceValue = cloneSource[key];
+        if (typeof targetValue === 'object' && targetValue !== null && !Array.isArray(targetValue)) {
+            cloneSource[key] = deepMerge(sourceValue, targetValue);
+        }
+        else {
+            cloneSource[key] = targetValue;
+        }
+    }
+    return cloneSource; // Retorna el clon y no modifica el original
+}
+// 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
+    }
+    // Manejar instancias de Date
+    if (obj instanceof Date) {
+        return new Date(obj.getTime());
+    }
+    // Manejar funciones devolviendo una copia directa
+    if (typeof obj === 'function') {
+        return obj.bind({}); // Devuelve una copia de la función enlazada a un contexto vacío
+    }
+    // Crear un nuevo objeto o array
+    const clonedObj = Array.isArray(obj) ? [] : {};
+    // Clonar recursivamente las propiedades del objeto
+    for (const key in obj) {
+        if (Object.prototype.hasOwnProperty.call(obj, key)) {
+            clonedObj[key] = deepClone(obj[key]);
+        }
+    }
+    return clonedObj;
+}
+/**
+ * Busca un elemento en un array o jerarquía de objetos según un campo y valor especificado.
+ *
+ * @returns El elemento encontrado o undefined si no existe.
+ */
+function buscarPorCampo(datosFn) {
+    for (const item of datosFn.items) {
+        // Verifica si el campo coincide con el valor
+        if (item[datosFn.campo] === datosFn.valor) {
+            return item;
+        }
+        // Verifica si hay un campo hijo y si es un array
+        if (datosFn.campoHijo && item[datosFn.campoHijo] && Array.isArray(item[datosFn.campoHijo])) {
+            // Realiza la búsqueda recursiva en el campo hijo
+            const encontrado = buscarPorCampo({
+                items: item[datosFn.campoHijo], // Asegura el tipo correcto
+                campo: datosFn.campo,
+                valor: datosFn.valor,
+                campoHijo: datosFn.campoHijo,
+            });
+            // Si se encuentra el valor en el campo hijo, retorna el resultado
+            if (encontrado) {
+                return encontrado;
+            }
+        }
+    }
+    // Si no se encuentra nada, retorna undefined
+    return undefined;
+}
+function sumarPropiedades(item, campos) {
+    const datosSumar = campos.map(campo => (item[campo] * 1));
+    return datosSumar.reduce((a, b) => a + b, 0);
+}
+function esNumero(value) {
+    return !isNaN(Number(value));
+}
+function sumarObjetos(arrayObjetos, campos) {
+    return arrayObjetos.reduce((accumulator, item) => {
+        campos.forEach(campo => {
+            const valor = Number(item[campo]);
+            if (!isNaN(valor)) {
+                accumulator[campo] = (accumulator[campo] ?? 0) + valor;
+            }
+        });
+        return accumulator;
+    }, {});
+}
+function getUniqueValues(array) {
+    return array.filter((currentValue, index, arr) => (arr.indexOf(currentValue) === index));
+}
+function getUniqueValuesByProperty(objetos, campo) {
+    const objetosUnicos = {};
+    objetos.forEach(objeto => {
+        // Verificar si el objeto tiene el campo especificado
+        // @ts-ignore
+        if (objeto.hasOwnProperty(campo)) {
+            // @ts-ignore
+            const valorCampo = objeto[campo];
+            // Utilizar el valor del campo como clave en un objeto para asegurar que no haya duplicados
+            objetosUnicos[valorCampo] = objeto;
+        }
+    });
+    // Convertir el objeto de claves únicas de vuelta a una lista de objetos
+    return Object.values(objetosUnicos);
+}
+function ordenarArray(array, numeros = false, sentido = 'ASC') {
+    if (numeros) {
+        if (sentido != 'ASC') {
+            return array.sort((a, b) => b - a);
+        }
+        return array.sort((a, b) => a - b);
+    }
+    return array.sort((a, b) => (a > b) ? 1 : ((b > a) ? -1 : 0));
+}
+function ordenarPorPropiedad(objData, propiedad, /**@deprecated*/ numeros = false) {
+    return ordenarPorPropiedades(objData, { propiedades: [propiedad], direcciones: ['asc'] });
+}
+function ordenarPorPropiedades(arr, options) {
+    const { propiedades, direcciones = [] } = options;
+    const orden = direcciones.map(d => d === 'desc' ? -1 : 1);
+    return [...arr].sort((a, b) => {
+        return propiedades.reduce((acc, propiedad, index) => {
+            if (acc !== 0)
+                return acc; // Si ya hay diferencia, no seguir comparando
+            const aValue = a[propiedad];
+            const bValue = b[propiedad];
+            if (typeof aValue === 'string' && typeof bValue === 'string') {
+                return aValue.localeCompare(bValue) * orden[index]; // 🔹 Comparación alfabética
+            }
+            if (typeof aValue === 'number' && typeof bValue === 'number') {
+                return (aValue - bValue) * orden[index]; // 🔹 Comparación numérica
+            }
+            return 0; // En caso de valores no comparables
+        }, 0);
+    });
+}
+function groupBy(array, key) {
+    const keyFn = key instanceof Function ? key : (obj) => obj[key];
+    return array.reduce((objectsByKeyValue, obj) => {
+        const value = keyFn(obj);
+        objectsByKeyValue[value] = (objectsByKeyValue[value] || []).concat(obj);
+        return objectsByKeyValue;
+    }, {});
+}
+function nestGroupsBy(arr, properties) {
+    const fnGroupBy = (conversions, property2) => {
+        return conversions.reduce((acc, obj) => {
+            const key = obj[property2];
+            if (!acc[key]) {
+                acc[key] = [];
+            }
+            acc[key].push(obj);
+            return acc;
+        }, {});
+    };
+    properties = Array.from(properties);
+    if (properties.length === 1) {
+        return fnGroupBy(arr, properties[0]);
+    }
+    const property = properties.shift();
+    const grouped = fnGroupBy(arr, property);
+    Object.keys(grouped).forEach(key => {
+        grouped[key] = nestGroupsBy(grouped[key], Array.from(properties));
+    });
+    return grouped;
+}
+/**
+ * Obtiene un valor de un objeto usando una ruta de propiedad anidada.
+ *
+ * @param obj - Objeto de entrada.
+ * @param path - Ruta en formato punto (ej: "cliente.orden").
+ * @returns El valor encontrado o undefined si no existe.
+ */
+function getValueByPath(obj, path) {
+    return path.split('.').reduce((acc, key) => acc?.[key], obj);
+}
+/**
+ * Retorna el valor máximo del campo especificado (incluso anidado) en un arreglo de objetos.
+ *
+ * @param data - Lista de objetos a procesar.
+ * @param campo - Nombre del campo a evaluar, puede ser anidado (ej. "campo.orden").
+ * @param incrementar - Si es true, retorna el valor máximo + 1. Por defecto es true.
+ * @returns El valor máximo encontrado, posiblemente incrementado.
+ */
+function obtenerUltimoOrden(data, campo, incrementar = true) {
+    const max = data.reduce((mayor, item) => {
+        const valor = Number(getValueByPath(item, campo)) || 0;
+        return valor > mayor ? valor : mayor;
+    }, 0);
+    return incrementar ? max + 1 : max;
+}
+/**
+ * Elimina una o varias columnas específicas (por índice) de una tabla representada como array de arrays.
+ *
+ * @param data - Array de filas (cada fila debe ser un array).
+ * @param columnIndex - Índice o lista de índices de las columnas a eliminar.
+ * @returns Nuevo array con las columnas eliminadas.
+ */
+function eliminarColumnaPorIndex(data, columnIndex) {
+    if (!Array.isArray(data))
+        return [];
+    // Normalizar a array único y ordenado (descendente para evitar reindexación al splicing)
+    const indices = Array.isArray(columnIndex)
+        ? [...new Set(columnIndex)].filter((i) => (typeof i === 'number' && i >= 0)).sort((a, b) => b - a)
+        : [columnIndex];
+    return data.map((row) => {
+        if (!Array.isArray(row))
+            return row;
+        const newRow = [...row];
+        for (const index of indices) {
+            if (index >= 0 && index < newRow.length) {
+                newRow.splice(index, 1);
+            }
+        }
+        return newRow;
+    });
+}
+function eliminarDuplicados(array, claves) {
+    const unicos = new Map();
+    for (const item of array) {
+        const claveUnica = claves && claves.length > 0
+            ? claves.map(k => item[k]).join('|')
+            : JSON.stringify(item);
+        if (!unicos.has(claveUnica)) {
+            unicos.set(claveUnica, item);
+        }
+    }
+    return Array.from(unicos.values());
+}
+function eliminarElementos(origen, elementosAEliminar, claves) {
+    const clavesSet = new Set();
+    for (const item of elementosAEliminar) {
+        const key = claves && claves.length > 0
+            ? claves.map(k => item[k]).join('|')
+            : JSON.stringify(item);
+        clavesSet.add(key);
+    }
+    return origen.filter(item => {
+        const key = claves && claves.length > 0
+            ? claves.map(k => item[k]).join('|')
+            : JSON.stringify(item);
+        return !clavesSet.has(key);
+    });
+}
+/**
+ * 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)
+        return data;
+    const normalizar = (val) => val?.toString()?.toLowerCase() ?? '';
+    const esNum = !isNaN(Number(value));
+    return data.filter(item => {
+        const campos = Array.isArray(campoBuscar) ? campoBuscar : [campoBuscar];
+        return campos.some(campo => {
+            const campoVal = item[campo];
+            if (campoVal == null)
+                return false;
+            return esNum
+                ? campoVal.toString().includes(value.toString())
+                : normalizar(campoVal).includes(normalizar(value));
+        });
+    });
+}
+
+/**
+ * Intenta obtener el DestroyRef desde el llamador (objThis/control)
+ * o inyectándolo si estamos en un contexto de inyección.
+ */
+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;
+    }));
+}
+/**
+ * @deprecated Use JvsAutocompleteDirective en su lugar para un enfoque más declarativo y robusto.
+ */
+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('.');
+        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, 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] || [];
+        if (objThis.filtrados[variableResultado] !== objThis.filtrados[variableResultado + 'tmp']) {
+            objThis.filtrados[variableResultado] = [];
+        }
+        objThis.isLoading = true;
+    }), switchMap(value => {
+        if (campoId) {
+            const existe = objThis.filtrados[variableResultado + 'tmp']
+                .findIndex((item) => item[campoId] === value);
+            if (existe >= 0) {
+                return of({ [tipoReq]: objThis.filtrados[variableResultado + 'tmp'] });
+            }
+        }
+        if (!value || value.length < minLength) {
+            objThis.isLoading = false;
+            return of({ [tipoReq]: [] });
+        }
+        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] ?? [] }))
+                .finally(() => { objThis.isLoading = false; });
+        }
+        return query.pipe(finalize(() => { objThis.isLoading = false; }));
+    })).subscribe((data) => {
+        objThis.filtrados[variableResultado] = data[tipoReq] ?? [];
+    });
+}
+
+function seleccionarTextoInput(event) {
+    event.target.select();
+}
+
+/**
+ * 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 b64Encode(val) {
+    return Buffer.from(val, 'binary').toString('base64');
+}
+/**
+ * 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 b64Decode(val) {
+    return Buffer.from(val, 'base64').toString('binary');
+}
+/**
+ * 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 encodeBase64String(str) {
+    const encoder = new TextEncoder();
+    const bytes = encoder.encode(str);
+    let binary = '';
+    bytes.forEach(b => binary += String.fromCharCode(b));
+    return btoa(binary);
+}
+/**
+ * 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);
+}
+/**
+ * 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));
+}
+/**
+ * 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() {
+    const agent = window.navigator.userAgent.toLowerCase();
+    switch (true) {
+        case agent.indexOf('edge') > -1:
+            return 'edge';
+        case agent.indexOf('opr') > -1 && !!window.opr:
+            return 'opera';
+        case agent.indexOf('chrome') > -1 && !!window.chrome:
+            return 'chrome';
+        case agent.indexOf('trident') > -1:
+            return 'ie';
+        case agent.indexOf('firefox') > -1:
+            return 'firefox';
+        case agent.indexOf('safari') > -1:
+            return 'safari';
+        default:
+            return 'other';
+    }
+}
+
+// import * as CryptoJS from 'crypto-js';
+// var CryptoJS = require("crypto-js");
+// Clave secreta (debe ser de 16, 24 o 32 caracteres)
+const secretKey = CryptoJS.enc.Utf8.parse('JVSoftSecret@20615178350');
+const iv = CryptoJS.enc.Utf8.parse('AnSalHuaJVSoft07'); // Debe ser de 16 bytes
+// Función para encriptar texto
+function encriptar(text) {
+    const encrypted = CryptoJS.AES.encrypt(text, secretKey, {
+        iv: iv,
+        mode: CryptoJS.mode.CBC,
+        padding: CryptoJS.pad.Pkcs7,
+    });
+    return encrypted.toString(); // Texto cifrado en Base64
+}
+// Función para desencriptar texto
+function desencriptar(ciphertext) {
+    const decrypted = CryptoJS.AES.decrypt(ciphertext, secretKey, {
+        iv: iv,
+        mode: CryptoJS.mode.CBC,
+        padding: CryptoJS.pad.Pkcs7,
+    });
+    return decrypted.toString(CryptoJS.enc.Utf8);
+}
+
+function formatearFechaFormato(val, format = 'dd/MM/yyyy') {
+    return val ? formatDate(val, format, 'es-PE') : '';
+}
+function formatearFecha(val, hora = '00:00:00') {
+    if (val) {
+        if (val.length <= 10) {
+            val = val + ' ' + hora;
+        }
+        return new Date(val);
+    }
+    return val;
+}
+function formatearFechaCadena(fecha) {
+    const year = parseInt(fecha.substring(0, 4), 10);
+    const month = parseInt(fecha.substring(4, 6), 10) - 1;
+    const day = parseInt(fecha.substring(6, 8), 10);
+    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) {
+        return `${user[0]}***@${domain}`; // 🔹 Si el usuario es muy corto, no se oculta nada
+    }
+    if (user.length <= 4) {
+        return `${user[0]}***${user.slice(-1)}@${domain}`; // 🔹 Muestra 1 al inicio y 1 al final
+    }
+    return `${user.slice(0, 2)}***${user.slice(-2)}@${domain}`; // 🔹 Muestra 2 al inicio y 2 al final
+}
+function isEmail(email) {
+    return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email);
+}
+
+const mimeTypes = {
+    // Imágenes
+    'jpg': 'image/jpeg',
+    'jpeg': 'image/jpeg',
+    'png': 'image/png',
+    'gif': 'image/gif',
+    'webp': 'image/webp',
+    'svg': 'image/svg+xml',
+    'ico': 'image/x-icon',
+    'bmp': 'image/bmp',
+    // Documentos
+    'pdf': 'application/pdf',
+    'doc': 'application/msword',
+    'docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+    'xls': 'application/vnd.ms-excel',
+    'xlsx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+    'ppt': 'application/vnd.ms-powerpoint',
+    'pptx': 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+    'txt': 'text/plain',
+    'csv': 'text/csv',
+    'json': 'application/json',
+    'xml': 'application/xml',
+    'html': 'text/html',
+    // Audio
+    'mp3': 'audio/mpeg',
+    'wav': 'audio/wav',
+    'ogg': 'audio/ogg',
+    'm4a': 'audio/mp4',
+    // Video
+    'mp4': 'video/mp4',
+    'avi': 'video/x-msvideo',
+    'mov': 'video/quicktime',
+    'wmv': 'video/x-ms-wmv',
+    'flv': 'video/x-flv',
+    'webm': 'video/webm',
+    'mkv': 'video/x-matroska',
+    // Archivos comprimidos
+    'zip': 'application/zip',
+    'rar': 'application/vnd.rar',
+    '7z': 'application/x-7z-compressed',
+    'tar': 'application/x-tar',
+    'gz': 'application/gzip',
+    'bz2': 'application/x-bzip2',
+    // Otros formatos
+    'js': 'application/javascript',
+    'css': 'text/css',
+    'ts': 'application/typescript',
+    'md': 'text/markdown',
+    'exe': 'application/octet-stream',
+    'eot': 'application/vnd.ms-fontobject',
+    'woff': 'font/woff',
+    'woff2': 'font/woff2',
+    'ttf': 'font/ttf',
+    'otf': 'font/otf',
+};
+function obtenerMimeType(nombreArchivo) {
+    const extension = nombreArchivo.split('.').pop()?.toLowerCase();
+    return extension ? mimeTypes[extension] || 'application/octet-stream' : null;
+}
+function sanitizarNombreArchivo(nombre, reemplazo = '_') {
+    // 1. Quitar caracteres no válidos para nombres de archivo
+    const nombreSanitizado = nombre.replace(/[\/\\:*?"<>|]/g, reemplazo);
+    // 2. Reemplazar espacios múltiples o al inicio/final
+    const nombreLimpio = nombreSanitizado.trim().replace(/\s+/g, reemplazo);
+    // 3. Asegurar longitud máxima (opcional, aquí 255 caracteres)
+    return nombreLimpio.substring(0, 255);
+}
+function getDataArchivoFromPath(value, conTimeStamp = false) {
+    const partesPath = value.split('/');
+    const nombreCompleto = partesPath[partesPath.length - 1];
+    let timeStamp = 1;
+    let nombreSinTimeStamp = nombreCompleto;
+    const partesNombre = nombreCompleto.split('-');
+    if (partesNombre.length > 1) {
+        timeStamp = partesNombre[0] * 1;
+        partesNombre.shift();
+        nombreSinTimeStamp = partesNombre.join('-');
+    }
+    if (conTimeStamp) {
+        return {
+            nombre: nombreCompleto,
+            extension: nombreCompleto.split('.').pop(),
+            d: timeStamp,
+            fechaSubida: timeStamp ? new Date(timeStamp * 1000) : '',
+        };
+    }
+    return {
+        nombre: nombreSinTimeStamp,
+        extension: nombreSinTimeStamp.split('.').pop(),
+        d: timeStamp,
+        fechaSubida: timeStamp ? new Date(timeStamp * 1000) : '',
+    };
+}
+function convertirBytes(valor, unidadSalida = null, incluirUnidad = true) {
+    const unidades = ['B', 'KB', 'MB', 'GB', 'TB', 'PB'];
+    const indiceEntrada = unidadSalida ? unidades.indexOf(unidadSalida) : 0;
+    if (indiceEntrada === -1) {
+        // Unidad de entrada no válida
+        return null;
+    }
+    let indiceActual = indiceEntrada;
+    let resultado = valor;
+    let cont = 0;
+    while (cont < 6 && (indiceActual < unidades.length - 1) && (resultado >= 1024)) {
+        resultado /= 1024;
+        indiceActual++;
+    }
+    if (incluirUnidad) {
+        return `${resultado.toFixed(2)} ${unidades[indiceActual]}`;
+    }
+    return resultado;
+}
+function downLoadFileStream(data, type, nombreArchivo) {
+    const blob = new Blob([data], { type });
+    saveAs(blob, nombreArchivo);
+}
+
+function establecerQuitarRequired(formulario, establecer = [], quitar = [], camposDisabled = []) {
+    establecer.forEach((control) => {
+        if (!formulario.get(control)?.hasValidator(Validators.required)) {
+            formulario.get(control)?.addValidators([Validators.required]);
+            formulario.get(control)?.enable();
+            formulario.get(control)?.updateValueAndValidity();
+        }
+    });
+    const deshabilitar = (strControl) => {
+        if (camposDisabled == 'todos') {
+            formulario.get(strControl)?.disable();
+            console.log(strControl);
+        }
+        else {
+            if (camposDisabled.includes(strControl)) {
+                formulario.get(strControl)?.disable();
+            }
+        }
+    };
+    quitar.forEach(control => {
+        if (formulario.get(control)?.hasValidator(Validators.required)) {
+            formulario.get(control)?.removeValidators([Validators.required]);
+            formulario.get(control)?.updateValueAndValidity();
+        }
+        deshabilitar(control);
+    });
+}
+function getFormValidationErrors(form) {
+    const result = [];
+    Object.keys(form.controls).forEach(key => {
+        const formProperty = form.get(key);
+        if (formProperty instanceof FormGroup) {
+            result.push(...getFormValidationErrors(formProperty));
+        }
+        const controlErrors = formProperty?.errors;
+        if (controlErrors) {
+            Object.keys(controlErrors).forEach(keyError => {
+                result.push({
+                    control: key,
+                    error: keyError,
+                    value: controlErrors[keyError]
+                });
+            });
+        }
+    });
+    return result;
+}
+function mensajesErrorFormControl(control) {
+    if (!control || !control.errors || !control.touched)
+        return '';
+    ReactiveFormConfig.set({
+        // RxwebValidators
+        validationMessage: {
+            required: 'Es requerido',
+            numeric: 'Debe ser numérico valido',
+            // minLength: 'minimum length is {{1}}',
+            // maxLength: 'allowed max length is {{1}}',
+        },
+    });
+    const errorMessages = {
+        required: 'Es requerido',
+        numeric: 'Debe ser numérico válido',
+        min: `Valor mínimo permitido: ${control.errors['min']?.min}`,
+        minValue: 'Debe ser positivo',
+        minlength: `Mínimo ${control.errors['minlength']?.requiredLength} caracteres.`,
+        maxlength: `Caracteres ${control.errors['maxlength']?.actualLength}/${control.errors['maxlength']?.requiredLength}`,
+        email: 'No se cumple con el formato de Correo Electrónico',
+        isNumeric: 'Debe seleccionar una opción',
+        hasNumber: 'Se requiere al menos un número',
+        hasCapitalCase: 'Se requiere al menos una mayúscula',
+        hasSmallCase: 'Se requiere al menos una minúscula',
+        hasSpecialCharacters: 'Se requiere al menos un carácter especial',
+        NoPassswordMatch: 'La contraseña no coincide',
+        itemSelected: 'Debe seleccionar una opción de la lista',
+        inputMask: 'El formato ingresado no es válido',
+    };
+    // Devuelve el primer mensaje de error encontrado
+    for (const errorKey of Object.keys(control.errors)) {
+        if (errorMessages[errorKey]) {
+            return errorMessages[errorKey];
+        }
+    }
+    // Si el error tiene un mensaje personalizado, usarlo
+    return control.errors[Object.keys(control.errors)[0]]?.message || '';
+}
+function toFormData(formValue) {
+    const formData = new FormData();
+    Object.keys(formValue).forEach((key) => {
+        const value = formValue[key];
+        if (value === null || value === undefined) {
+            return; // Ignorar valores nulos o indefinidos
+        }
+        if (Array.isArray(value)) {
+            value.forEach((item, index) => {
+                if (typeof item === 'object' && item !== null) {
+                    if ('file' in item) {
+                        formData.append(`${key}[${index}]`, item.file);
+                    }
+                    else {
+                        formData.append(`${key}[${index}]`, JSON.stringify(item));
+                    }
+                }
+                else {
+                    formData.append(`${key}[${index}]`, item.toString());
+                }
+            });
+        }
+        else if (typeof value === 'object') {
+            // Si es un objeto (pero no un array), convertirlo a JSON
+            formData.append(key, JSON.stringify(value));
+        }
+        else {
+            // Para valores primitivos (string, number, boolean)
+            formData.append(key, value.toString());
+        }
+    });
+    return formData;
+}
+function markAsTouchedWithoutEmitEvent(control) {
+    if (control instanceof FormControl) {
+        control.markAsTouched({ onlySelf: true });
+        control.updateValueAndValidity({ emitEvent: false });
+    }
+    else if (control instanceof FormGroup || control instanceof FormArray) {
+        Object.values(control.controls).forEach(childControl => {
+            markAsTouchedWithoutEmitEvent(childControl);
+        });
+        control.updateValueAndValidity({ emitEvent: false });
+    }
+}
+function setControlDesdeLista(config) {
+    const lista = config.lista$?.getValue() ?? [];
+    if (!lista.length)
+        return;
+    let seleccionado;
+    if (config.idProp && config.idValor !== undefined) {
+        seleccionado = lista.find((item) => item[config.idProp] === config.idValor);
+    }
+    else if (config.usarPrimeraOpcion) {
+        seleccionado = lista[0];
+    }
+    console.log(seleccionado);
+    if (!seleccionado)
+        return;
+    let valor;
+    if (config.selector) {
+        valor = config.selector(seleccionado);
+    }
+    else if (config.idProp) {
+        valor = seleccionado[config.idProp];
+    }
+    else {
+        valor = seleccionado;
+    }
+    if (config.formControl) {
+        config.formControl.setValue(valor);
+    }
+    else if (config.formGroup && config.controlName) {
+        const control = config.formGroup.get(config.controlName);
+        if (control instanceof FormControl) {
+            control.setValue(valor);
+        }
+    }
+}
+function transformarFechasPorNombreDeCampo(formValue) {
+    const retData = {};
+    Object.entries(formValue).forEach(([key, value]) => {
+        // ✅ No procesar Blob o File
+        if (value instanceof Blob || value instanceof File) {
+            retData[key] = value;
+            return;
+        }
+        if (value instanceof Date) {
+            if (/^d[A-Za-z]+/.test(key)) {
+                retData[key] = moment(value).format('YYYY-MM-DD');
+            }
+            else {
+                retData[key] = new Date(Date.UTC(value.getFullYear(), value.getMonth(), value.getDate(), value.getHours(), value.getMinutes(), value.getSeconds()));
+            }
+        }
+        else if (/^dt[A-Za-z]+/.test(key) && typeof value === 'string') {
+            if (/\d{4}-\d{2}-\d{2}\s\d{2}:\d{2}:\d{2}\.\d{3}/.test(value)) {
+                retData[key] = new Date(value + 'Z');
+            }
+            else if (/\d{4}-\d{2}-\d{2}T\d{2}:\d{2}/.test(value) || /\d{4}-\d{2}-\d{2}\s\d{2}:\d{2}/.test(value)) {
+                retData[key] = new Date(value + ':00.000Z');
+            }
+            else {
+                console.warn('FECHA INVALIDA AL ENVIAR (FormInter):', key, value);
+                retData[key] = value;
+            }
+        }
+        else if (Array.isArray(value)) {
+            if (value.every(v => v instanceof File || v instanceof Blob)) {
+                retData[key] = value;
+            }
+            else {
+                retData[key] = value.map(item => typeof item === 'object' && item !== null
+                    ? transformarFechasPorNombreDeCampo(item)
+                    : item);
+            }
+        }
+        else if (typeof value === 'object' && value !== null) {
+            retData[key] = transformarFechasPorNombreDeCampo(value);
+        }
+        else {
+            retData[key] = value;
+        }
+    });
+    return retData;
+}
+
+function mensajeAlerta(tipo, titulo, mensaje, opciones) {
+    opciones = {
+        ...{
+            heightAuto: false,
+            title: titulo,
+            html: mensaje,
+            icon: tipo,
+            confirmButtonText: 'Aceptar',
+            // customClass: {
+            // 	confirmButton: 'btn btn-lg btn-outline-success mx-2',
+            // 	cancelButton: 'btn btn-lg btn-outline-dark mx-2'
+            // },
+            // buttonsStyling: false
+        },
+        ...opciones
+    };
+    return swal.fire(opciones);
+}
+function mensajeTimer(tipo, titulo, mensaje, milisegundos = 3000, showLoading = true, opciones) {
+    let timerInterval;
+    opciones = {
+        ...{
+            heightAuto: false,
+            title: titulo,
+            html: mensaje + '<br> Se cerrará en <strong> X </strong> segundos.',
+            icon: tipo,
+            timer: milisegundos,
+            showCancelButton: false,
+            showConfirmButton: false,
+            willOpen: () => {
+                if (showLoading) {
+                    swal.showLoading();
+                }
+                timerInterval = setInterval(() => {
+                    const impr = Math.ceil(((swal.getTimerLeft() ?? 1) / 1000));
+                    if (swal.getHtmlContainer()) {
+                        // @ts-ignore
+                        swal.getHtmlContainer().querySelector('strong').textContent = String(impr);
+                    }
+                }, 100);
+            },
+            willClose: () => {
+                clearInterval(timerInterval);
+            }
+        },
+        ...opciones
+    };
+    return swal.fire(opciones);
+}
+// @ts-ignore
+function mensajeConfirmacion(tipo, titulo, mensaje, opciones) {
+    opciones = {
+        ...{
+            heightAuto: false,
+            title: titulo,
+            html: mensaje,
+            icon: tipo,
+            showCancelButton: true,
+            // confirmButtonColor: '#3f51b5',
+            // cancelButtonColor: '#ffffff',
+            confirmButtonText: 'Confirmar',
+            cancelButtonText: 'Cancelar',
+            reverseButtons: true,
+            // customClass: {
+            // 	confirmButton: 'btn btn-lg btn-outline-success mx-2',
+            // 	cancelButton: 'btn btn-lg btn-outline-dark mx-2'
+            // },
+            // buttonsStyling: false
+        },
+        ...opciones
+    };
+    return swal.fire(opciones);
+}
+function mensajeToast(tipo, titulo, mensaje, opciones) {
+    opciones = {
+        ...{
+            heightAuto: false,
+            title: titulo,
+            html: mensaje,
+            icon: tipo,
+            confirmButtonText: 'Aceptar',
+            toast: true,
+            position: 'top-end',
+            showConfirmButton: false,
+            timer: 3000,
+            timerProgressBar: true,
+        },
+        ...opciones
+    };
+    return swal.fire(opciones);
+}
+
+function mensajesDeError(error, toast = false) {
+    let msg;
+    if (error.error && error.error instanceof ArrayBuffer) {
+        const msgArrayBuffer = (arrayBuffer) => {
+            try {
+                const mensajeError = JSON.parse(new TextDecoder("utf-8").decode(arrayBuffer));
+                return mensajeError.message || 'Error desconocido';
+            }
+            catch (parseError) {
+                console.error('Error al analizar la respuesta JSON:', parseError);
+                return 'Error al analizar la respuesta JSON';
+            }
+        };
+        msg = msgArrayBuffer(error.error);
+    }
+    else {
+        switch (error.status) {
+            case 0:
+                // msg = error.message;
+                msg = 'El servidor no responde, verifica tu conexion a la red';
+                console.log(error);
+                break;
+            case 401:
+                if (error.error && typeof error.error == 'object') {
+                    if (error.error.message) {
+                        msg = error.error.message;
+                    }
+                    else if (error.error.error) {
+                        msg = error.error.error;
+                    }
+                    else {
+                        msg = JSON.stringify(error.error);
+                        console.log(error);
+                    }
+                }
+                else if (error.error && typeof error.error == 'string') {
+                    msg = error.error;
+                }
+                else {
+                    msg = 'Acceso no autorizado';
+                    console.log(error);
+                }
+                break;
+            case 422:
+                let strEr = '';
+                console.log(typeof error.error.errors);
+                console.log(error.error.errors);
+                if (error.error.errors) {
+                    Object.keys(error.error.errors).forEach(o => {
+                        strEr += '<li>' + error.error.errors[o][0] + '</li>';
+                    });
+                    msg = (error.error.message ?? '') + '<ul>' + strEr + '</ul>';
+                }
+                else if (error.error.error) {
+                    msg = error.error.msg;
+                }
+                break;
+            case 429:
+            case 400:
+            case 500:
+            case 503:
+                msg = error.error.message;
+                break;
+            case 504:
+                msg = 'No se puede conectar al servidor. Comprueba tu conexion a la red - ' + error.statusText;
+                break;
+            default:
+                msg = error?.error?.message ?? 'Error de Sistema';
+                console.log(error);
+                break;
+        }
+    }
+    if (!msg) {
+        msg = error.statusText ?? 'Error inesperado o datos inexistentes.';
+    }
+    let tituloFinal = 'Error!';
+    let mensajeFinal;
+    if (msg.includes('Hmac::doVerify')) {
+        console.log(error, msg);
+        return;
+    }
+    else if (msg == 'Server Error') {
+        console.log(error, msg);
+        return;
+    }
+    else if (msg.includes('[IMSSP]')) {
+        mensajeFinal = 'Error en consulta de registros.';
+    }
+    else if (msg.includes('Tiempo de espera de la')) {
+        mensajeFinal = 'Hubo un error en la solicitud de datos, por favor actualice (SHIFT + F5)';
+    }
+    else {
+        mensajeFinal = msg;
+    }
+    if (toast) {
+        mensajeToast('error', tituloFinal, mensajeFinal);
+    }
+    else {
+        mensajeAlerta('error', tituloFinal, mensajeFinal);
+    }
+    throw new Error(mensajeFinal);
+}
+
+let dataSessionStorageKey = {
+    tokenStringKey: 'JVSoftTkn',
+    changePasswordKey: 'chPwd',
+    logoUrl: 'logo_url',
+    logoLogin: 'login-logo',
+    backgroundLogin: 'login-background',
+    favicon: 'favicon',
+    darkMode: 'darkMode',
+    serverTimestamp: 'srvtmstp',
+    apiDataKey: 'reqDt',
+};
+let localStorageKeys = dataSessionStorageKey;
+function inicializarVariablesSessionStorage(datSesion) {
+    dataSessionStorageKey = datSesion;
+}
+function setJwtTokenData(data) {
+    localStorage.setItem(dataSessionStorageKey.tokenStringKey, data);
+}
+function jwtTokenData(key = dataSessionStorageKey.tokenStringKey) {
+    const tokenObj = localStorage.getItem(key);
+    try {
+        return JSON.parse(tokenObj);
+    }
+    catch (error) {
+        return null;
+    }
+}
+function jwtToken(key = dataSessionStorageKey.tokenStringKey) {
+    const varJwtTokenData = jwtTokenData(key);
+    if (varJwtTokenData) {
+        return varJwtTokenData.access_token;
+    }
+    return '';
+}
+function jwtTokenExpiracion(key = dataSessionStorageKey.tokenStringKey) {
+    const jwtStr = jwtToken(key);
+    if (!jwtStr)
+        return null;
+    try {
+        const decodedToken = jwtDecode(jwtStr);
+        return decodedToken.exp ? decodedToken.exp * 1000 : null; // Convertir a milisegundos
+    }
+    catch (e) {
+        return null;
+    }
+}
+function jwtTokenExpiracionFaltante() {
+    return Math.abs(moment().diff(jwtTokenExpiracion(), 'seconds'));
+}
+function setCambiarPwd(accion = true) {
+    localStorage.setItem(dataSessionStorageKey.changePasswordKey, (accion ? 1 : 0).toString());
+}
+function getCambiarPwd() {
+    const frmCambioPwd = localStorage.getItem(dataSessionStorageKey.changePasswordKey);
+    if (!frmCambioPwd) {
+        return null;
+    }
+    return frmCambioPwd == '1';
+}
+function delLocalStorage(keyElim = [
+    dataSessionStorageKey.tokenStringKey,
+    dataSessionStorageKey.changePasswordKey,
+    dataSessionStorageKey.apiDataKey,
+]) {
+    keyElim.forEach(key => {
+        localStorage.removeItem(key);
+    });
+}
+function getLocalStorage(key) {
+    return localStorage.getItem(key);
+}
+function setLocalStorage(key, value = '') {
+    localStorage.setItem(key, value.toString());
+}
+
+function roundToDecimal(number, decimal) {
+    return parseFloat(number.toFixed(decimal));
+}
+function numberToWords(num) {
+    if (num === 0)
+        return 'cero';
+    if (num < 0)
+        return 'menos ' + numberToWords(Math.abs(num));
+    if (num > 999999999999)
+        return 'número demasiado grande';
+    const ones = ['', 'un', 'dos', 'tres', 'cuatro', 'cinco', 'seis', 'siete', 'ocho', 'nueve'];
+    const onesFinal = ['', 'uno', 'dos', 'tres', 'cuatro', 'cinco', 'seis', 'siete', 'ocho', 'nueve'];
+    const tens = ['', 'diez', 'veinte', 'treinta', 'cuarenta', 'cincuenta', 'sesenta', 'setenta', 'ochenta', 'noventa'];
+    const teens = ['diez', 'once', 'doce', 'trece', 'catorce', 'quince', 'dieciséis', 'diecisiete', 'dieciocho', 'diecinueve'];
+    const hundreds = ['', 'ciento', 'doscientos', 'trescientos', 'cuatrocientos', 'quinientos', 'seiscientos', 'setecientos', 'ochocientos', 'novecientos'];
+    // Función auxiliar para "un"/"uno"
+    const getOneForm = (n, isFinal) => n === 1 ? (isFinal ? 'uno' : 'un') : onesFinal[n];
+    let words = '';
+    // Miles de millones (ahora sí se ejecuta)
+    if (num >= 1000000000) {
+        const billions = Math.floor(num / 1000000000);
+        words += (billions === 1 ? 'mil' : numberToWords(billions) + ' mil') + ' millones ';
+        num %= 1000000000;
+    }
+    // Millones
+    if (num >= 1000000) {
+        const millions = Math.floor(num / 1000000);
+        words += millions === 1 ? 'un millón ' : numberToWords(millions) + ' millones ';
+        num %= 1000000;
+    }
+    // Miles
+    if (num >= 1000) {
+        const thousands = Math.floor(num / 1000);
+        words += thousands === 1 ? 'mil ' : numberToWords(thousands) + ' mil ';
+        num %= 1000;
+    }
+    // Centenas (con tratamiento especial para "ciento uno")
+    if (num >= 100) {
+        if (num === 100) {
+            words += 'cien';
+            num = 0;
+        }
+        else {
+            words += hundreds[Math.floor(num / 100)];
+            num %= 100;
+            if (num > 0) {
+                words += ' ' + getOneForm(num, true); // Siempre "uno" después de ciento
+                num = 0;
+            }
+        }
+    }
+    // Decenas y unidades
+    if (num > 0) {
+        const isFinalWord = words === '';
+        if (num < 10) {
+            words += getOneForm(num, isFinalWord);
+        }
+        else if (num < 20) {
+            words += teens[num - 10];
+        }
+        else if (num < 30) {
+            if (num === 21)
+                words += 'veintiuno';
+            else if (num === 22)
+                words += 'veintidós';
+            else if (num === 23)
+                words += 'veintitrés';
+            else if (num === 26)
+                words += 'veintiséis';
+            else
+                words += `veinti${onesFinal[num % 10]}`;
+        }
+        else {
+            words += tens[Math.floor(num / 10)];
+            if (num % 10 > 0) {
+                words += ' y ' + getOneForm(num % 10, isFinalWord);
+            }
+        }
+    }
+    return words.trim().replace(/\s+/g, ' ');
+}
+
+function objectPropertiesToType(formFields) {
+    Object.keys(formFields).filter(control => !!formFields[control]).forEach(control => {
+        if (/^dt[a-zA-Z]+/.test(control)) {
+            formFields[control] = formatDate(formFields[control], 'yyyy-MM-dd HH:mm', 'es-PE');
+        }
+        else if (control.startsWith('d')) {
+            formFields[control] = formatearFecha(formFields[control]);
+        }
+        else if (control.startsWith('n')) {
+            formFields[control] = Number(formFields[control]);
+        }
+    });
+    return formFields;
+}
+function objectPropertiesBoolean(formFields, retorno = 'boolean') {
+    Object.keys(formFields).forEach(control => {
+        const valRetorno = (ctrl) => {
+            switch (retorno) {
+                case 'boolean':
+                    formFields[ctrl] = formFields[ctrl] == 1;
+                    break;
+                case 'bit':
+                    formFields[ctrl] = formFields[ctrl] ? 1 : 0;
+                    break;
+            }
+        };
+        if (control.charAt(0) == 'b' || (control.charAt(0) == 'i' && control.indexOf('Estado') !== -1)) {
+            valRetorno(control);
+        }
+    });
+    return formFields;
+}
+
+function generateRandomString(length) {
+    let result = '';
+    const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+    const charactersLength = characters.length;
+    for (let i = 0; i < length; i++) {
+        result += characters.charAt(Math.floor(Math.random() * charactersLength));
+    }
+    return result;
+}
+/**
+ * Obtiene el host (hostname) de una URL o cadena host[:port].
+ * Opcionalmente puede devolver también el puerto si está presente.
+ *
+ * - Acepta inputs como:
+ *   'https://example.com/path', 'example.com:3000', 'localhost', 'http://[::1]:4200'
+ * - Usa la API URL cuando es posible (más robusta) y cae a un regex de respaldo.
+ *
+ * @param url Cadena que representa una URL o host
+ * @param options
+ * @param options.includePort Si es true, incluye":puerto" cuando exista (por defecto false)
+ * @param options.includeProtocol Incluye "http://" o "https://" según corresponda (por defecto false)
+ */
+function obtenerHostDesdeUrl(url, options) {
+    if (!url)
+        return null;
+    const includePort = !!options?.includePort;
+    const includeProtocol = !!options?.includeProtocol;
+    // Intentar con API URL
+    try {
+        const candidate = url.includes('://') ? url : `http://${url}`;
+        const parsed = new URL(candidate);
+        const protocol = includeProtocol ? `${parsed.protocol}//` : '';
+        const hostname = parsed.hostname;
+        const port = parsed.port;
+        if (!hostname)
+            return null;
+        return `${protocol}${hostname}${includePort && port ? `:${port}` : ''}`;
+    }
+    catch {
+        // Regex fallback
+        const regex = /^(?:(?<protocol>[a-z]+):\/\/)?(?:www\.)?(?<host>\[[^\]]+\]|[A-Za-z0-9.-]+)(?::(?<port>\d{1,5}))?/;
+        const match = String(url).match(regex);
+        if (!match?.groups)
+            return null;
+        let host = match.groups['host'];
+        if (host.startsWith('[') && host.endsWith(']')) {
+            host = host.slice(1, -1);
+        }
+        const port = match.groups['port'];
+        const protocol = includeProtocol ? `${match.groups['protocol'] ?? 'http'}://` : '';
+        return `${protocol}${host}${includePort && port ? `:${port}` : ''}`;
+    }
+}
+/** @deprecated Alias compatible (deprecated) — preferir usar `obtenerHostDesdeUrl`. */
+const extraerDominio = (url, options) => obtenerHostDesdeUrl(url, options);
+
+function verificarRUC(ruc) {
+    const f = [5, 4, 3, 2, 7, 6, 5, 4, 3, 2];
+    const rucArray = ruc.split('');
+    const nArray = f.map((item, idx) => {
+        return item * parseFloat(rucArray[idx]);
+    });
+    const suma = nArray.reduce((a, b) => a + b, 0);
+    const residuo = suma % 11;
+    const residuo2 = 11 - residuo;
+    // @residuo=CONVERT(Integer,Right(CONVERT(VarChar,@residuo),1))
+    const residuo3 = residuo2.toString().charAt(residuo2.toString().length - 1);
+    const ultimoCaracter = ruc.toString().charAt(ruc.toString().length - 1);
+    if (residuo3 == ultimoCaracter) {
+        return true;
+    }
+    mensajeAlerta('error', 'Datos No válidos', ' El número de RUC no es válido');
+    return false;
+}
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { b64Decode, b64Encode, buscarPorCampo, changeSelect, changeSelectApi, changeSelectData, changeSelectDataApi, changeSelectReformateado, convertirBytes, 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, 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, toFormData, transformarFechasPorNombreDeCampo, verificarRUC };
+//# sourceMappingURL=jvsoft-utils-functions.mjs.map