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

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;
+        });
+    }
+}

package/src/pipes/form-control-is-required.pipe.ts

@@ -0,0 +1,17 @@
+import {Pipe, PipeTransform} from '@angular/core';
+import {AbstractControl, Validators} from '@angular/forms';
+
+@Pipe({
+  name: 'formControlIsRequired'
+})
+export class FormControlIsRequiredPipe implements PipeTransform {
+
+	transform(formControl: AbstractControl, ...args: unknown[]): any {
+		if (!formControl) { return false; }
+		return formControl.hasValidator(Validators.required);
+	}
+
+}
+export function  formControlIsRequired(formControl: AbstractControl) {
+    return new FormControlIsRequiredPipe().transform(formControl);
+}

package/src/pipes/index.ts

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

package/src/pipes/json-parse.pipe.ts

@@ -0,0 +1,18 @@
+import { Pipe, PipeTransform } from '@angular/core';
+
+@Pipe({
+	name: 'jsonParse'
+})
+export class JsonParsePipe implements PipeTransform {
+
+	transform(value: string, ...args: unknown[]): any {
+		if (!value) { return []; }
+		try {
+			return JSON.parse(value);
+		} catch (e) {
+			console.warn('La cadena "' + value + '" no es JSON');
+			return [];
+		}
+	}
+
+}

package/src/pipes/ng-package.json

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

package/src/pipes/no-sanitize.pipe.ts

@@ -0,0 +1,12 @@
+import {Pipe, PipeTransform} from '@angular/core';
+import {DomSanitizer, SafeHtml} from '@angular/platform-browser';
+
+@Pipe({ name: 'noSanitize' })
+export class NoSanitizePipe implements PipeTransform {
+	constructor(private domSanitizer: DomSanitizer) {
+
+	}
+	transform(html: string): SafeHtml {
+		return this.domSanitizer.bypassSecurityTrustHtml(html);
+	}
+}

package/src/pipes/public-api.ts

@@ -0,0 +1,10 @@
+
+export * from './data-en-lista.pipe';
+export * from './date-diff-string.pipe';
+export * from './filtro.pipe'
+export * from './form-control-is-required.pipe'
+export * from './json-parse.pipe'
+export * from './no-sanitize.pipe'
+export * from './tipo-valor-funcion.pipe'
+export * from './zero-fill.pipe'
+

package/src/pipes/tipo-valor-funcion.pipe.ts

@@ -0,0 +1,23 @@
+import {Pipe, PipeTransform} from '@angular/core';
+
+export type TipoValorFuncion<T> = T | ((...param: any) => T);
+
+@Pipe({
+    name: 'tipoValorFuncion',
+    standalone: true, // Para usarlo en standalone components
+})
+export class TipoValorFuncionPipe implements PipeTransform {
+    transform<T>(datoParam: TipoValorFuncion<T>, defaultValue?: T, ...param: any[]): T | undefined {
+        if (datoParam === undefined || datoParam === null) {
+            return defaultValue;
+        }
+        if (typeof datoParam === 'function') {
+            return (datoParam as (...args: any) => T)(...param);
+        }
+        return datoParam;
+    }
+}
+
+export function tipoValorFuncion<T>(datoParam: TipoValorFuncion<T>, defaultValue?: T, ...param: any[]): T | undefined {
+    return new TipoValorFuncionPipe().transform(datoParam, defaultValue, ...param);
+}

package/src/pipes/zero-fill.pipe.ts

@@ -0,0 +1,19 @@
+import {Pipe, PipeTransform} from '@angular/core';
+
+@Pipe({
+	name: 'zeroFill',
+})
+export class ZeroFillPipe implements PipeTransform {
+
+	transform(value: unknown, digitos: number, ...args: unknown[]) {
+		let s = value + '';
+		while (s.length < digitos) {
+			s = '0' + s;
+		}
+		return s;
+	}
+
+}
+export function zeroFill(value: unknown, digitos: number, ...args: unknown[]) {
+	return new ZeroFillPipe().transform(value, digitos, args);
+}

package/src/public-api.ts

@@ -0,0 +1,12 @@
+/*
+ * Public API Surface of utils
+ */
+
+export * from './classes/data-model';
+export * from './functions';
+export * from './pipes';
+export * from './interfaces';
+// export * from './functions/common.function';
+
+// export * from './lib/utils.component';
+// export * from './lib/utils.service';

package/tsconfig.lib.json

@@ -0,0 +1,18 @@
+/* To learn more about Typescript configuration file: https://www.typescriptlang.org/docs/handbook/tsconfig-json.html. */
+/* To learn more about Angular compiler options: https://angular.dev/reference/configs/angular-compiler-options. */
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../out-tsc/lib",
+    "rootDir": ".", // ✅ permite que cualquier subcarpeta como "functions/" esté incluida
+    "baseUrl": ".",
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "inlineSources": true,
+    "types": []
+  },
+  "exclude": [
+    "**/*.spec.ts"
+  ]
+}

package/tsconfig.lib.prod.json

@@ -0,0 +1,11 @@
+/* To learn more about Typescript configuration file: https://www.typescriptlang.org/docs/handbook/tsconfig-json.html. */
+/* To learn more about Angular compiler options: https://angular.dev/reference/configs/angular-compiler-options. */
+{
+  "extends": "./tsconfig.lib.json",
+  "compilerOptions": {
+    "declarationMap": false
+  },
+  "angularCompilerOptions": {
+    "compilationMode": "partial"
+  }
+}

package/tsconfig.spec.json

@@ -0,0 +1,15 @@
+/* To learn more about Typescript configuration file: https://www.typescriptlang.org/docs/handbook/tsconfig-json.html. */
+/* To learn more about Angular compiler options: https://angular.dev/reference/configs/angular-compiler-options. */
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../out-tsc/spec",
+    "types": [
+      "jasmine"
+    ]
+  },
+  "include": [
+    "**/*.spec.ts",
+    "**/*.d.ts"
+  ]
+}

package/classes/data-model.d.ts

@@ -1,25 +0,0 @@
-import { FormGroup } from '@angular/forms';
-export declare class DataModel {
-    modelosChk: {
-        [key: string]: boolean | any;
-    };
-    checkbox: ForCheckboxModel;
-    constructor();
-    generarId(row: any, campoValor: string[] | string, separador?: string): string;
-    agregarControles(lista: any[], idLista: string, limpiar?: boolean, campoValor?: string[] | string | null, campoValorSeparador?: string): void;
-    setState(idx: string, state: boolean): void;
-    getState(idx: string): boolean | any;
-    getDataMultiple(idx: string): any;
-    generarLista(tipoRetorno?: 'array' | 'object' | null, esCampoNumerico?: boolean): string | object | any[];
-    generarFormGroupFromModelosChk(tipo?: string): FormGroup;
-}
-declare class ForCheckboxModel {
-    private modeloCheck;
-    constructor(modeloCheck: DataModel);
-    get cantidadActivos(): number;
-    get existenActivados(): boolean;
-    get todosActivos(): boolean;
-    get algunosActivos(): boolean;
-    establecerTodos(activo: boolean): void;
-}
-export {};