ngx-redi-core 0.0.0

package/projects/ngx-redi-core/RediTable/src/modules/redi-table/redi-table.component.html

@@ -0,0 +1,70 @@
+<!-- Contenedor principal del componente -->
+<div class="container">
+    <!-- Filtro de datos para la tabla -->
+    <div *ngIf="filtrarDatos">
+        <mat-icon class="icon"> search </mat-icon>
+        <input #filtroInput placeholder="Filtro" (keyup)="applyFilter(filtroInput.value)" />
+    </div>
+    <!-- Tabla de datos -->
+    <div class="section">
+        <table mat-table [dataSource]="dataSource" matSort>
+            <caption> RediTableComponent </caption>
+            <!-- Contenedor de selección -->
+            <ng-container *ngIf="seleccionarFilas" matColumnDef="select">
+                <!-- Encabezado de tabla con selección de registros -->
+                <th scope="col" mat-header-cell *matHeaderCellDef>
+                    <!-- controles de selección -->
+                    <mat-checkbox (change)="$event ? alternarSeleccion() : null"
+                        [checked]="dataTable.seleccion.hasValue() && todoSeleccionado()"
+                        [indeterminate]="dataTable.seleccion.hasValue() && !todoSeleccionado()">
+                    </mat-checkbox>
+                </th>
+                <!-- Selector de fila -->
+                <td mat-cell *matCellDef="let row">
+                    <mat-checkbox (change)="$event ? dataTable.seleccion.toggle(row) : null"
+                        [checked]="dataTable.seleccion.isSelected(row)" [aria-label]="validarEtiqueta(row)">
+                    </mat-checkbox>
+                </td>
+            </ng-container>
+            <!-- Ordenamiento de encabezados -->
+            <ng-container>
+                <ng-container [matColumnDef]="column.identificador" *ngFor="let column of datosColumna">
+                    <!-- Definición de encabezado por columna -->
+                    <th scope="col" mat-header-cell *matHeaderCellDef mat-sort-header
+                        [attr.disabled]="ordenamientoActivo()">
+                        {{column.etiqueta ||
+                        column.identificador}} </th>
+                    <!-- Creación de identificadores de tabla -->
+                    <td mat-cell *matCellDef="let element"> {{element[column.identificador]}} </td>
+                </ng-container>
+            </ng-container>
+            <!-- Definición de acciones  -->
+            <ng-container *ngIf="verAcciones()" matColumnDef="actions" stickyEnd>
+                <th scope="col" mat-header-cell *matHeaderCellDef aria-label="row actions">&nbsp;</th>
+                <!-- Definición de acciones por fila -->
+                <td mat-cell *matCellDef="let element">
+                    <!-- Configuración de botones de acción -->
+                    <button mat-icon-button color="primary" *ngFor="let action of dataTable.acciones"
+                        (click)="action?.emiter?.emit({target:element,source:dataSource})"
+                        [disabled]="deshabilitarAccion(action,element)">
+                        <!-- Icono dinámico de la acción -->
+                        <mat-icon [ngClass]="deshabilitarAccion(action,element) ? 'disabled-button' : ''">
+                            {{action.icono || 'apps'}}
+                        </mat-icon>
+                    </button>
+                </td>
+            </ng-container>
+            <!-- Definición de columnas -->
+            <tr mat-header-row *matHeaderRowDef="columnas; sticky:true"></tr>
+            <!-- Estilizados alternado de filas -->
+            <tr mat-row *matRowDef="let row; columns: columnas;let rowNum = index" [class.odd]="rowNum%2"
+                [class.even]="!(rowNum%2)" (click)="onRowSelect(row)"></tr>
+        </table>
+    </div>
+    <!-- Paginador de datos -->
+    <div [ngClass]="paginar ? 'visible' : 'hidden'">
+        <!-- Configuración de Paginador -->
+        <mat-paginator [pageSizeOptions]="[5,10,20,50,100]" showFirstLastButtons aria-label="Seleccione una pagina">
+        </mat-paginator>
+    </div>
+</div>

package/projects/ngx-redi-core/RediTable/src/modules/redi-table/redi-table.component.spec.ts

@@ -0,0 +1,162 @@
+import { ComponentFixture, TestBed } from '@angular/core/testing';
+import { RediTableComponent } from './redi-table.component';
+import { RediTableModule } from '../redi-table.module';
+
+import { CUSTOM_ELEMENTS_SCHEMA, Component, SimpleChange } from '@angular/core';
+
+import { MatPaginatorModule } from '@angular/material/paginator';
+import { MatIconModule } from '@angular/material/icon';
+import { MatTableModule } from '@angular/material/table';
+import { ScrollingModule } from '@angular/cdk/scrolling';
+import { MatCheckboxModule } from '@angular/material/checkbox';
+
+import { CommonModule } from '@angular/common';
+
+import { BrowserAnimationsModule } from '@angular/platform-browser/animations';
+
+import { DataTable } from '../../models/interfaces/data-table';
+import { ColumnDefinition } from '../../models/interfaces/column-definition';
+import { RowAction } from '../../models/interfaces/row-action';
+import { SelectionModel } from '@angular/cdk/collections';
+import { MatSort } from '@angular/material/sort';
+
+describe('RediTableComponent', () => {
+  let component: RediTableComponent<Pais>;
+  let fixture: ComponentFixture<RediTableComponent<Pais>>;
+
+  interface Pais {
+    id: string;
+    nombre: string;
+    iso: string;
+    fechaAlta: string;
+  }
+
+  beforeEach(async () => {
+    await TestBed.configureTestingModule({
+      declarations: [RediTableComponent],
+      schemas: [CUSTOM_ELEMENTS_SCHEMA],
+      imports: [
+        CommonModule,
+        MatPaginatorModule,
+        MatIconModule,
+        MatTableModule,
+        ScrollingModule,
+        MatCheckboxModule,
+        BrowserAnimationsModule]
+    })
+      .compileComponents();
+    fixture = TestBed.createComponent(RediTableComponent<Pais>);
+    component = fixture.componentInstance;
+    component.dataTable = {
+      dataSource: [
+        { id: "01", nombre: "México", iso: "MX", fechaAlta: "13/10/2021" } as Pais,
+        { id: "02", nombre: "Estados Unidos", iso: "EU", fechaAlta: "13/10/2021" } as Pais,
+        { id: "03", nombre: "El Salvador", iso: "SV", fechaAlta: "13/10/2021" } as Pais,
+        { id: "04", nombre: "Guatemala", iso: "GT", fechaAlta: "22/10/2021" } as Pais,
+        { id: "05", nombre: "Puerto Rico", iso: "PR", fechaAlta: "15/10/2021" } as Pais,
+        { id: "06", nombre: "República de Cuba", iso: "CU", fechaAlta: "15/10/2021" } as Pais,
+        { id: "07", nombre: "Venezuela", iso: "VE", fechaAlta: "13/10/2021" } as Pais,
+        { id: "08", nombre: "Colombia", iso: "COL", fechaAlta: "22/10/2021" } as Pais,
+        { id: "09", nombre: "Argentina", iso: "ARG", fechaAlta: "15/10/2021" } as Pais,
+        { id: "10", nombre: "Belice", iso: "BZ", fechaAlta: "15/10/2021" } as Pais
+      ],
+      columnas: [{ identificador: 'id', etiqueta: 'ID' } as ColumnDefinition,
+      { identificador: 'nombre', etiqueta: 'Nombre' } as ColumnDefinition,
+      { identificador: 'iso', etiqueta: 'ISO' } as ColumnDefinition,
+      { identificador: 'fechaAlta', etiqueta: 'Fecha de alta' } as ColumnDefinition],
+      acciones: [
+        {
+          icono: 'delete_outline',
+          accion: (itemRow, dataSource) => {
+            dataSource?.data.splice(dataSource?.data.indexOf(itemRow), 1);
+            dataSource?._updateChangeSubscription()
+          }
+        } as RowAction,
+        {
+          icono: 'edit',
+          accion: (itemRow, dataSource) => {
+            console.log(dataSource)
+          }
+        } as RowAction],
+        seleccion: new SelectionModel<Pais>(true, [])
+    } as DataTable<Pais>;
+    fixture.detectChanges();
+  });
+
+  it('should create', () => {
+    expect(component).toBeTruthy();
+  });
+
+  it('cambio de estados', () => {
+    component.paginar = true;
+    component.ngOnChanges({ paginar: new SimpleChange(false, component.paginar, true) });
+    fixture.detectChanges();
+
+    component.filtrarDatos = true;
+    component.ngOnChanges({ filtrarDatos: new SimpleChange(false, component.filtrarDatos, true) });
+    fixture.detectChanges();
+
+    component.filtrarDatos = false;
+    component.ngOnChanges({ filtrarDatos: new SimpleChange(true, component.filtrarDatos, false) });
+    fixture.detectChanges();
+
+    component.ordenarDatos = true;
+    component.ngOnChanges({ ordenarDatos: new SimpleChange(false, component.ordenarDatos, true) });
+    fixture.detectChanges();
+
+    component.seleccionarFilas = true;
+    component.ngOnChanges({ seleccionarFilas: new SimpleChange(false, component.seleccionarFilas, true) });
+    fixture.detectChanges();
+
+    component.seleccionarFilas = false;
+    component.ngOnChanges({ seleccionarFilas: new SimpleChange(true, component.seleccionarFilas, false) });
+    fixture.detectChanges();
+
+
+    component.paginar = false;
+    component.ngOnChanges({ paginar: new SimpleChange(true, component.paginar, false) });
+    fixture.detectChanges();
+    expect(component.paginar).toBe(false);
+
+    component.filtrarDatos = false;
+    component.ngOnChanges({ filtrarDatos: new SimpleChange(true, component.filtrarDatos, false) });
+    fixture.detectChanges();
+
+    component.ordenarDatos = false;
+    component.sort = {} as MatSort;
+    component.ngOnChanges({ ordenarDatos: new SimpleChange(true, component.ordenarDatos, false) });
+    fixture.detectChanges();
+  });
+
+  it('filtrar datos',()=>{
+    expect(component.applyFilter('Me'));
+
+    component.paginar = true;
+    component.ngOnChanges({ paginar: new SimpleChange(false, component.paginar, true) });
+    fixture.detectChanges();
+    expect(component.paginar).toBe(true);
+
+    expect(component.applyFilter('Me'));
+  });
+
+  it('seleccion de filas', () => {
+    expect(component.alternarSeleccion());
+    component.dataTable.seleccion.select(...component.dataTable.dataSource);
+    expect(component.alternarSeleccion());
+
+  });
+
+  
+  it('metodos en general', () => {
+    expect(component.validarEtiqueta(false));
+    component.dataTable.columnas=[];
+    expect(component.ngAfterViewInit())
+  });
+
+});
+
+
+interface Pais {
+  id: number;
+  nombre: string;
+}

package/projects/ngx-redi-core/RediTable/src/modules/redi-table/redi-table.component.ts

@@ -0,0 +1,322 @@
+/** Librerías angular */
+import { Component, EventEmitter, Input, OnChanges, OnInit, Output, SimpleChanges, ViewChild } from '@angular/core';
+import { MatPaginator } from '@angular/material/paginator';
+import { MatSort } from '@angular/material/sort';
+import { MatTableDataSource } from '@angular/material/table';
+import { SelectionModel } from '@angular/cdk/collections';
+
+/** Modelo */
+import { DataTable } from '../../models/interfaces/data-table';
+import { ColumnDefinition } from '../../models/interfaces/column-definition';
+import { CsvService } from 'ngx-redi-core/Helper';
+import { RowAction } from '../../models/interfaces/row-action';
+
+/**
+ * Componente que muestra los datos en una tabla
+ * @decorators ´@Component´
+ */
+@Component({
+  selector: 'redi-table',
+  templateUrl: './redi-table.component.html',
+  styleUrls: ['./redi-table.component.css']
+})
+export class RediTableComponent<T extends object> implements OnInit, OnChanges {
+  /**
+   * Propiedad que indica si se pueden seleccionar las filas
+   */
+  @Input()
+  public seleccionarFilas = false;
+
+  /**
+   * Propiedad que indica si se habilitan los filtros para la tabla
+   */
+  @Input()
+  public filtrarDatos = false;
+
+  /**
+   * Propiedad que indica si se paginan los datos
+   */
+  @Input()
+  public paginar = false;
+
+  /**
+   * Propiedad que indica si se habilita el ordenamiento de datos
+   */
+  @Input()
+  public ordenarDatos = false;
+
+  /**
+   * Datos y configuración de la tabla
+   */
+  @Input()
+  public dataTable: DataTable<T>;
+
+  /**
+   * Origen de datos para el MatTable
+   */
+  public dataSource: MatTableDataSource<T>;
+
+  /**
+   * Objeto de la vista para el ordenamiento
+   */
+  @ViewChild(MatSort) sort!: MatSort;
+
+  /**
+   * Objeto de la vista para la paginación
+   */
+  @ViewChild(MatPaginator) paginator!: MatPaginator;
+
+  /**
+  * Contiene las columnas que se mostraran en la tabla
+  */
+  public columnas: Array<string> = [];
+
+  /**
+   * Contiene los datos de las columnas
+   */
+  public datosColumna: Array<ColumnDefinition> = [];
+
+
+  /**
+   * Crea un nuevo componente Tabla
+   */
+  constructor(private csv: CsvService) {
+    this.dataTable = {
+      dataSource: [] as Array<T>,
+      acciones: [] as Array<RowAction<T>>
+    } as DataTable<T>;
+    this.dataSource = new MatTableDataSource();
+    this.dataSource.data = [];
+  }
+
+  /**
+  * Eventos que se ejecutan al inicias
+  */
+  ngOnInit() {
+    this.limpiarColumnas();
+    if (this.dataTable) {
+      this.dataSource = new MatTableDataSource(this.dataTable.dataSource);
+      this.construiDatosColumna();
+      this.mostrarColumnas();
+    }
+    this.inicializarPaginador();
+  }
+
+  /**
+   * Construye los datos de las columnas para la tabla
+   */
+  private construiDatosColumna() {
+    if (this.dataTable.columnas &&
+      this.dataTable.columnas.length > 0) {
+      this.datosColumna.push(...this.dataTable.columnas);
+    }
+    else {
+      if (this.dataTable.dataSource.length) {
+        this.datosColumna.push(...Object.keys(this.dataTable.dataSource[0])
+          .map(x => { return { identificador: x, etiqueta: x } as ColumnDefinition; }));
+      }
+    }
+  }
+
+  /**
+   * Activa las columnas que se van a mostrar
+   */
+  private mostrarColumnas() {
+    this.columnas.push(...this.datosColumna
+      .map(item => { return item.identificador; }));
+    if (this.dataTable?.acciones && this.verAcciones()) {
+      this.columnas.push('actions');
+    }
+    this.dataSource.sort = this.sort;
+  }
+
+  /**
+   * Método que ejecuta los cambios en la selección de filas
+   * @param currentValue - Valor actual
+   */
+  private changeSelection(currentValue: boolean): void {
+    if (currentValue) {
+      this.columnas.unshift('select');
+      this.dataTable.seleccion = this.dataTable.seleccion ?? new SelectionModel<T>(true, []);
+    } else {
+      const index = this.columnas.indexOf('select');
+      if (index > -1) {
+        this.columnas.splice(index, 1);
+      }
+    }
+  }
+
+  /**
+   * Método que valida los cambios en los datos de entrada
+   * @param changer - Cambios realizados en la vista
+   */
+  ngOnChanges(changes: SimpleChanges): void {
+    this.actualizarSeleccion(changes);
+    this.actualizarFiltro(changes);
+    this.actualizarPaginacion(changes);
+    this.actualizarDataTable(changes);
+  }
+
+  private actualizarSeleccion(cambios: SimpleChanges) {
+    const changeSelectedRow = cambios['seleccionarFilas'];
+    if (changeSelectedRow && this.dataTable) {
+      this.changeSelection(changeSelectedRow.currentValue);
+    }
+  }
+
+  private actualizarFiltro(cambios: SimpleChanges) {
+    const changeFilter = cambios['filtrarDatos'];
+    if (changeFilter && !changeFilter.currentValue) {
+      this.dataSource.filter = '';
+      this.reasignarPaginacion();
+    }
+  }
+
+  private reasignarPaginacion() {
+    if (this.paginar) {
+      this.dataSource.paginator = this.paginator;
+    }
+    else {
+      this.dataSource.paginator = null;
+    }
+  }
+
+  private actualizarPaginacion(cambios: SimpleChanges) {
+    const changePagination = cambios['paginar'];
+    if (changePagination) {
+      if (changePagination.currentValue) {
+        this.dataSource.paginator = this.paginator;
+      }
+      else {
+        this.dataSource.paginator = null;
+      }
+    }
+  }
+  private actualizarDataTable(cambios: SimpleChanges) {
+    const datos = cambios['dataTable'];
+    if (datos && datos.currentValue) {
+      this.dataTable = datos.currentValue;
+      this.ngOnInit();
+      this.reasignarPaginacion();
+      this.changeSelection(this.seleccionarFilas);
+      this.dataTable.acciones = this.dataTable.acciones ?? [];
+    }
+  }
+
+  /**
+   * Método que aplica el filtro a los datos de la tabla
+   * @param filtro - Evento de filtrado
+   */
+  public applyFilter(filtro: string) {
+    this.dataSource.filter = filtro.trim().toLowerCase();
+    if (this.dataSource.paginator) {
+      this.dataSource.paginator.firstPage();
+    }
+  }
+
+  private limpiarColumnas() {
+    this.datosColumna.splice(0);
+    this.columnas.splice(0);
+  }
+
+  /**
+   * Método que indica si se debe mostrar la columna de acciones
+   * @returns True si se debe mostrar las acciones
+   */
+  public verAcciones(): boolean {
+    return this.dataTable && this.dataTable.acciones && this.dataTable.acciones.length > 0;
+  }
+
+  /**
+   * Método que inicializa el Paginador
+   */
+  private inicializarPaginador() {
+    if (this.paginator) {
+      this.paginator._intl.itemsPerPageLabel = 'Elementos por pagina';
+      this.paginator._intl.firstPageLabel = 'Primera pagina';
+      this.paginator._intl.itemsPerPageLabel = 'Elementos por pagina';
+      this.paginator._intl.lastPageLabel = 'Ultima pagina';
+      this.paginator._intl.nextPageLabel = 'Siguiente pagina';
+      this.paginator._intl.previousPageLabel = 'Pagina anterior';
+      this.paginator._intl.getRangeLabel = (page: number, pageSize: number, length: number) => {
+        return `Pagina:${page + 1} de ${pageSize <= length ? Math.ceil(length / pageSize) : 1}`;
+      };
+    }
+  }
+
+  /**
+   * Indica si el ordenamiento esta activo
+   */
+  public ordenamientoActivo(): boolean {
+    if (!this.ordenarDatos && this.sort) {
+      this.sort.direction = '';
+    }
+    return !this.ordenarDatos;
+  }
+
+  /** Alterna la selección de registros de la tabla */
+  public alternarSeleccion() {
+    if (this.todoSeleccionado()) {
+      this.dataTable.seleccion.clear();
+      return;
+    }
+    this.dataTable.seleccion.select(...this.dataSource.data);
+  }
+
+  /**
+   * Indica si todo el contenido esta seleccionado
+   * @returns True si todo el contenido esta seleccionado
+   */
+  public todoSeleccionado(): boolean {
+    const numSelected = this.dataTable.seleccion.selected.length;
+    const numRows = this.dataSource.data.length;
+    return numSelected === numRows;
+  }
+
+  /**
+   * Obtiene el estado de la etiqueta de seleccionado
+   * @param fila - Fila que se validara
+   * @returns Estado de selección en modo texto
+   */
+  public validarEtiqueta(fila?: any): string {
+    if (!fila) {
+      return `${this.todoSeleccionado() ? 'deselect' : 'select'} all`;
+    }
+    return `${this.dataTable.seleccion.isSelected(fila) ? 'deselect' : 'select'} row ${Number(fila.position) + 1}`;
+  }
+
+
+  public descargarCsv(archivo: string, soloSeleccionados?: boolean) {
+    if (!soloSeleccionados) {
+      this.csv.descargarCsv(archivo, this.dataTable.dataSource);
+    }
+    else {
+      this.csv.descargarCsv(archivo, this.dataTable.seleccion.selected);
+    }
+  }
+
+  public onRowSelect(event: T) {
+    this.onRowClick.emit(event);
+  }
+
+  @Output()
+  public onRowClick = new EventEmitter<T>();
+
+
+  protected deshabilitarAccion(action: RowAction<T>, element: any) {
+    if (action.deshabilitar) {
+      return action.deshabilitar;
+    }
+    else if (action.desabilitarActionPorValores) {
+      const valor = element[action.desabilitarActionPorValores.columnaRef];
+      const valores = action.desabilitarActionPorValores.valoresADeshabilitar;
+
+      if (valores.length === 0) {
+        return false;
+      } else {
+        return valores.some(value => value === valor);
+      }
+    }
+    return false
+  }
+}

package/projects/ngx-redi-core/RediTable/src/modules/redi-table.module.ts

@@ -0,0 +1,32 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+
+
+import { MatPaginatorModule } from '@angular/material/paginator';
+import { MatIconModule } from '@angular/material/icon';
+import { MatTableModule } from '@angular/material/table';
+import { ScrollingModule } from '@angular/cdk/scrolling';
+import { MatCheckboxModule } from '@angular/material/checkbox';
+import { RediTableComponent } from './redi-table/redi-table.component';
+import { MatButtonModule } from '@angular/material/button';
+
+/**
+ * Modulo que contiene los componentes de la tabla
+ * @decorators ´@NgModule´
+ */
+@NgModule({
+  declarations: [RediTableComponent],
+  imports: [
+    CommonModule,
+    MatPaginatorModule,
+    MatIconModule,
+    MatTableModule,
+    ScrollingModule,
+    MatCheckboxModule,
+    MatButtonModule
+  ],
+  exports: [
+    RediTableComponent
+  ]
+})
+export class RediTableModule { }

package/projects/ngx-redi-core/ng-package.json

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

package/projects/ngx-redi-core/package.json

@@ -0,0 +1,12 @@
+{
+  "name": "ngx-redi-core",
+  "version": "0.0.1",
+  "peerDependencies": {
+    "@angular/common": "^17.2.0",
+    "@angular/core": "^17.2.0"
+  },
+  "dependencies": {
+    "tslib": "^2.3.0"
+  },
+  "sideEffects": false
+}

package/projects/ngx-redi-core/src/lib/ngx-redi-core.component.spec.ts

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

package/projects/ngx-redi-core/src/lib/ngx-redi-core.component.ts

@@ -0,0 +1,16 @@
+import { Component } from '@angular/core';
+
+@Component({
+  selector: 'lib-ngx-redi-core',
+  standalone: true,
+  imports: [],
+  template: `
+    <p>
+      ngx-redi-core works!
+    </p>
+  `,
+  styles: ``
+})
+export class NgxRediCoreComponent {
+
+}

package/projects/ngx-redi-core/src/lib/ngx-redi-core.service.spec.ts

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

package/projects/ngx-redi-core/src/lib/ngx-redi-core.service.ts

@@ -0,0 +1,9 @@
+import { Injectable } from '@angular/core';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class NgxRediCoreService {
+
+  constructor() { }
+}

package/projects/ngx-redi-core/src/public-api.ts

@@ -0,0 +1,6 @@
+/*
+ * Public API Surface of ngx-redi-core
+ */
+
+export * from './lib/ngx-redi-core.service';
+export * from './lib/ngx-redi-core.component';