ngx-redi-core 0.0.0-watch

package/esm2022/RediDragDrop/public-api.mjs

@@ -0,0 +1,5 @@
+export * from './src/modules/redi-drag-drop.module';
+export * from './src/modules/redi-drag-drop/redi-drag-drop.component';
+export * from './src/models/classes/proceso-archivo-csv';
+export * from './src/models/directives/drag-drop.directive';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL25neC1yZWRpLWNvcmUvUmVkaURyYWdEcm9wL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsY0FBYyxxQ0FBcUMsQ0FBQztBQUNwRCxjQUFjLHVEQUF1RCxDQUFDO0FBQ3RFLGNBQWMsMENBQTBDLENBQUM7QUFDekQsY0FBYyw2Q0FBNkMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIlxyXG5leHBvcnQgKiBmcm9tICcuL3NyYy9tb2R1bGVzL3JlZGktZHJhZy1kcm9wLm1vZHVsZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vc3JjL21vZHVsZXMvcmVkaS1kcmFnLWRyb3AvcmVkaS1kcmFnLWRyb3AuY29tcG9uZW50JztcclxuZXhwb3J0ICogZnJvbSAnLi9zcmMvbW9kZWxzL2NsYXNzZXMvcHJvY2Vzby1hcmNoaXZvLWNzdic7XHJcbmV4cG9ydCAqIGZyb20gJy4vc3JjL21vZGVscy9kaXJlY3RpdmVzL2RyYWctZHJvcC5kaXJlY3RpdmUnOyJdfQ==

package/esm2022/RediDragDrop/src/models/classes/proceso-archivo-csv.mjs

@@ -0,0 +1,132 @@
+/**
+ * Clase para procesar archivo csv según las necesidades.
+ * Produce datos con la estructura necesaria para el grid de datos o un arreglo de objetos.
+ */
+export class ProcesoArchivoCsv {
+    /**
+     *
+     * @param archivo El archivo csv a procesar
+     * @param datosParaDataGrid Especifica si los datos a generar son para el grid de datos
+     * @returns Una promesa con los datos en el formato especificado por el parámetro `datosParaGrid`
+     * @example
+     * Si la propiedad ´datosParaDataGrid = true´  devuelve ´{cols:[],rows:[]}´
+     * Si la propiedad ´datosParaDataGrid = false´  devuelve ´[{propiedad1:'valor',propiedad2:'valor2'}]´
+     */
+    procesar(archivo, datosParaDataGrid) {
+        return new Promise((resolve, reject) => {
+            const reader = new FileReader();
+            const item = archivo.item(0);
+            if (item) {
+                reader.readAsText(item, 'UTF-8');
+            }
+            reader.onload = () => {
+                const resultado = reader.result;
+                if ((resultado ?? '').toString().length === 0) {
+                    reject({
+                        mensaje: 'El archivo se encuentra vacío.'
+                    });
+                }
+                if (!reader.result?.toString().includes('�')) {
+                    const [informacion, columnas] = (this.generarInformacionColumnas(resultado, datosParaDataGrid));
+                    if (datosParaDataGrid) {
+                        resolve({ cols: columnas, rows: informacion });
+                    }
+                    else {
+                        resolve(informacion);
+                    }
+                }
+                else {
+                    reject({
+                        mensaje: 'El contenido del archivo no es válido.'
+                    });
+                }
+            };
+        });
+    }
+    /**
+     * Método que genera la información y columnas contenidas en el archivo ´csv´ seleccionado.
+     * @param datos El texto contenido en el archivo ´csv´.
+     * @param datosParaDataGrid Especifica si los datos a generar son para el grid de datos
+     * @returns Retorna una lista con la información y las columnas contenidas en el archivo ´csv´.
+     */
+    generarInformacionColumnas(datos, datosParaDataGrid) {
+        let informacion = [];
+        let columnas = [];
+        const lineasTextTotales = datos.split(/\n/);
+        columnas = lineasTextTotales[0].toString().split(',')
+            .map((str) => { return str.replace(/ /g, '-').trim(); }).filter((stringArchivos) => stringArchivos.length > 0);
+        const datosSeparados = lineasTextTotales.filter((valor, indice) => indice > 0 && valor.length > 0)
+            .map((dato) => {
+            if (dato.includes('"')) {
+                return this.generaColumnas(dato.trim());
+            }
+            else {
+                return dato.split(',');
+            }
+        });
+        if (datosParaDataGrid) {
+            columnas = columnas.map(columna => {
+                return { value: columna };
+            });
+            informacion = datosSeparados.map(dato => {
+                return dato.map(o => {
+                    return { value: o.replace(/\r/, '') };
+                });
+            });
+        }
+        else if (lineasTextTotales.length === 1) {
+            const objeto = {};
+            columnas.forEach(columna => objeto[`${columna}`] = '');
+            informacion.push(objeto);
+        }
+        else {
+            datosSeparados.forEach(dato => {
+                const objeto = {};
+                columnas.forEach((col, i) => {
+                    objeto[col] = dato[i].replace(/\r/, '');
+                });
+                informacion.push(objeto);
+            });
+        }
+        return [informacion, columnas];
+    }
+    /**
+     * Método para separa las filar del csv en columnas.
+     * @param fila La cadena a separar para generar las columnas
+     * @returns Arreglo con las columnas
+     */
+    generaColumnas(fila) {
+        const values = [];
+        const separadorTemporal = 'ꜛ';
+        let estaEnComillas = false;
+        let val = '';
+        fila = fila.replaceAll('""', separadorTemporal);
+        [...fila].forEach((letra, indice) => {
+            switch (letra) {
+                case ',':
+                    if (estaEnComillas) {
+                        val += letra;
+                    }
+                    else {
+                        values.push(val);
+                        val = '';
+                    }
+                    break;
+                case '"':
+                    if (estaEnComillas && indice + 1 < fila.length && fila[indice + 1] === '"') {
+                        val += '"';
+                    }
+                    else {
+                        estaEnComillas = !estaEnComillas;
+                    }
+                    break;
+                default:
+                    val += fila[indice];
+                    break;
+            }
+        });
+        values.push(val);
+        return values.map(columnas => columnas.replaceAll(separadorTemporal, '"'));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"proceso-archivo-csv.js","sourceRoot":"","sources":["../../../../../../../projects/ngx-redi-core/RediDragDrop/src/models/classes/proceso-archivo-csv.ts"],"names":[],"mappings":"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","sourcesContent":["/**\r\n * Clase para procesar archivo csv según las necesidades.\r\n * Produce datos con la estructura necesaria para el grid de datos o un arreglo de objetos.\r\n */\r\nexport class ProcesoArchivoCsv {\r\n  /**\r\n   * \r\n   * @param archivo El archivo csv a procesar\r\n   * @param datosParaDataGrid Especifica si los datos a generar son para el grid de datos\r\n   * @returns Una promesa con los datos en el formato especificado por el parámetro `datosParaGrid`\r\n   * @example\r\n   * Si la propiedad ´datosParaDataGrid = true´  devuelve ´{cols:[],rows:[]}´\r\n   * Si la propiedad ´datosParaDataGrid = false´  devuelve ´[{propiedad1:'valor',propiedad2:'valor2'}]´\r\n   */\r\n  public procesar(archivo: FileList, datosParaDataGrid: boolean) {\r\n    return new Promise((resolve, reject) => {\r\n      const reader: FileReader = new FileReader();\r\n      const item = archivo.item(0);\r\n      if (item) {\r\n        reader.readAsText(item, 'UTF-8');\r\n      }\r\n      reader.onload = () => {\r\n        const resultado = reader.result;\r\n        if ((resultado ?? '').toString().length === 0) {\r\n          reject({\r\n            mensaje: 'El archivo se encuentra vacío.'\r\n          });\r\n        }\r\n        if (!reader.result?.toString().includes('�')) {\r\n          const [informacion, columnas] = (this.generarInformacionColumnas((resultado as string), datosParaDataGrid));\r\n          if (datosParaDataGrid) {\r\n            resolve({ cols: columnas, rows: informacion });\r\n          }\r\n          else {\r\n            resolve(informacion);\r\n          }\r\n        } else {\r\n          reject({\r\n            mensaje: 'El contenido del archivo no es válido.'\r\n          });\r\n        }\r\n      };\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Método que genera la información y columnas contenidas en el archivo ´csv´ seleccionado.\r\n   * @param datos El texto contenido en el archivo ´csv´.\r\n   * @param datosParaDataGrid Especifica si los datos a generar son para el grid de datos\r\n   * @returns Retorna una lista con la información y las columnas contenidas en el archivo ´csv´.\r\n   */\r\n  private generarInformacionColumnas(datos: string, datosParaDataGrid: boolean): unknown[][] {\r\n    let informacion: unknown[] = [];\r\n    let columnas: unknown[] = [];\r\n    const lineasTextTotales = datos.split(/\\n/);\r\n\r\n    columnas = lineasTextTotales[0].toString().split(',')\r\n      .map((str: string) => { return str.replace(/ /g, '-').trim(); }).filter((stringArchivos: string) => stringArchivos.length > 0);\r\n\r\n    const datosSeparados = lineasTextTotales.filter((valor: string, indice: number) => indice > 0 && valor.length > 0)\r\n      .map((dato: string) => {\r\n        if (dato.includes('\"')) {\r\n          return this.generaColumnas(dato.trim());\r\n        }\r\n        else {\r\n          return dato.split(',');\r\n        }\r\n      });\r\n\r\n    if (datosParaDataGrid) {\r\n      columnas = columnas.map(columna => {\r\n        return { value: columna };\r\n      });\r\n      informacion = datosSeparados.map(dato => {\r\n        return dato.map(o => {\r\n          return { value: o.replace(/\\r/, '') };\r\n        });\r\n      });\r\n    } else\r\n      if (lineasTextTotales.length === 1) {\r\n        const objeto: Record<string, string> = {};\r\n        columnas.forEach(columna => objeto[`${columna}`] = '');\r\n        informacion.push(objeto);\r\n      } else {\r\n        datosSeparados.forEach(dato => {\r\n          const objeto: Record<string, string> = {};\r\n          columnas.forEach((col: unknown, i: number) => {\r\n            objeto[(col as string)] = dato[i].replace(/\\r/, '');\r\n          });\r\n          informacion.push(objeto);\r\n        });\r\n      }\r\n    return [informacion, columnas];\r\n  }\r\n\r\n  /**\r\n   * Método para separa las filar del csv en columnas.\r\n   * @param fila La cadena a separar para generar las columnas\r\n   * @returns Arreglo con las columnas\r\n   */\r\n  generaColumnas(fila: string) {\r\n    const values = [];\r\n    const separadorTemporal = 'ꜛ';\r\n    let estaEnComillas = false;\r\n    let val = '';\r\n    fila = fila.replaceAll('\"\"', separadorTemporal);\r\n    [...fila].forEach((letra: string, indice: number) => {\r\n      switch (letra) {\r\n        case ',':\r\n          if (estaEnComillas) {\r\n            val += letra;\r\n          } else {\r\n            values.push(val);\r\n            val = '';\r\n          }\r\n          break;\r\n        case '\"':\r\n          if (estaEnComillas && indice + 1 < fila.length && fila[indice + 1] === '\"') {\r\n            val += '\"';\r\n          }\r\n          else {\r\n            estaEnComillas = !estaEnComillas;\r\n          }\r\n          break;\r\n        default:\r\n          val += fila[indice];\r\n          break;\r\n      }\r\n    });\r\n    values.push(val);\r\n    return values.map(columnas => columnas.replaceAll(separadorTemporal, '\"'));\r\n  }\r\n}\r\n"]}

package/esm2022/RediDragDrop/src/models/directives/drag-drop.directive.mjs

@@ -0,0 +1,95 @@
+import { Directive, EventEmitter, Output, HostListener, HostBinding } from '@angular/core';
+import * as i0 from "@angular/core";
+export class DragDropDirective {
+    constructor() {
+        this.formato = 'dashed 2px #838383';
+        /**
+         * Evento que se emite una vez que se ha soltado el o los archivos en el componente.
+         */
+        this.fileDropped = new EventEmitter();
+        /**
+         * Evento que se emite una vez que se hace click al componente.
+         */
+        this.clicked = new EventEmitter();
+        /**
+         * Obtiene o establece el estilo del borde del componente.
+         */
+        this.border = this.formato;
+        /**
+         * Obtiene o establece el estilo del fondo del componente.
+         */
+        this.background = '';
+    }
+    /**
+     * El evento que cambia el borde y fondo del componente al arrastrar el archivo sobre el.
+     * @param event Evento
+     */
+    dragOver(event) {
+        this.border = 'dashed 2px #be1704';
+        this.background = '#be170421';
+        event.preventDefault();
+        event.stopPropagation();
+    }
+    /**
+     * El evento que restablece el borde y fondo del componente una vez que el archivo sale del área.
+     * @param event Evento
+     */
+    dragLeave(event) {
+        this.border = this.formato;
+        this.background = '';
+        event.preventDefault();
+        event.stopPropagation();
+    }
+    /**
+     * Evento que se ejecuta una vez que el archivo se suelta en el componente.
+     * @param event Evento
+     */
+    drop(event) {
+        this.border = this.formato;
+        this.background = '';
+        const files = event.dataTransfer?.files;
+        this.fileDropped.emit(files);
+        event.preventDefault();
+        event.stopPropagation();
+    }
+    /**
+     * Se emite el evento click en una vez se suelta el click (izquierdo)
+     * @param $event Evento
+     */
+    onClick(event) {
+        if (event.button === 0) {
+            this.clicked.emit();
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.4", ngImport: i0, type: DragDropDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.0.4", type: DragDropDirective, selector: "[dragDrop]", outputs: { fileDropped: "fileDropped", clicked: "clicked" }, host: { listeners: { "dragover": "dragOver($event)", "dragleave": "dragLeave($event)", "drop": "drop($event)", "mouseup": "onClick($event)" }, properties: { "style.border": "this.border", "style.background": "this.background" } }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.4", ngImport: i0, type: DragDropDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[dragDrop]'
+                }]
+        }], propDecorators: { fileDropped: [{
+                type: Output
+            }], clicked: [{
+                type: Output
+            }], border: [{
+                type: HostBinding,
+                args: ['style.border']
+            }], background: [{
+                type: HostBinding,
+                args: ['style.background']
+            }], dragOver: [{
+                type: HostListener,
+                args: ['dragover', ['$event']]
+            }], dragLeave: [{
+                type: HostListener,
+                args: ['dragleave', ['$event']]
+            }], drop: [{
+                type: HostListener,
+                args: ['drop', ['$event']]
+            }], onClick: [{
+                type: HostListener,
+                args: ['mouseup', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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