@jvsoft/utils 0.0.10 → 0.0.11

package/CHANGELOG.md

@@ -0,0 +1,7 @@
+# @jvsoft/utils
+
+## 0.0.11
+
+### Patch Changes
+
+- WSpace

package/ng-package.json

@@ -0,0 +1,7 @@
+{
+  "$schema": "../../node_modules/ng-packagr/ng-package.schema.json",
+  "dest": "../../dist/utils",
+  "lib": {
+    "entryFile": "src/public-api.ts"
+  }
+}

package/package.json

@@ -1,6 +1,9 @@
 {
   "name": "@jvsoft/utils",
-  "version": "0.0.10",
+  "version": "0.0.11",
+  "publishConfig": {
+    "access": "public"
+  },
   "peerDependencies": {
     "@angular/common": ">=16.0.0",
     "@angular/core": ">=16.0.0",
@@ -19,27 +22,9 @@
     "tslib": "^2.3.0"
   },
   "sideEffects": false,
-  "module": "fesm2022/jvsoft-utils.mjs",
-  "typings": "index.d.ts",
-  "exports": {
-    "./package.json": {
-      "default": "./package.json"
-    },
-    ".": {
-      "types": "./index.d.ts",
-      "default": "./fesm2022/jvsoft-utils.mjs"
-    },
-    "./src/interfaces": {
-      "types": "./src/interfaces/index.d.ts",
-      "default": "./fesm2022/jvsoft-utils-src-interfaces.mjs"
-    },
-    "./src/functions": {
-      "types": "./src/functions/index.d.ts",
-      "default": "./fesm2022/jvsoft-utils-src-functions.mjs"
-    },
-    "./src/pipes": {
-      "types": "./src/pipes/index.d.ts",
-      "default": "./fesm2022/jvsoft-utils-src-pipes.mjs"
-    }
+  "scripts": {
+    "build": "ng build utils --configuration production",
+    "watch": "ng build utils --watch --configuration development",
+    "test": "ng test utils"
   }
-}
+}

package/src/classes/data-model.ts

@@ -0,0 +1,150 @@
+import {AbstractControl, FormControl, FormControlOptions, FormGroup, ValidationErrors, ValidatorFn, Validators} from '@angular/forms';
+import {esNumero} from '../functions';
+
+export class DataModel {
+    public modelosChk: { [key: string]: boolean | any } = {}; // Usar any para valores dinámicos
+
+    public checkbox: ForCheckboxModel;
+
+    constructor() {
+        this.checkbox = new ForCheckboxModel(this);
+    }
+
+    generarId(row: any, campoValor: string[] | string, separador = '') {
+        if (typeof campoValor == 'string') {
+            campoValor = [campoValor];
+        }
+        return campoValor.map(data => row[data]).join(separador);
+    }
+
+    // Agrega controles al objeto modelosChk
+    agregarControles(lista: any[], idLista: string, limpiar = true, campoValor: string[] | string | null = null, campoValorSeparador = '') {
+
+        if (limpiar) {
+            this.modelosChk = {};
+        }
+
+        const asignarValor = (dat: any, idLista: string, campoValor: string, key?: string) => {
+            if (!key) {
+                key = dat[idLista] + (campoValor.includes('.') ? '':`.${campoValor}`);
+            }
+            const mat = campoValor.match(/^([in])[A-Z][a-zA-Z]+/);
+            if (mat) {
+                this.modelosChk[key] = dat[campoValor] * 1;
+            }
+            else {
+                this.modelosChk[key] = dat[campoValor];
+            }
+        }
+
+
+        lista.forEach(dat => {
+            if (campoValor === null) {
+                // Caso 1: Sin campoValor, se asigna false
+                this.modelosChk[dat[idLista]] = false;
+            }
+            else if (typeof campoValor === 'string') {
+                // Caso 2: campoValor es un string
+                asignarValor(dat, idLista, campoValor, dat[idLista]);
+            }
+            else if (campoValorSeparador) {
+                const idStr = this.generarId(dat, campoValor, campoValorSeparador);
+                // Caso 2: campoValor es un string
+                asignarValor(dat, idLista, '.', idStr);
+            }
+            else {
+                // Caso 3: campoValor es un array de strings
+                campoValor.forEach(data => asignarValor(dat, idLista, data));
+            }
+        });
+    }
+
+    // Establece el estado de un índice
+    setState(idx: string, state: boolean) {
+        this.modelosChk[idx] = state;
+    }
+
+    // Obtiene el estado de un índice
+    getState(idx: string): boolean | any {
+        return this.modelosChk[idx];
+    }
+
+    getDataMultiple(idx: string) {
+        const camposMod = Object.keys(this.modelosChk).filter(key => key.split('.')[0] == idx);
+        const vRet: any = {};
+        camposMod.forEach(key => {
+            vRet[key.split('.')[1]] = this.modelosChk[key];
+        });
+        return vRet;
+    }
+
+    // Genera una lista basada en el estado de los índices
+    generarLista(tipoRetorno: 'array' | 'object' | null = null, esCampoNumerico = false): string | object | any[] {
+        const strLista: string[] = [];
+        const objLista: { [key: string]: boolean | any } = {};
+        Object.keys(this.modelosChk).forEach(key => {
+            if ((esCampoNumerico && esNumero(this.modelosChk[key])) ||
+                (this.modelosChk[key])
+            ) {
+                strLista.push(key);
+                objLista[key] = this.modelosChk[key];
+            }
+        });
+        if (tipoRetorno === 'array') {
+            return strLista;
+        }
+        if (tipoRetorno === 'object') {
+            return objLista;
+        }
+        return strLista.join(',');
+    }
+
+    generarFormGroupFromModelosChk(tipo?: string): FormGroup {
+        const formGroupObj: { [key: string]: FormControl } = {};
+        let validadores: ValidatorFn | ((control: AbstractControl) => ValidationErrors | null)[] | FormControlOptions | null | undefined = []
+        if (tipo == 'number') {
+            validadores = [
+                Validators.required,
+                Validators.min(1)
+            ]
+        }
+        Object.keys(this.modelosChk).forEach(key => {
+            formGroupObj[key] = new FormControl(this.modelosChk[key], validadores);
+        });
+        return new FormGroup(formGroupObj);
+
+        // return this.formBuilder.group(formGroupObj);
+    }
+}
+
+class ForCheckboxModel {
+    private modeloCheck: DataModel;
+
+    constructor(modeloCheck: DataModel) {
+        this.modeloCheck = modeloCheck;
+    }
+
+    get cantidadActivos() {
+        return Object.values(this.modeloCheck.modelosChk).filter(Boolean).length;
+    }
+
+    get existenActivados() {
+        return this.cantidadActivos > 0;
+    }
+
+    get todosActivos() {
+        const total = Object.keys(this.modeloCheck.modelosChk).length;
+        const activos = this.cantidadActivos;
+        return activos > 0 && total === activos;
+    }
+
+    get algunosActivos() {
+        const total = Object.keys(this.modeloCheck.modelosChk).length;
+        const activos = this.cantidadActivos;
+        return activos > 0 && total !== activos;
+    }
+
+    establecerTodos(activo: boolean) {
+        Object.keys(this.modeloCheck.modelosChk).forEach(idx => this.modeloCheck.modelosChk[idx] = activo);
+    }
+}

package/src/functions/base64.ts

@@ -0,0 +1,8 @@
+import {Buffer} from 'buffer';
+
+export function b64Encode(val: string) {
+    return Buffer.from(val, 'binary').toString('base64');
+}
+export function b64Decode(val: string) {
+    return Buffer.from(val, 'base64').toString('binary');
+}

package/src/functions/browser.ts

@@ -0,0 +1,20 @@
+
+export function getBrowserName() {
+    const agent = window.navigator.userAgent.toLowerCase();
+    switch (true) {
+        case agent.indexOf('edge') > -1:
+            return 'edge';
+        case agent.indexOf('opr') > -1 && !!(<any>window).opr:
+            return 'opera';
+        case agent.indexOf('chrome') > -1 && !!(<any>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';
+    }
+}

package/src/functions/crypto-js.ts

@@ -0,0 +1,29 @@
+// import * as CryptoJS from 'crypto-js';
+import 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
+export function encriptar(text: string): string {
+    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
+export function desencriptar(ciphertext: string): string {
+    const decrypted = CryptoJS.AES.decrypt(ciphertext, secretKey, {
+        iv: iv,
+        mode: CryptoJS.mode.CBC,
+        padding: CryptoJS.pad.Pkcs7,
+    });
+    return decrypted.toString(CryptoJS.enc.Utf8);
+}

package/src/functions/date.ts

@@ -0,0 +1,23 @@
+import {formatDate} from '@angular/common';
+
+export function formatearFechaFormato(val: string, format: string = 'dd/MM/yyyy') {
+    return val ? formatDate(val, format, 'es-PE'):'';
+}
+
+export function formatearFecha(val: string, hora = '00:00:00') {
+    if (val) {
+        if (val.length <= 10) {
+            val = val + ' ' + hora;
+        }
+        return new Date(val);
+    }
+    return val;
+}
+
+export function formatearFechaCadena(fecha: string): Date {
+    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);
+}

package/src/functions/email.ts

@@ -0,0 +1,17 @@
+export function maskEmail(email: string): string {
+    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
+}
+
+export function isEmail(email: string): boolean {
+    return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email);
+}

package/src/functions/file.ts

@@ -0,0 +1,138 @@
+import {saveAs} from 'file-saver';
+
+
+const mimeTypes: { [key: string]: string } = {
+    // 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',
+};
+
+export function obtenerMimeType(nombreArchivo: string): string | null {
+    const extension = nombreArchivo.split('.').pop()?.toLowerCase();
+    return extension ? mimeTypes[extension] || 'application/octet-stream' : null;
+}
+export function sanitizarNombreArchivo(nombre: string, reemplazo: string = '_'): string {
+    // 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);
+}
+
+export function getDataArchivoFromPath(value: string, conTimeStamp = false): {
+    nombre: string, extension?: string, d?: any, fechaSubida: any
+} {
+    const partesPath = value.split('/');
+    const nombreCompleto = partesPath[partesPath.length - 1];
+    let timeStamp = 1;
+    let nombreSinTimeStamp = nombreCompleto;
+    const partesNombre: any [] = 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):'',
+    };
+}
+
+export function convertirBytes(valor: number, unidadSalida: string | null = null, incluirUnidad: boolean = true): string | number | null {
+    const unidades: string[] = ['B', 'KB', 'MB', 'GB', 'TB', 'PB'];
+    const indiceEntrada: number = unidadSalida ? unidades.indexOf(unidadSalida):0;
+
+    if (indiceEntrada === -1) {
+        // Unidad de entrada no válida
+        return null;
+    }
+
+    let indiceActual: number = indiceEntrada;
+    let resultado: number = 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;
+}
+
+
+export function downLoadFileStream(data: any, type: string, nombreArchivo?: string) {
+    const blob = new Blob([data], {type});
+    saveAs(blob, nombreArchivo);
+}

package/src/functions/forms.ts

@@ -0,0 +1,145 @@
+import {AbstractControl, FormArray, FormControl, FormGroup, ValidationErrors, Validators} from '@angular/forms';
+import {ReactiveFormConfig} from '@rxweb/reactive-form-validators';
+
+export function establecerQuitarRequired(formulario: FormGroup, establecer: any[] = [], quitar: any[] = [], camposDisabled: string[] | 'todos' = []) {
+    establecer.forEach((control: string) => {
+        if (!formulario.get(control)?.hasValidator(Validators.required)) {
+            formulario.get(control)?.addValidators([Validators.required]);
+            formulario.get(control)?.enable();
+            formulario.get(control)?.updateValueAndValidity();
+        }
+    });
+    const deshabilitar = (strControl: string) => {
+        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);
+    });
+}
+
+export function getFormValidationErrors(form: FormGroup) {
+    const result: { control: string; error: string; value: any; }[] = [];
+    Object.keys(form.controls).forEach(key => {
+        const formProperty = form.get(key);
+        if (formProperty instanceof FormGroup) {
+            result.push(...getFormValidationErrors(formProperty));
+        }
+        const controlErrors: ValidationErrors | null | undefined = formProperty?.errors;
+        if (controlErrors) {
+            Object.keys(controlErrors).forEach(keyError => {
+                result.push({
+                    control: key,
+                    error: keyError,
+                    value: controlErrors[keyError]
+                });
+            });
+        }
+    });
+
+    return result;
+}
+
+export function mensajesErrorFormControl(control: AbstractControl | null): string {
+    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: Record<string, string> = {
+        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 || '';
+}
+
+export function toFormData<T extends Record<string, any>>(formValue: T): FormData {
+    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;
+}
+
+export function markAsTouchedWithoutEmitEvent(control: AbstractControl): void {
+    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});
+    }
+}