ngx-redi-core 0.0.13 → 1.0.0

package/RediGrid/ng-package.json

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

package/RediGrid/public-api.ts

@@ -0,0 +1,3 @@
+
+export * from "./src/modules/redi-grid.module";
+export * from "./src/modules/redi-grid/redi-grid.component"

package/RediGrid/src/modules/redi-grid/redi-grid.component.css

@@ -0,0 +1,101 @@
+.container {
+    border: 1px solid #f4f4f4;
+    overflow: auto;
+    max-height: 90vh;
+    padding: 0px;
+    box-shadow: rgba(0, 0, 0, 0.24) 0px 3px 8px;
+}
+
+thead {
+    text-align: center;
+    color: #f9f9f9;
+    height: 1.9em;
+}
+
+thead>tr>th {
+    border-right: solid 1px white;
+    font-weight: 400;
+    background-color: #a5a5a5;
+}
+
+tbody {
+    text-align: center;
+    cursor: cell;
+    color: #717171
+}
+
+input {
+    text-align: center;
+    color: #717171;
+    border: none;
+    background: transparent;
+    outline: 0;
+    width: 100%;
+    padding: 0px;
+}
+
+tbody>tr>td:focus-within {
+    border: solid 1px #468b51bd;
+    background: #9fd0fb6b;
+
+}
+
+tbody>tr:nth-child(even) {
+    background-color: #f4f4f4;
+}
+
+tbody>tr:hover {
+    background-color: #cddce9;
+}
+
+tbody>tr>td:last-child,
+thead>tr>th:last-child {
+    border-right: solid 0px;
+}
+
+tbody>tr:last-child{
+    border-bottom: solid 1px #e1e1e1;
+}
+
+td {
+    padding: 3px;
+    height: 1.5em;
+    border-right: solid 1px #e1e1e1;
+    border-style: groove;
+    min-width: 2em;
+}
+
+table {
+    width: 100%;
+    -webkit-user-select: none;
+    -ms-user-select: none;
+    user-select: none;
+    overflow: auto;
+}
+
+thead tr th {
+    position: sticky;
+    top: 0;
+}
+
+cdk-virtual-scroll-viewport {
+    min-height: 400px;
+}
+
+::-webkit-scrollbar { 
+    width: 6px; 
+} 
+ 
+::-webkit-scrollbar-track { 
+    background: #cccccc; 
+    margin-top: 2.6em; 
+    margin-bottom: 1.4em; 
+} 
+ 
+::-webkit-scrollbar-thumb { 
+    background: #bc2337bf; 
+} 
+ 
+::-webkit-scrollbar-thumb:hover { 
+    background: #bc2337; 
+}

package/RediGrid/src/modules/redi-grid/redi-grid.component.html

@@ -0,0 +1,21 @@
+<div class="container">
+  <cdk-virtual-scroll-viewport #scrollViewport itemSize="25">
+    <table>
+      <thead>
+        <tr>
+          <th [style.top]="inverseOfTranslation" *ngIf="enumerate">
+          <th [style.top]="inverseOfTranslation" *ngFor="let col of dataGrid.cols">{{col.value}}</th>
+        </tr>
+      </thead>
+      <tbody>
+        <tr *cdkVirtualFor="let row of dataGrid.rows;let rowNum = index">
+          <td *ngIf="enumerate">{{rowNum+1}}</td>
+          <td *ngFor="let cell of row; let colNum=index">
+            <input *ngIf="editable" type="text" [value]="cell.value" (focusout)="updateData(rowNum,colNum,$event)" />
+            {{!editable?cell.value:''}}
+          </td>
+        </tr>
+      </tbody>
+    </table>
+  </cdk-virtual-scroll-viewport>
+</div>

package/RediGrid/src/modules/redi-grid/redi-grid.component.spec.ts

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

package/RediGrid/src/modules/redi-grid/redi-grid.component.ts

@@ -0,0 +1,67 @@
+import { CdkVirtualScrollViewport } from '@angular/cdk/scrolling';
+import { AfterViewInit, Component, Input, ViewChild } from '@angular/core';
+
+@Component({
+  selector: 'mf-spreadsheet',
+  templateUrl: './redi-grid.component.html',
+  styleUrls: ['./redi-grid.component.css']
+})
+export class RediGridComponent implements AfterViewInit {
+  @Input()
+  dataGrid: DataGrid;
+
+  @Input()
+  enumerate: boolean;
+
+  @Input()
+  editable: boolean;
+
+  constructor() {
+    this.dataGrid = {} as DataGrid;
+    this.enumerate = false;
+    this.editable = false;
+  }
+  ngAfterViewInit(): void {
+    if (this.dataGrid) {
+      this.editable = this.dataGrid.editable || false;
+      this.enumerate = this.dataGrid.enumerate || false;
+    }
+  }
+
+  @ViewChild(CdkVirtualScrollViewport, { static: false })
+  public viewPort!: CdkVirtualScrollViewport;
+  public get inverseOfTranslation(): string {
+    if (!this.viewPort || !this.viewPort["_renderedContentOffset"]) {
+      return "-0px";
+    }
+    let offset = this.viewPort["_renderedContentOffset"];
+    return `-${offset}px`;
+  }
+
+  updateData(indexRow: number, indexCol: number, event: Event): void {
+    if (this.dataGrid && this.dataGrid.rows) {
+      let inputControl: HTMLInputElement = event.target as HTMLInputElement;
+      this.dataGrid.rows[indexRow][indexCol] = { value: inputControl.value };
+    }
+  }
+}
+
+export interface Cell {
+  col?: number;
+  row?: number;
+  isValid?: boolean;
+  maxLength?: number;
+  value?: string;
+}
+export interface DataGrid {
+  cols: Array<Cell>;
+  rows: Array<Array<Cell>>;
+  enumerate?: boolean;
+  size?: Size;
+  editable?: boolean
+}
+
+export interface Size {
+  width?: number;
+  heigth?: number;
+}

package/RediGrid/src/modules/redi-grid.module.ts

@@ -0,0 +1,18 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { RediGridComponent } from './redi-grid/redi-grid.component';
+import { ScrollingModule } from '@angular/cdk/scrolling';
+
+
+
+@NgModule({
+  declarations: [RediGridComponent],
+  imports: [
+    CommonModule,
+    ScrollingModule
+  ],
+  exports:[
+    RediGridComponent
+  ]
+})
+export class RediGridModule { }

package/RediTable/ng-package.json

@@ -0,0 +1,10 @@
+
+{
+    "$schema": "../../../node_modules/ng-packagr/ng-package.schema.json",
+    "lib": {
+      "entryFile": "public-api.ts"
+    },
+    "allowedNonPeerDependencies": [
+        "@angular/material"
+    ]
+  }

package/RediTable/public-api.ts

@@ -0,0 +1,3 @@
+
+export * from "./src/modules/redi-table.module";
+export * from "./src/modules/redi-table/redi-table.component"

package/RediTable/src/modules/redi-table/redi-table.component.css

@@ -0,0 +1,101 @@
+.container{
+    display: grid;
+}
+
+tbody{
+    box-shadow: rgba(0, 0, 0, 0.24) 0px 3px 8px;
+}
+
+.section{
+    overflow: auto;
+    height: 300px;
+    background-color: white;
+    max-height: 90vh;
+    border: 1px solid #f4f4f4;
+}
+
+table {
+    width: 100%;
+    color: #676a6f;
+   
+    overflow: auto;
+    
+    padding: 0px;
+    background-color: #f7f7f7;
+}
+
+.odd {
+    background-color: #f4f4f4;
+
+    font-size: 1.05em;
+}
+
+.even {
+    background-color: white;
+}
+
+.odd,.even{
+    height: 2.5em;
+    cursor: pointer;
+}
+
+td.mat-cell{
+    border: 0px;
+    color: #676a6f;
+    font-size: 1.05em;
+}
+
+.odd:hover,
+.even:hover {
+    background-color: #cddce9;
+}
+
+th{
+    font-size: 1.2em;
+}
+tr.mat-header-row{
+    height: 2.55em;
+}
+
+input{
+    min-width: 250px;
+    border: solid 2px #dadada;
+    float: right;
+    margin-bottom: 8px;
+    outline: 0;
+    padding-right: 2em;
+}
+
+mat-icon{
+    float: right;
+    margin-left: -3em;
+    position: relative;
+    color:#676a6f ;
+    margin-top: 1px;
+}
+
+.visible{
+    display: contents;
+}
+
+.hidden{
+    display: none;
+}
+
+::-webkit-scrollbar { 
+    width: 6px; 
+} 
+ 
+::-webkit-scrollbar-track { 
+    background: #cccccc; 
+    margin-top: 2.6em; 
+    margin-bottom: 1.4em; 
+} 
+ 
+::-webkit-scrollbar-thumb { 
+    background: #bc2337bf; 
+} 
+ 
+::-webkit-scrollbar-thumb:hover { 
+    background: #bc2337; 
+}

package/RediTable/src/modules/redi-table/redi-table.component.html

@@ -0,0 +1,51 @@
+<div class="container">
+    <div *ngIf="enableFilter">
+        <mat-icon>search</mat-icon>
+        <input placeholder="Filtro" (keyup)="applyFilter($event)" />
+    </div>
+    <div class="section">
+        <table mat-table [dataSource]="dataSource" matSort>
+            <ng-container *ngIf="selectRows" matColumnDef="select">
+                <th mat-header-cell *matHeaderCellDef>
+                    <mat-checkbox (change)="$event ? toggleAllRows() : null"
+                        [checked]="dataTable.selection.hasValue() && isAllSelected()"
+                        [indeterminate]="dataTable.selection.hasValue() && !isAllSelected()"
+                        [aria-label]="checkboxLabel()">
+                    </mat-checkbox>
+                </th>
+                <td mat-cell *matCellDef="let row">
+                    <mat-checkbox (click)="$event.stopPropagation()"
+                        (change)="$event ? dataTable.selection.toggle(row) : null"
+                        [checked]="dataTable.selection.isSelected(row)" [aria-label]="checkboxLabel(row)">
+                    </mat-checkbox>
+                </td>
+            </ng-container>
+
+            <ng-container>
+                <ng-container [matColumnDef]="column.key" *ngFor="let column of colsEntities">
+                    <th mat-header-cell *matHeaderCellDef mat-sort-header [attr.disabled]="isSortActive()"> {{column.label ||
+                        column.key}} </th>
+                    <td mat-cell *matCellDef="let element"> {{element[column.key]}} </td>
+                </ng-container>
+            </ng-container>
+            <ng-container *ngIf="actions" matColumnDef="actions" stickyEnd>
+                <th mat-header-cell *matHeaderCellDef aria-label="row actions">&nbsp;</th>
+                <td mat-cell *matCellDef="let element">
+                    <button mat-icon-button color="primary" *ngFor="let action of dataTable.actions"
+                        (click)="action.action(element,dataSource)">
+                        <mat-icon>{{action.icon || 'apps'}}</mat-icon>
+                    </button>
+                </td>
+            </ng-container>
+
+            <tr mat-header-row *matHeaderRowDef="displayedColumns; sticky:true"></tr>
+            <tr mat-row *matRowDef="let row; columns: displayedColumns;let rowNum = index" [class.odd]="rowNum%2"
+                [class.even]="!(rowNum%2)"></tr>
+        </table>
+
+    </div>
+    <div [ngClass]="paginateData?'visible':'hidden'">
+        <mat-paginator [pageSizeOptions]="[5,10,20,50,100]" showFirstLastButtons aria-label="Seleccione una pagina">
+        </mat-paginator>
+    </div>
+</div>

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

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

package/RediTable/src/modules/redi-table/redi-table.component.ts

@@ -0,0 +1,173 @@
+import { SelectionModel } from '@angular/cdk/collections';
+import { AfterViewInit, Component, Input, OnChanges, SimpleChanges, ViewChild } from '@angular/core';
+import { MatPaginator } from '@angular/material/paginator';
+import { MatSort } from '@angular/material/sort';
+import { MatTableDataSource } from '@angular/material/table';
+
+@Component({
+  selector: 'redi-table',
+  templateUrl: './redi-table.component.html',
+  styleUrls: ['./redi-table.component.css']
+})
+export class RediTableComponent<T> implements AfterViewInit, OnChanges {
+  @Input()
+  public selectRows: boolean = false;
+
+  @Input()
+  public enableFilter: boolean = false;
+
+  @Input()
+  public paginateData: boolean = false;
+
+  @Input()
+  public sortData: boolean = false;
+
+  public actions: boolean = false;
+
+  @Input()
+  public dataTable: DataTable<T>;
+
+  public dataSource: MatTableDataSource<any>;
+
+  @ViewChild(MatSort) sort!: MatSort;
+  @ViewChild(MatPaginator) paginator!: MatPaginator;
+
+
+  constructor() {
+    this.dataTable = {} as DataTable<T>;
+    this.dataSource = new MatTableDataSource();
+    this.dataSource.data = [];
+  }
+
+  ngOnChanges(changes: SimpleChanges): void {
+    let changeSelectedRow = changes['selectRows'];
+    if (changeSelectedRow) {
+      if (changeSelectedRow.currentValue) {
+        this.displayedColumns.unshift('select');
+        this.dataTable.selection = new SelectionModel<any>(true, [])
+      } else {
+        const index = this.displayedColumns.indexOf('select');
+        if (index > -1) {
+          this.displayedColumns.splice(index, 1);
+        }
+      }
+    }
+
+    let changeFilter = changes['enableFilter'];
+    if (changeFilter && !changeFilter.currentValue) {
+      this.dataSource.filter = '';
+      if (this.paginateData) {
+        this.dataSource.paginator = this.paginator;
+      }
+      else {
+        this.dataSource.paginator = null;
+      }
+    }
+
+    let changePagination = changes['paginateData'];
+    if (changePagination) {
+      if (changePagination.currentValue) {
+        this.dataSource.paginator = this.paginator;
+      }
+      else {
+        this.dataSource.paginator = null;
+      }
+    }
+  }
+
+  displayedColumns: Array<string> = [];
+
+  colsEntities: Array<ColumnDefinition> = []
+
+  public applyFilter(event: Event) {
+    const filterValue = (event.target as HTMLInputElement).value;
+    this.dataSource.filter = filterValue.trim().toLowerCase();
+    if (this.dataSource.paginator) {
+      this.dataSource.paginator.firstPage();
+    }
+  }
+
+  ngAfterViewInit() {
+    if (this.dataTable) {
+      this.dataSource = new MatTableDataSource(this.dataTable.dataSource);
+
+      if (this.dataTable.colums &&
+        this.dataTable.colums.length > 0) {
+        this.colsEntities.push(...this.dataTable.colums);
+      }
+      else {
+        if (this.dataTable.dataSource.length) {
+          this.colsEntities.push(...Object.keys(this.dataTable.dataSource[0] as any).map(x => { return { key: x, label: x } as ColumnDefinition }))
+        }
+      }
+      this.displayedColumns.push(...this.colsEntities.map(item => { return item.key }));
+      this.actions = this.dataTable.actions && this.dataTable.actions.length > 0;
+      if (this.actions) {
+        this.displayedColumns.push('actions')
+      }
+      this.dataSource.sort = this.sort;
+    }
+    this.translatePaginator();
+  }
+
+  private translatePaginator() {
+    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 ? length / pageSize : 1}`;
+    }
+  }
+
+  isSortActive() {
+    if (!this.sortData) {
+      this.sort.direction = '';
+      this.sort
+    }
+    return !this.sortData
+  }
+
+  toggleAllRows() {
+    if (this.isAllSelected()) {
+      this.dataTable.selection.clear();
+      return;
+    }
+    this.dataTable.selection.select(...this.dataSource.data);
+  }
+
+  isAllSelected() {
+    const numSelected = this.dataTable.selection.selected.length;
+    const numRows = this.dataSource.data.length;
+    return numSelected === numRows;
+  }
+
+  checkboxLabel(row?: any): string {
+    if (!row) {
+      return `${this.isAllSelected() ? 'deselect' : 'select'} all`;
+    }
+    return `${this.dataTable.selection.isSelected(row) ? 'deselect' : 'select'} row ${row.position + 1}`;
+  }
+
+}
+
+export interface DataTable<T> {
+  dataSource: Array<T>;
+  colums: Array<ColumnDefinition>;
+  actions: Array<RowAction>;
+  selection: SelectionModel<T>;
+}
+
+export type fnRowAction = (itemRow?: any, dataSource?: MatTableDataSource<any>) => {};
+
+export interface RowAction {
+  icon: string;
+  action: fnRowAction;
+}
+
+export interface ColumnDefinition {
+  label: string;
+  key: string;
+}

package/RediTable/src/modules/redi-table.module.ts

@@ -0,0 +1,28 @@
+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';
+
+
+
+@NgModule({
+  declarations: [RediTableComponent],
+  imports: [
+    CommonModule,
+    MatPaginatorModule,
+    MatIconModule,
+    MatTableModule,
+    ScrollingModule,
+    MatCheckboxModule
+  ],
+  exports: [
+    RediTableComponent
+  ]
+})
+export class RediTableModule { }

package/Security/public-api.ts

@@ -0,0 +1,4 @@
+export * from "./src/modules/security.module";
+export * from "./src/modules/security-web-intercept/interceptors/redi-secure.interceptor"
+export * from "./src/modules/security-web-intercept/models/secure-factory.model"
+export * from "./src/modules/security-web-intercept/services/cifrado.service"

package/{src/lib/modules/interceptors/secure.interceptor.spec.ts → Security/src/modules/security-web-intercept/interceptors/redi-secure.interceptor.spec.ts}

@@ -1,16 +1,16 @@
 import { TestBed } from '@angular/core/testing';
 
-import { SecureInterceptor } from './secure.interceptor';
+import { RediSecureInterceptor } from './redi-secure.interceptor';
 
 describe('SecureInterceptor', () => {
   beforeEach(() => TestBed.configureTestingModule({
     providers: [
-      SecureInterceptor
+      RediSecureInterceptor
       ]
   }));
 
   it('should be created', () => {
-    const interceptor: SecureInterceptor = TestBed.inject(SecureInterceptor);
+    const interceptor: RediSecureInterceptor = TestBed.inject(RediSecureInterceptor);
     expect(interceptor).toBeTruthy();
   });
 });

package/{src/lib/modules/interceptors/secure.interceptor.ts → Security/src/modules/security-web-intercept/interceptors/redi-secure.interceptor.ts}

@@ -10,8 +10,8 @@ import {
 } from '@angular/common/http';
 import { Observable } from 'rxjs';
 import { map } from 'rxjs/operators';
-import { CifradoService } from '../secure/services/cifrado.service';
-import { TOKEN_SECURE } from '../secure/model/secure-factory.model';
+import { CifradoService } from '../services/cifrado.service';
+import { TOKEN_SECURE } from '../models/secure-factory.model';
 
 /** Request token para el contexto Http */
 export const REQUEST_TOKEN = new HttpContextToken<any>(() => { });
@@ -23,7 +23,7 @@ export const RESPONSE_TOKEN = new HttpContextToken<any>(() => { });
  * @decorator `@Injectable()`
  */
 @Injectable()
-export class SecureInterceptor implements HttpInterceptor {
+export class RediSecureInterceptor implements HttpInterceptor {
   constructor(private cifradoService: CifradoService) { }
 
   intercept(request: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> {
@@ -60,16 +60,13 @@ export class SecureInterceptor implements HttpInterceptor {
    */
   private cifrarRequest(request: HttpRequest<any>): HttpRequest<any> {
     let newRequest: HttpRequest<any> = request;
-    let requestDefinition = request.context.get(REQUEST_TOKEN);
-    if (requestDefinition) {
-      switch (request.method) {
-        case 'POST':
-          newRequest = request.clone({ body: this.cifrarDatos(request.body) });
-          break;
-        default:
-          newRequest = request.clone({ url: this.cifrarPeticionUrl(request) });
-          break;
-      }
+    switch (request.method) {
+      case 'POST':
+        newRequest = request.clone({ body: this.cifrarDatos(request.body) });
+        break;
+      default:
+        newRequest = request.clone({ url: this.cifrarPeticionUrl(request) });
+        break;
     }
     return newRequest;
   }

package/Security/src/modules/security.module.ts

@@ -0,0 +1,13 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+
+
+
+@NgModule({
+  declarations: [],
+  imports: [
+    CommonModule
+  ],
+  exports:[]
+})
+export class SecurityModule { }

package/index.ts

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

package/ng-package.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ngx-redi-core",
-  "version": "0.0.13",
+  "version": "1.0.0",
   "peerDependencies": {
     "@angular/common": "^15.2.0",
     "@angular/core": "^15.2.0"
@@ -8,5 +8,8 @@
   "dependencies": {
     "tslib": "^2.3.0"
   },
-  "sideEffects": false
+  "sideEffects": false,
+  "allowedNonPeerDependencies":[
+    "@angular/material"
+  ]
 }

package/public-api.ts

@@ -0,0 +1,5 @@
+/*
+ * Public API Surface of ngx-redi-core
+ */
+
+export const REDI_CORE = "ngx-redi-core";

package/tsconfig.lib.json

@@ -6,10 +6,7 @@
     "declaration": true,
     "declarationMap": true,
     "inlineSources": true,
-    "types": [],
-    "downlevelIteration": true,
-    "experimentalDecorators": true,
-    "emitDecoratorMetadata": true,
+    "types": []
   },
   "exclude": [
     "**/*.spec.ts"

package/src/lib/modules/secure/secure.module.ts

@@ -1,27 +0,0 @@
-import { NgModule } from '@angular/core';
-import { CommonModule } from '@angular/common';
-import { secure } from './model/secure-factory.model';
-
-
-
-@NgModule({
-  declarations: [],
-  imports: [
-    CommonModule
-  ],
-  exports:[
-  ]
-})
-export class SecureModule { }
-
-export function some() {
-  /**
-   * Función para la fabrica de decoradores de clases y propiedades
-   * @param target Target del decorador
-   * @param propertyKey Nombre de la propiedad
-   * @returns Function de devolución para la fabrica de decoradores
-   */
-  return function (target: any, propertyKey?: string) {
-  }
-}
-

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

@@ -1,23 +0,0 @@
-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({
-      declarations: [ NgxRediCoreComponent ]
-    })
-    .compileComponents();
-
-    fixture = TestBed.createComponent(NgxRediCoreComponent);
-    component = fixture.componentInstance;
-    fixture.detectChanges();
-  });
-
-  it('should create', () => {
-    expect(component).toBeTruthy();
-  });
-});

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

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

package/src/lib/ngx-redi-core.module.ts

@@ -1,16 +0,0 @@
-import { NgModule } from '@angular/core';
-import { NgxRediCoreComponent } from './ngx-redi-core.component';
-
-
-
-@NgModule({
-  declarations: [
-    NgxRediCoreComponent
-  ],
-  imports: [
-  ],
-  exports: [
-    NgxRediCoreComponent
-  ]
-})
-export class NgxRediCoreModule { }

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

@@ -1,16 +0,0 @@
-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/src/lib/ngx-redi-core.service.ts

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

package/src/public-api.ts

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