@jvsoft/utils 0.0.13-alpha.3 → 0.0.13-alpha.4

package/src/functions/number.ts

@@ -0,0 +1,85 @@
+export function roundToDecimal(number: number, decimal: number): number {
+    return parseFloat(number.toFixed(decimal));
+}
+
+export function numberToWords(num: number): string {
+    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: number, isFinal: boolean): string =>
+        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, ' ');
+}

package/src/functions/object-transformation.ts

@@ -0,0 +1,37 @@
+import {formatDate} from '@angular/common';
+import {formatearFecha} from './date';
+
+export function objectPropertiesToType(formFields: Record<string, any>) {
+    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;
+}
+
+export function objectPropertiesBoolean(formFields: Record<string, any>, retorno: 'boolean' | 'bit' = 'boolean') {
+    Object.keys(formFields).forEach(control => {
+        const valRetorno = (ctrl: any) => {
+            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;
+}

package/src/functions/objects-arrays.ts

@@ -0,0 +1,321 @@
+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;
+}
+
+
+/**
+ * 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.
+ */
+export function eliminarColumnaPorIndex<T extends unknown[][]>(
+    data: T,
+    columnIndex: number | number[]
+): T {
+    if (!Array.isArray(data)) return [] as unknown as T;
+
+    // Normalizar a array único y ordenado (descendente para evitar reindexación al splicing)
+    const indices: number[] = 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 as typeof row;
+    }) as T;
+}
+
+
+
+export function eliminarDuplicados<T extends object>(
+    array: T[],
+    claves?: (keyof T)[]
+): T[] {
+    const unicos = new Map<string, T>();
+
+    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());
+}
+
+export function eliminarElementos<T extends object>(
+    origen: T[],
+    elementosAEliminar: T[],
+    claves?: (keyof T)[]
+): T[] {
+    const clavesSet = new Set<string>();
+
+    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);
+    });
+}
+

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,68 @@
+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;
+}
+
+/**
+ * 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)
+ */
+export function obtenerHostDesdeUrl(
+    url: string | null | undefined,
+    options?: { includePort?: boolean; includeProtocol?: boolean }
+): string | null {
+    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`. */
+export const extraerDominio = (
+    url: string | null | undefined,
+    options?: { includePort?: boolean; includeProtocol?: boolean }
+) => obtenerHostDesdeUrl(url, options);

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';
+