@jvsoft/utils 0.0.9 → 0.0.11

package/src/functions/objects-arrays.ts

@@ -0,0 +1,243 @@
+export function deepMerge(source: any, target: any): any {
+    // 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
+export function deepClone(obj: any): any {
+    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: Record<string, any> = 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.
+ */
+export function buscarPorCampo<T>(datosFn: {
+    items: T[];
+    campo: keyof T;
+    valor: any;
+    campoHijo?: string; // Campo opcional para búsqueda recursiva
+}): T | undefined {
+    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 as keyof T] && Array.isArray(item[datosFn.campoHijo as keyof T])) {
+            // Realiza la búsqueda recursiva en el campo hijo
+            const encontrado = buscarPorCampo({
+                items: item[datosFn.campoHijo as keyof T] as T[], // 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;
+}
+
+export function sumarPropiedades(item: Record<string, any>, campos: string[]) {
+    const datosSumar = campos.map(campo => (item[campo] * 1));
+    return datosSumar.reduce((a, b) => a + b, 0);
+}
+
+export function esNumero(value: any): boolean {
+    return !isNaN(Number(value));
+}
+
+export function sumarObjetos(arrayObjetos: any[], campos: string[]): Record<string, number> {
+    return arrayObjetos.reduce((accumulator: Record<string, number>, item: any) => {
+        campos.forEach(campo => {
+            const valor = Number(item[campo]);
+            if (!isNaN(valor)) {
+                accumulator[campo] = (accumulator[campo] ?? 0) + valor;
+            }
+        });
+        return accumulator;
+    }, {});
+}
+
+export function getUniqueValues(array: any[]) {
+    return array.filter((currentValue, index, arr) => (
+        arr.indexOf(currentValue) === index
+    ));
+}
+
+export function getUniqueValuesByProperty<T>(objetos: T[], campo: string): T[] {
+    const objetosUnicos: {[key: string]: T} = {};
+
+    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);
+}
+
+
+export function ordenarArray(array: any[], numeros = false, sentido: 'ASC' | 'DESC' = 'ASC'): any[] {
+    if (numeros) {
+        if (sentido != 'ASC') {
+            return array.sort((a: any, b: any) => b - a);
+        }
+        return array.sort((a: any, b: any) => a - b);
+    }
+    return array.sort((a, b) => (a > b) ? 1:((b > a) ? -1:0));
+
+}
+
+export function ordenarPorPropiedad(objData: any, propiedad: string, /**@deprecated*/ numeros = false) {
+    return ordenarPorPropiedades(objData, {propiedades: [propiedad], direcciones:['asc']});
+}
+
+export function ordenarPorPropiedades<T>(arr: T[], options: {
+    propiedades: (keyof T)[],
+    direcciones?: ('asc' | 'desc' | '')[],
+}): T[] {
+    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);
+    });
+}
+
+export function groupBy<T extends Record<string, any>, K extends keyof T>(
+    array: T[],
+    key: K | ((obj: T) => string)
+): Record<string, T[]> {
+    const keyFn = key instanceof Function ? key:(obj: T) => obj[key];
+    return array.reduce((objectsByKeyValue, obj) => {
+        const value = keyFn(obj);
+        objectsByKeyValue[value] = (objectsByKeyValue[value] || []).concat(obj);
+        return objectsByKeyValue;
+    }, {} as Record<string, T[]>);
+}
+
+export function nestGroupsBy(arr: any, properties: any) {
+    const fnGroupBy = (conversions: any, property2: any) => {
+        return conversions.reduce((acc: any, obj: any) => {
+            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: any, path: string): any {
+    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.
+ */
+export function obtenerUltimoOrden(data: any[], campo: string, incrementar: boolean = true): number {
+    const max = data.reduce((mayor, item) => {
+        const valor = Number(getValueByPath(item, campo)) || 0;
+        return valor > mayor ? valor:mayor;
+    }, 0);
+
+    return incrementar ? max + 1:max;
+}

package/src/functions/public-api.ts

@@ -0,0 +1,19 @@
+export * from './mat-form-controls';
+
+export * from './base64'
+export * from './browser'
+export * from './crypto-js';
+export * from './date';
+export * from './email';
+export * from './file'
+export * from './forms'
+export * from './http-client'
+export * from './local-storage';
+export * from './number';
+export * from './object-transformation'
+export * from './objects-arrays'
+export * from './string'
+export * from './sweetalert'
+export * from './utiles'
+
+

package/src/functions/string.ts

@@ -0,0 +1,9 @@
+export function generateRandomString(length: number) {
+    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;
+}

package/src/functions/sweetalert.ts

@@ -0,0 +1,95 @@
+import swal, {SweetAlertOptions, SweetAlertResult} from 'sweetalert2';
+
+export function mensajeAlerta(tipo: 'success' | 'error' | 'info' | 'warning' | 'question', titulo: string, mensaje: string, opciones?: SweetAlertOptions) {
+    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);
+}
+
+export function mensajeTimer(tipo: 'success' | 'error' | 'info' | 'warning' | 'question', titulo: string, mensaje: string, milisegundos = 3000, showLoading = true, opciones?: SweetAlertOptions) {
+    let timerInterval: any;
+    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
+export function mensajeConfirmacion(tipo: 'success' | 'error' | 'info' | 'warning' | 'question', titulo, mensaje, opciones?: SweetAlertOptions): Promise<SweetAlertResult<Awaited<any>>> {
+    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);
+}
+export function mensajeToast(tipo: 'success' | 'error' | 'info' | 'warning' | 'question', titulo: string, mensaje: string, opciones?: SweetAlertOptions) {
+    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);
+}

package/src/functions/utiles.ts

@@ -0,0 +1,20 @@
+import {mensajeAlerta} from './sweetalert';
+
+export function verificarRUC(ruc: string) {
+    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;
+}

package/{interfaces/datos.d.ts → src/interfaces/datos.ts}

@@ -1,4 +1,5 @@
-import { BehaviorSubject } from 'rxjs';
+import {BehaviorSubject} from 'rxjs';
+
 export interface DataServidor {
     [key: string]: BehaviorSubject<any>;
 }

package/src/interfaces/index.ts

@@ -0,0 +1 @@
+export * from './public-api'

package/src/interfaces/ng-package.json

@@ -0,0 +1,5 @@
+{
+  "lib": {
+    "entryFile": "public-api.ts"
+  }
+}

package/src/interfaces/public-api.ts

@@ -0,0 +1,3 @@
+export * from './datos';
+// export * from './otros';
+

package/src/interfaces/routes.ts

@@ -0,0 +1,42 @@
+import {Route} from '@angular/router';
+import {Type} from '@angular/core';
+
+export interface JVSoftRouteData {
+    scrollDisabled?: boolean;
+    toolbarShadowEnabled?: boolean;
+    containerEnabled?: boolean;
+
+    iMenuId?: number;
+    sinReloj?: boolean;
+    titulo?: string;
+    ignorarDerechos?: boolean,
+    derechos?: any;
+
+    [key: string]: any;
+
+    // camposFiltro?: CampoFiltro[];
+    // parametrosFiltro?: ControlParams[];
+    // parametrosFiltro$?: Observable<ControlParams[]>;
+    /** Usar junto al guard CanActivate 'activarCondicionDespachoGuard' **/
+    activarCondicionDespachoGuardParams?: {
+        condicion?(despacho: any): boolean,
+        error?: {
+            rutaRedireccion?: string,
+            mensaje?: string,
+        }
+    },
+
+    headerTemplates?: {
+        bajo?: Type<any>;
+        medio?: Type<any>;
+        botonesCentro: any[];
+    }
+}
+
+
+export interface JVSoftRoute extends Route {
+    data?: JVSoftRouteData;
+    children?: JVSoftRoute[];
+}
+
+export type JVSoftRoutes = JVSoftRoute[];

package/src/pipes/data-en-lista.pipe.ts

@@ -0,0 +1,40 @@
+import {Pipe, PipeTransform} from '@angular/core';
+
+@Pipe({
+    name: 'dataEnLista',
+})
+export class DataEnListaPipe implements PipeTransform {
+
+    transform(coleccion: object[], idBuscar: string | string[], dato: any): any {
+        if (coleccion) {
+            if (Array.isArray(idBuscar)) {
+                return coleccion.find(item => {
+                    const arrCoincide: any[] = [];
+                    idBuscar.forEach((campo: string, idx) => {
+                        // @ts-ignore
+                        arrCoincide.push((item[campo] == dato[idx]));
+                    });
+                    return arrCoincide.every(e => e === true);
+                });
+            }
+            // @ts-ignore
+            return coleccion.find(item => item[idBuscar] == dato);
+        }
+        return null;
+    }
+
+    // opcSelec(coleccion, idBuscar, formControl) {
+    // 	if (coleccion) {
+    // 		if (formControl.value == '') {
+    // 			return {cModuloNombre: '', cModuloPadreNombre: 'Todos', iModuloId: ''};
+    // 		}
+    // 		return coleccion.find(item => item[idBuscar] == formControl.value);
+    // 	}
+    // 	return null;
+    // }
+
+}
+
+export function dataEnLista(coleccion: object[], idBuscar: string | string[], dato: any): any {
+    return new DataEnListaPipe().transform(coleccion, idBuscar, dato);
+}

package/src/pipes/date-diff-string.pipe.ts

@@ -0,0 +1,117 @@
+import {Pipe, PipeTransform} from '@angular/core';
+
+@Pipe({
+	name: 'dateDiffString',
+	pure: true
+})
+export class DateDiffStringPipe implements PipeTransform {
+	transform(startingDate: Date, endingDate: Date): any {
+		let startDate = new Date(startingDate);
+		// user not pass endingDate then set current date as end date.
+		if (!endingDate) {
+			endingDate = new Date();
+		}
+		let endDate = new Date(endingDate);
+		// chack start date and end date and base on condication alter date.
+		if (startDate > endDate) {
+			const swap = startDate;
+			startDate = endDate;
+			endDate = swap;
+		}
+
+		const disgregado = this.separarMilisegundos(endDate.getTime() - startDate.getTime());
+		// console.log(disgregado);
+		const formatearATexto = (arrayToFill: string[], campo: any, texto: any, textoPlural = 's') => {
+			if (campo > 0) {
+				arrayToFill.push( campo + ' ' + texto + (campo > 1 ? textoPlural : '') );
+			}
+			return arrayToFill;
+		};
+
+		let arrDFinal: any[] = [];
+		arrDFinal = formatearATexto(arrDFinal, disgregado.years, 'año');
+		arrDFinal = formatearATexto(arrDFinal, disgregado.months, 'mes', 'es');
+		arrDFinal = formatearATexto(arrDFinal, disgregado.weeks, 'semana');
+		arrDFinal = formatearATexto(arrDFinal, disgregado.days, 'día');
+		arrDFinal = formatearATexto(arrDFinal, disgregado.hours, 'hora');
+		arrDFinal = formatearATexto(arrDFinal, disgregado.minutes, 'minuto');
+		arrDFinal = formatearATexto(arrDFinal, disgregado.seconds, 'segundo');
+		if (arrDFinal.length > 3) {
+			arrDFinal.splice(3);
+			arrDFinal.splice(-1, 0, 'y');
+		} else {
+			if (arrDFinal.length > 1) {
+				arrDFinal.splice(-1, 0, 'y');
+			}
+		}
+		return arrDFinal.join(' ');
+	}
+
+	separarMilisegundos(milisegundos: any): {
+		years: number,
+		months: number,
+		weeks: number,
+		days: number,
+		hours: number,
+		minutes: number,
+		seconds: number,
+	} {
+		const todoEnSegundos = milisegundos / 1000;
+		let secsUsed = 0;
+		const years = Math.floor(todoEnSegundos / 31536000);
+		if (years > 0) {
+			secsUsed += (years * 31536000);
+		}
+		const months = Math.floor((todoEnSegundos - secsUsed) / 2628288);
+		if (months > 0) {
+			secsUsed += (months * 2628288);
+		}
+		const weeks = Math.floor((todoEnSegundos - secsUsed) / 604800);
+		if (weeks > 0) {
+			secsUsed += (weeks * 604800);
+		}
+		const days = Math.floor((todoEnSegundos - secsUsed) / 86400);
+		if (days > 0) {
+			secsUsed += (days * 86400);
+		}
+		const hours = Math.floor((todoEnSegundos - secsUsed) / 3600);
+		if (hours > 0) {
+			secsUsed += (hours * 3600);
+		}
+		const minutes = Math.floor((todoEnSegundos - secsUsed) / 60);
+		if (minutes > 0) {
+			secsUsed += (minutes * 60);
+		}
+		const seconds = Math.round(todoEnSegundos - secsUsed);
+
+		return {
+			years,
+			months,
+			weeks,
+			days,
+			hours,
+			minutes,
+			seconds,
+		};
+	}
+
+/*
+	transform(to: Date, from: Date, seconds = true, strict = false): string {
+		if (typeof to == 'string') {
+			to = new Date(to);
+		}
+		if (typeof from == 'string') {
+			from = new Date(from);
+		}
+		console.log(typeof to, typeof from);
+		console.log(to);
+		console.log(from);
+
+		return strict ? formatDistanceStrict(from, to, {unit: 'minute', locale: es}) : formatDistance(from, to, {includeSeconds: seconds, locale: es});
+	}
+	*/
+}
+
+export function dateDiffString(startingDate: Date, endingDate: Date){
+	return new DateDiffStringPipe().transform(startingDate, endingDate);
+}

package/src/pipes/filtro.pipe.ts

@@ -0,0 +1,64 @@
+import {Pipe, PipeTransform} from '@angular/core';
+
+interface OpcionesBusqueda {
+    texto: string;
+    longitudMinima?: number;
+    campo?: string | string[];
+    mostrarObligado?: MostrarObligado;
+}
+
+interface MostrarObligado {
+    campo: string;
+    items: any[];
+}
+
+@Pipe({
+    name: 'filtro'
+})
+export class FiltroPipe implements PipeTransform {
+
+    transform(items: any[], opcionesBusqueda: OpcionesBusqueda): any[] {
+        if (!items || !Array.isArray(items)) return [];
+        if (!opcionesBusqueda.texto || opcionesBusqueda.texto.length < (opcionesBusqueda.longitudMinima ?? 1)) return items;
+
+        const normalize = (() => {
+            const from = 'ÃÀÁÄÂÈÉËÊÌÍÏÎÒÓÖÔÙÚÜÛãàáäâèéëêìíïîòóöôùúüûÑñÇç';
+            const to = 'AAAAAEEEEIIIIOOOOUUUUaaaaaeeeeiiiioooouuuunncc';
+            const mapping: Record<string, string> = {};
+
+            for (let i = 0; i < from.length; i++) {
+                mapping[from[i]] = to[i];
+            }
+
+            return (str: string): string => {
+                return str.split('').map(c => mapping[c] || c).join('');
+            };
+        })();
+
+        const textoNormalizado = normalize(opcionesBusqueda.texto.toLowerCase());
+
+        return items.filter(item => {
+            // 🔹 Manejo de `mostrarObligado`
+            if (opcionesBusqueda.mostrarObligado) {
+                const {campo, items: obligados} = opcionesBusqueda.mostrarObligado;
+                if (obligados.includes(item[campo])) return true;
+            }
+
+            // 🔹 Manejo de `campo`
+            if (opcionesBusqueda.campo) {
+                if (Array.isArray(opcionesBusqueda.campo)) {
+                    return opcionesBusqueda.campo.some(campo => {
+                        const valor = item[campo] as string | undefined;
+                        return valor ? normalize(valor.toLowerCase()).includes(textoNormalizado):false;
+                    });
+                }
+                else {
+                    const valor = item[opcionesBusqueda.campo] as string | undefined;
+                    return valor ? normalize(valor.toLowerCase()).includes(textoNormalizado):false;
+                }
+            }
+
+            return false;
+        });
+    }
+}