ngx-redi-core 18.2.5 → 19.0.2

package/Helper/index.ts

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

package/Helper/ng-package.json

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

package/Helper/{public-api.d.ts → public-api.ts}

@@ -1,7 +1,10 @@
-export * from './src/helpers/csv.service';
-export * from './src/helpers/data-subject.service';
-export * from './src/helpers/bag-data-subject.service';
-export * from './src/helpers/query-filters.service';
-export * from './src/models/interfaces/query-filters';
-export * from './src/helpers/form-bind.service';
-export * from './src/helpers/location.service';
+export * from './src/helpers/csv.service';
+export * from './src/helpers/data-subject.service';
+export * from './src/helpers/bag-data-subject.service';
+
+export * from './src/helpers/query-filters.service';
+export * from './src/models/interfaces/query-filters';
+
+export * from './src/helpers/form-bind.service';
+
+export * from './src/helpers/location.service';

package/Helper/src/helpers/bag-data-subject.service.spec.ts

@@ -0,0 +1,16 @@
+import { TestBed } from '@angular/core/testing';
+
+import { BagDataSubjectService } from './bag-data-subject.service';
+
+describe('BagDataSubjectService', () => {
+  let service: BagDataSubjectService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({});
+    service = TestBed.inject(BagDataSubjectService);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+});

package/Helper/src/helpers/bag-data-subject.service.ts

@@ -0,0 +1,66 @@
+import { Injectable } from '@angular/core';
+import { DataSubjectService } from './data-subject.service';
+import { Observable } from 'rxjs';
+
+/**
+ * Servicio para compartir datos entre micro-fronts
+ * @decorators `@Injectable`
+ */
+@Injectable({
+  providedIn: 'root'
+})
+export class BagDataSubjectService {
+
+  /**
+   * Crea un nuevo servicio de datos compartido
+   */
+  constructor() {
+    this.subjects = {};
+  }
+
+  /**
+   * Obtiene el subjet dada un identificador
+   * @param subject Identificador
+   * @returns Servicio de datos
+   */
+  public getSubject<T>(subject: string): DataSubjectService<T> {
+    let result = Reflect.get(this.subjects, subject);
+    if (!result) {
+      result = new DataSubjectService<T>();
+      Reflect.defineProperty(this.subjects, subject, { value: result });
+    }
+    return result as DataSubjectService<T>;
+  }
+
+  /**
+   * Asigna los datos a un servicio mediante su identificador
+   * @param subject Identificador del servicio
+   * @param data Datos a emitir
+   */
+  public setData<T>(subject: string, data: T): void {
+    return this.getSubject<T>(subject).broadcast(data);
+  }
+
+  /**
+   * Obtiene el ultimo dato del servicio especificando su identificador
+   * @param subject Identificador del servicio
+   * @returns Dato
+   */
+  public getData<T>(subject: string): T {
+    return this.getSubject(subject).data as T;
+  }
+
+  /**
+   * Obtiene el observable especificando el servicio
+   * @param subject Identificador del servicio
+   * @returns Observable<T>
+   */
+  public getObservable<T>(subject: string): Observable<T> {
+    return this.getSubject(subject).observer as Observable<T>;
+  }
+
+  /**
+   * Objeto contenedor de los subjects
+   */
+  private subjects: object;
+}

package/Helper/src/helpers/csv.service.spec.ts

@@ -0,0 +1,16 @@
+import { TestBed } from '@angular/core/testing';
+
+import { CsvService } from './csv.service';
+
+describe('CsvService', () => {
+  let service: CsvService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({});
+    service = TestBed.inject(CsvService);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+});

package/Helper/src/helpers/csv.service.ts

@@ -0,0 +1,71 @@
+import { Injectable } from '@angular/core';
+/**
+ * Servicio que provee métodos para trabajar con datos CSV
+ */
+@Injectable({
+  providedIn: 'root'
+})
+export class CsvService {
+  /**
+     * Genera el texto CSV a partir de un archivo
+     * @param data- Datos a construir
+     * @returns CSV texto
+     */
+  public generarCsv<T extends {}>(data: Array<T>): string {
+    const datos = data.map(d => {
+      return Object.values(d)
+        .filter(p => this.tipoSerializable(p))
+        .map(v => (v as string).includes(',') ? `"${v}"` : v);
+    });
+    return `${data?.slice(0, 1)?.map((o) => {
+      return `${Object.keys(o).join(',')}\n`
+    })}${datos.map(d => {
+      return Object.values(d).join(',');
+    }).join('\n')}`;
+  }
+
+  /**
+   * Método que indica si la propiedad es serializable
+   * @param propiedad - Propiedad a validar
+   * @returns True si es una propiedad serializable
+   */
+  private tipoSerializable(propiedad: unknown): boolean {
+    return typeof (propiedad) !== 'object' &&
+      typeof (propiedad) !== 'function';
+  }
+
+  /**
+   * Descarga el CSV a partir de los datos establecidos
+   * @param archivo - Nombre del archivo a descargar
+   * @param data - Arreglo de datos a descargar
+   */
+  public descargarCsv<T extends {}>(archivo: string, data: Array<T>): void {
+    const blob = new Blob([BOM_CSV, this.generarCsv(data)], { type: TYPE_CSV });
+    const link = this.generarLink(archivo, blob);
+    document.body.appendChild(link);
+    link.click();
+    document.body.removeChild(link);
+  }
+
+  /**
+   * Genera el link para el blob y archivo establecidos
+   * @param archivo - Nombre del archivo a descargar
+   * @param blob - Contenido del blob
+   * @returns link
+   */
+  private generarLink(archivo: string, blob: Blob): HTMLAnchorElement {
+    const link = document.createElement('a') as HTMLAnchorElement;
+    if (link.download !== undefined) {
+      link.setAttribute('href', URL.createObjectURL(blob));
+      link.setAttribute('download', archivo);
+      link.style.visibility = 'hidden';
+    }
+    return link;
+  }
+
+}
+
+/** Tipo MIME CSV + Encode */
+const TYPE_CSV = 'text/csv;charset=utf-8;';
+/** BOM CSV */
+const BOM_CSV = new Uint8Array([0xEF, 0xBB, 0xBF]);

package/Helper/src/helpers/data-subject.service.spec.ts

@@ -0,0 +1,16 @@
+import { TestBed } from '@angular/core/testing';
+
+import { DataSubjectService } from './data-subject.service';
+
+describe('DataSubjectService', () => {
+  let service: DataSubjectService<unknown>;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({});
+    service = TestBed.inject(DataSubjectService);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+});

package/Helper/src/helpers/data-subject.service.ts

@@ -0,0 +1,53 @@
+import { Injectable } from '@angular/core';
+import { Observable, Subject } from 'rxjs';
+import { DataSubject } from '../models/interfaces/data-subject.interface';
+
+/**
+ * Servicio para compartir datos
+ * @decorators `@Injectable`
+ */
+@Injectable({
+  providedIn: 'root'
+})
+export class DataSubjectService<T> implements DataSubject<T> {
+  /**
+   * Crea un nuevo servicio de Datos compartidos
+   */
+  constructor() {
+    this._data = undefined as T;
+    this.subject = new Subject();
+  }
+
+  /**
+   * Contiene el subject que emite datos
+   */
+  private readonly subject: Subject<T>;
+
+  /**
+   * Datos internos
+   */
+  private _data: T;
+
+  /**
+   * Emite los datos a los subscriptores
+   * @param data Datos a emitir
+   */
+  public broadcast(data: T): void {
+    this._data = data;
+    this.subject.next(data);
+  }
+
+  /**
+   * Contiene el ultimo dato emitido
+   */
+  public get data(): T {
+    return this._data;
+  }
+
+  /**
+   * Observable  que notifica los cambios
+   */
+  public get observer(): Observable<T> {
+    return this.subject.asObservable();
+  }
+}

package/Helper/src/helpers/form-bind.service.spec.ts

@@ -0,0 +1,16 @@
+import { TestBed } from '@angular/core/testing';
+
+import { FormBindService } from './form-bind.service';
+
+describe('FormBindService', () => {
+  let service: FormBindService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({});
+    service = TestBed.inject(FormBindService);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+});

package/Helper/src/helpers/form-bind.service.ts

@@ -0,0 +1,30 @@
+import { Injectable } from '@angular/core';
+import { FormGroup } from '@angular/forms';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class FormBindService {
+
+  constructor() { }
+
+  public setValues<T extends {}>(entity: T, formGroup: unknown) {
+    if (!entity || !formGroup) {
+      return;
+    }
+    let internalForm = formGroup as FormGroup;
+    Object.keys(entity).map(k => internalForm.get(k)?.setValue(Reflect.get(entity, k)));
+  }
+
+  public updateValues<T extends {}>(entity: T, formGroup: unknown) {
+    if (!entity || !formGroup) {
+      return;
+    }
+    let internalForm = formGroup as FormGroup;
+    Object.keys(entity).map(k => {
+      if (internalForm.contains(k)) {
+        Reflect.set(entity, k, internalForm.get(k)?.value);
+      }
+    });
+  }
+}

package/Helper/src/helpers/location.service.spec.ts

@@ -0,0 +1,16 @@
+import { TestBed } from '@angular/core/testing';
+
+import { LocationService } from './location.service';
+
+describe('LocationService', () => {
+  let service: LocationService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({});
+    service = TestBed.inject(LocationService);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+});

package/Helper/src/helpers/location.service.ts

@@ -0,0 +1,27 @@
+import { inject, Injectable } from '@angular/core';
+import { Route, Router } from '@angular/router';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class LocationService {
+
+  private readonly router = inject(Router);
+
+  constructor() { }
+
+  public navigate(path: string): void {
+    this.router.navigate(this.getRelative(path));
+  }
+
+  public getRelative(relativePath?: string): Array<string> {
+    return this.getCurrentPath(relativePath);
+  }
+
+  private getCurrentPath(relative: string | undefined): Array<string> {
+    const url = (new URL(relative ?? '', window.location.href)).href;
+    const currentLocation = Reflect.get(this.router, 'location')?._basePath ?? '';
+    return url.substring(url.lastIndexOf(currentLocation) + currentLocation.length)
+      .split('/');
+  }
+}

package/Helper/src/helpers/query-filters.service.spec.ts

@@ -0,0 +1,16 @@
+import { TestBed } from '@angular/core/testing';
+
+import { QueryFiltersService } from './query-filters.service';
+
+describe('QueryFiltersService', () => {
+  let service: QueryFiltersService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({});
+    service = TestBed.inject(QueryFiltersService);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+});

package/Helper/src/helpers/query-filters.service.ts

@@ -0,0 +1,85 @@
+import { Inject, Injectable } from '@angular/core';
+import { ActivatedRoute, Params } from '@angular/router';
+import { QueryFilters } from '../models/interfaces/query-filters';
+import { map, Observable } from 'rxjs';
+
+/**
+ * Servicio de filtro de datos para query params
+ * @decorators `@Injectable`
+ */
+@Injectable({
+  providedIn: 'root'
+})
+export class QueryFiltersService {
+  /**
+   * Crea una nueva instancia de QueryFilter
+   * @param {ActivatedRoute} rutaActiva - Servicio de ruta
+   */
+  constructor(@Inject(ActivatedRoute) private readonly rutaActiva: ActivatedRoute) {
+  }
+
+  /**
+   * Obtiene los filtros de la ruta
+   * @returns Observable<QueryFilters>
+   */
+  public getQueryFilters(): Observable<QueryFilters> {
+    return this.rutaActiva.queryParams.pipe(map(queryParam => {
+      return {
+        seleccionarTodo: queryParam['seleccionar'] === '',
+        seleccionados: this.getData(queryParam, 'seleccionar'),
+        deseleccionados: this.getData(queryParam, 'deseleccionar'),
+        eliminados: this.getData(queryParam, 'eliminar'),
+        filtrados: this.getData(queryParam, 'filtrar'),
+        servicio: queryParam['bagDataSubject'] ?? ''
+      } as QueryFilters;
+    }));
+  }
+
+
+  public getSnapFilters(state: string): QueryFilters {
+    let filter = Reflect.get(history.state, state);
+    if (filter) {
+      filter = {
+        seleccionarTodo: filter.seleccionarTodo ?? false,
+        seleccionados: filter.seleccionados ?? [],
+        deseleccionados: filter.deseleccionados ?? [],
+        eliminados: filter.eliminados ?? [],
+        filtrados: filter.filtrados ?? [],
+        servicio: filter.servicio ?? ''
+      } as QueryFilters;
+    }
+    return filter;
+  }
+
+  public generateFilter(url: string): QueryFilters | undefined {
+    if (!url) {
+      return undefined;
+    }
+    let params = url.split('&')
+      .map(p => {
+        let data = p.split('=');
+        return {
+          key: data[0],
+          value: data[1] ?? ''
+        }
+      });
+    return {
+      seleccionarTodo: params.some(p => p.key === 'seleccionar' && p.value === ''),
+      seleccionados: params.find(p => p.key === 'seleccionar')?.value.split(',') ?? [],
+      deseleccionados: params.find(p => p.key === 'deseleccionar')?.value.split(',') ?? [],
+      eliminados: params.find(p => p.key === 'eliminar')?.value.split(',') ?? [],
+      filtrados: params.find(p => p.key === 'filtrar')?.value?.split(',') ?? [],
+      servicio: params.find(p => p.key === 'servicio')?.value ?? '',
+    } as QueryFilters;
+  }
+
+  /**
+   * Obtiene los datos de los parámetros establecidos
+   * @param {Params} param - Parámetros
+   * @param {string} key - Clave del parámetro
+   * @returns Arreglo de parámetros
+   */
+  private getData(param: Params, key: string): Array<string> {
+    return param[key]?.split(',') ?? [];
+  }
+}

package/Helper/src/models/interfaces/{data-subject.interface.d.ts → data-subject.interface.ts}

@@ -1,21 +1,24 @@
-import { Observable } from "rxjs";
-/**
- * Interface de suscripción para compartir datos
- */
-export interface DataSubject<T> {
-    /**
-     * Realiza la propagación de datos a los suscriptores
-     * @param {T} data - Dato a propagar
-     */
-    broadcast(data: T): void;
-    /**
-     * Obtiene los datos propagados
-     * @return {T} datos
-     */
-    get data(): T;
-    /**
-     * Observable de datos
-     * @return {Observer<T>} Observable<T>
-     */
-    get observer(): Observable<T>;
-}
+import { Observable } from "rxjs";
+
+/**
+ * Interface de suscripción para compartir datos
+ */
+export interface DataSubject<T> {
+    /**
+     * Realiza la propagación de datos a los suscriptores
+     * @param {T} data - Dato a propagar
+     */
+    broadcast(data: T): void;
+
+    /**
+     * Obtiene los datos propagados
+     * @return {T} datos
+     */
+    get data(): T;
+
+    /**
+     * Observable de datos
+     * @return {Observer<T>} Observable<T>
+     */
+    get observer(): Observable<T>;
+}

package/Helper/src/models/interfaces/{query-filters.d.ts → query-filters.ts}

@@ -1,29 +1,34 @@
-/**
- * Interface que contiene los filtros de parámetros
- */
-export interface QueryFilters {
-    /**
-     * Indica que elementos están seleccionados
-     */
-    seleccionados: Array<string>;
-    /**
-     * Indica que elementos están deseleccionados
-     */
-    deseleccionados: Array<string>;
-    /**
-     * Indica que elementos se eliminan
-     */
-    eliminados: Array<string>;
-    /**
-     * Indica que elementos se filtran
-     */
-    filtrados: Array<string>;
-    /**
-     * Indica si se selecciona todo
-     */
-    seleccionarTodo: boolean;
-    /**
-     * Contiene el nombre del servicio que comparten datos
-     */
-    servicio: string;
-}
+/**
+ * Interface que contiene los filtros de parámetros
+ */
+export interface QueryFilters {
+    /**
+     * Indica que elementos están seleccionados
+     */
+    seleccionados: Array<string>;
+
+    /**
+     * Indica que elementos están deseleccionados
+     */
+    deseleccionados: Array<string>;
+
+    /**
+     * Indica que elementos se eliminan
+     */
+    eliminados: Array<string>;
+
+    /**
+     * Indica que elementos se filtran
+     */
+    filtrados: Array<string>;
+
+    /**
+     * Indica si se selecciona todo
+     */
+    seleccionarTodo: boolean;
+
+    /**
+     * Contiene el nombre del servicio que comparten datos
+     */
+    servicio: string;
+}

package/RediBreadCrumb/index.ts

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

package/RediBreadCrumb/ng-package.json

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

package/RediBreadCrumb/{public-api.d.ts → public-api.ts}

@@ -1,2 +1,2 @@
-/** Componentes */
-export * from './src/components/redi-bread-crumb/redi-bread-crumb.component';
+/** Componentes */
+export * from './src/components/redi-bread-crumb/redi-bread-crumb.component';

package/RediBreadCrumb/src/components/redi-bread-crumb/redi-bread-crumb.component.html

@@ -0,0 +1,4 @@
+<div>
+    <span class="material-symbols-outlined"> home </span>
+    <p>{{crumb}}</p>
+</div>

package/RediBreadCrumb/src/components/redi-bread-crumb/redi-bread-crumb.component.scss

@@ -0,0 +1,20 @@
+div {
+  color: gray;
+  display: inline-flex;
+}
+
+p {
+  margin: 0px;
+  padding-left: 5px;
+  align-content: end;
+  font-size: 0.9em;
+  letter-spacing: -0.04rem;
+}
+
+.material-symbols-outlined {
+  font-variation-settings:
+    'FILL' 1,
+    'wght' 600,
+    'GRAD' 200,
+    'opsz' 24
+}

package/RediBreadCrumb/src/components/redi-bread-crumb/redi-bread-crumb.component.spec.ts

@@ -0,0 +1,23 @@
+import { ComponentFixture, TestBed } from '@angular/core/testing';
+
+import { RediBreadCrumbComponent } from './redi-bread-crumb.component';
+
+describe('BreadCrumbComponent', () => {
+  let component: RediBreadCrumbComponent;
+  let fixture: ComponentFixture<RediBreadCrumbComponent>;
+
+  beforeEach(async () => {
+    await TestBed.configureTestingModule({
+      imports: [RediBreadCrumbComponent]
+    })
+    .compileComponents();
+
+    fixture = TestBed.createComponent(RediBreadCrumbComponent);
+    component = fixture.componentInstance;
+    fixture.detectChanges();
+  });
+
+  it('should create', () => {
+    expect(component).toBeTruthy();
+  });
+});