Ajout possibilité de tout stopper à la moindre erreur rencontrée par le parseur + suppression des noms de colonne vide pouvant être reçus.

package.json

@@ -1,6 +1,6 @@
 {
   "name": "freecsv2html",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "description": "Conversion of a csv file into an HTML code with selection lists, data sorting, etc.",
   "main": "index.js",
   "scripts": {

src/errors.js

@@ -4,7 +4,7 @@ module.exports =
     elementNotFound : "Aucun élément HTML n'a été trouvé ayant comme \"id\" : ",
     needDatasElt: "Merci de fournir un id valide pour l'élément où afficher les données.",
     needNaturalNumber: "Merci de fournir un nombre entier supérieur ou égal à zéro pour désigner chaque colonne.",
-    needUrl: "Merci de fournir l'url du fichier CSV à parser.",
+    needUrl: "Merci de fournir une url valide pour le fichier CSV à parser.",
     parserFail: "La lecture des données du fichier a échoué.",
     selectorFieldNotFound: "Au moins une des colonnes devant servir à filtrer les données n'existe pas dans le fichier.",
 };

src/freeCSV2HTML.ts

@@ -25,6 +25,7 @@ export class freeCSV2HTML
     public parseDatas: papaParseDatas[] = [];
     public parseErrors: papaParseErrors[] = [];
     public datasHTML: string = "";
+    public stopIfParseErrors : boolean = false;
 
     set datasViewElt(elt: domElement)
     {
@@ -48,18 +49,26 @@ export class freeCSV2HTML
     
     set datasSelectors(selectionElts: selectors[])
     {
+        this._datasSelectors=[]; // remise à zéro
         let checkContainerExist: HTMLElement|null;
         for(let i = 0; i < selectionElts.length; i++)
         {
             checkContainerExist=document.getElementById(selectionElts[i].id);
             if(checkContainerExist === null)
-                throw new Error(errors.elementNotFound+selectionElts[i].id);
+                console.error(errors.elementNotFound+selectionElts[i].id);
             else if(Number.isInteger( selectionElts[i].colCSV) === false ||  selectionElts[i].colCSV < 0)
-                throw new Error(errors.needNaturalNumber);
+                console.error(errors.needNaturalNumber);
             else
+            {
                 selectionElts[i].eltDOM=checkContainerExist;
+                this._datasSelectors.push(selectionElts[i]);
              }
-        this._datasSelectors=selectionElts;
+        }
+    }
+    
+    get datasSelectors() : selectors[] 
+    {
+            return this._datasSelectors;
     }
 
    public async parse():  Promise<any>
@@ -75,9 +84,17 @@ export class freeCSV2HTML
                     header: true,
                     complete: function(results :any)
                     {
-                        converter.parseMeta=results.meta;
                         converter.parseErrors=results.errors;
                         converter.parseDatas=results.data;
+                        // Attention, papaParse peut accepter un nom de colonne vide
+                        let realFields: string[]=[];
+                        for(let i in results.meta.fields)
+                        {
+                            if(results.meta.fields[i].trim() !== "")
+                                realFields.push(results.meta.fields[i]);
+                        }
+                        results.meta.fields=realFields;
+                        converter.parseMeta=results.meta;
                         resolve(true);
                     },
                     error:function(error :any)
@@ -99,18 +116,18 @@ export class freeCSV2HTML
              throw new Error(errors.needDatasElt);
         if(this._datasSourceUrl === "" )
             throw new Error(errors.needUrl);
+
         await this.parse();
         
         if(this.parseDatas.length === 0 || this.parseMeta!.fields === undefined) // je force avec "!", car l'existence de parseMeta certaine après parse().
-        {
+             throw new Error(errors.datasNotFound);
-            this._datasViewElt.eltDOM.innerHTML=errors.datasNotFound;
+        else if(this.stopIfParseErrors && this.parseErrors.length!==0)
-            return false;
+            console.error(this.parseErrors);
-        }
         else
         {
             let converter=this;
             // Affichage initial des données du fichier
-            this.datasHTML=this.createDatasHTML(this.parseMeta.fields, this.parseDatas);
+            this.datasHTML=this.createDatasHTML(this.parseMeta!.fields, this.parseDatas); 
             this._datasViewElt.eltDOM.innerHTML=this.datasHTML;
 
             // Si demandé, création des listes permettant de filter les données
@@ -120,11 +137,11 @@ export class freeCSV2HTML
                 let selectorsHTML : string [] = [];
                 for(let i in this._datasSelectors)
                 {
-                    if(this._datasSelectors[i].colCSV > (this.parseMeta.fields.length-1))
+                    if(this._datasSelectors[i].colCSV > (this.parseMeta!.fields.length-1))
                           throw new Error(errors.selectorFieldNotFound);
                     else
                     {
-                        let values=[], colName=this.parseMeta.fields[this._datasSelectors[i].colCSV];
+                        let values=[], colName=this.parseMeta!.fields[this._datasSelectors[i].colCSV];
                         for (let row in this.parseDatas)
                         {
                             if(values.indexOf(this.parseDatas[row][colName].trim()) === -1)

tests/datas/datas-errors2.csv

@@ -0,0 +1,14 @@
+Z (numéro atomique),Élément,Symbole,Famille,Abondance,,
+1,Hydrogène,H,Non-métal,1400000,dze,
+2,Hélium,He,Gaz noble,8,,
+3,Lithium,Li,Métal alcalin,20000,,
+4,Béryllium,Be,Métal alcalino-terreux,2800,,
+5,Bore,B,Métalloïde,10000,dd,dd
+6,Carbone,C,Non-métal,200000,,
+7,Azote,N,Non-métal,19000,,
+8,Oxygène,O,Non-métal,461000000,,
+9,Fluor,F,Halogène,585000,,
+10,Néon,Ne,Gaz noble,5,,
+11,Sodium,Na,Métal alcalin,23600000,,
+12,Magnésium,Mg,Métal alcalino-terreux,23300000,,
+13,Aluminium,Al,Métal pauvre,82300000,,

tests/freeCSV2HTMLSpec.ts

@@ -34,20 +34,27 @@ describe("freeCSV2HTML", () =>
             expect(() => { return converter.datasViewElt={ id:"datas" }; }).not.toThrowError();
         });
         
-        it("Doit générer une erreur s'il n'y a pas un élément dans la page pour chaque id fourni pour afficher un des sélecteurs.", () =>
+        it("Ne doit accepter que les sélecteurs pour lesquels un élément a été trouvé dans la page pour l'id fourni.", () =>
         {
-            expect(() =>{ return converter.datasSelectors=[{ colCSV:2, id:"selector2" },{ colCSV:3, id:"selector3" }]; }).toThrowError(errors.elementNotFound+"selector3");
+            converter.datasSelectors=[{ colCSV:2, id:"selector2" },{ colCSV:3, id:"selector3" }];
+            expect(converter.datasSelectors.length).toEqual(1);
+            expect(converter.datasSelectors[0].id).toEqual("selector2");
         });
         
-        it("Doit générer une erreur si tous les numéros de colonne des sélecteurs ne sont pas des nombres naturels.", () =>
+        it("Ne doit accepter que les sélecteurs pour lesquels les numéros de colonne fourrnis sont des nombres naturels.", () =>
         {
-            expect(() => { return converter.datasSelectors=[{ colCSV:2.3, id:"selector1" },{ colCSV:3, id:"selector2" }]; }).toThrowError(errors.needNaturalNumber);
+            converter.datasSelectors=[{ colCSV:2.3, id:"selector1" },{ colCSV:3, id:"selector2" }];
-            expect(() => { return converter.datasSelectors=[{ colCSV:2, id:"selector1" },{ colCSV:-1, id:"selector2" }]; }).toThrowError(errors.needNaturalNumber);
+            expect(converter.datasSelectors.length).toEqual(1);
+            expect(converter.datasSelectors[0].id).toEqual("selector2");
+            converter.datasSelectors=[{ colCSV:2, id:"selector1" },{ colCSV:-1, id:"selector2" }];
+            expect(converter.datasSelectors.length).toEqual(1);
+            expect(converter.datasSelectors[0].id).toEqual("selector1");
         });
 
-        it("Ne doit pas générer une erreur si toutes les informations fournies pour les sélecteurs sont correctes.", () =>
+        it("Doit accepter tous les sélecteurs si leurs informations sont valides.", () =>
         {
-            expect(() => { return converter.datasSelectors=[{ colCSV:0, id:"selector1" },{ colCSV:3, id:"selector2" }]; }).not.toThrowError();
+            converter.datasSelectors=[{ colCSV:0, id:"selector1" },{ colCSV:3, id:"selector2" }];
+            expect(converter.datasSelectors.length).toEqual(2);
         });
         
         it("Doit générer une erreur si l'url fournie pour le fichier de données est vide.", () =>
@@ -58,18 +65,11 @@ describe("freeCSV2HTML", () =>
 
     describe("Parsage du fichier et création du tableau de données", () =>
     {
-        it("Doit générer une erreur si au moins un des deux paramètres nécessaires au fonctionnement n'est pas fourni.", async () =>
-        {
-            await expectAsync( converter.run()).toBeRejectedWith(new Error(errors.needDatasElt));
-            converter.datasViewElt={ id:"datas" };
-            await expectAsync( converter.run()).toBeRejectedWith(new Error(errors.needUrl));
-        });
-        
         it("Doit générer une erreur si la lecture du fichier échoue.", async () =>
         {
             converter.datasViewElt={ id:"datas" };
             converter.datasSourceUrl="http://localhost:9876/datas/dontExist.csv";
-           await expectAsync( converter.parse()).toBeRejectedWith(new Error(errors.parserFail));
+           await expectAsync(converter.parse()).toBeRejectedWith(new Error(errors.parserFail));
         });
         
         it("Doit enregistrer la liste des erreurs rencontrées en parsant le fichier.", async () =>
@@ -80,6 +80,14 @@ describe("freeCSV2HTML", () =>
             expect(converter.parseErrors.length).toBeGreaterThan(0);
         });
         
+        it("Ne doit garder que les noms de colonne non vides.", async () =>
+        {
+            converter.datasViewElt={ id:"datas" };
+            converter.datasSourceUrl="http://localhost:9876/datas/datas-errors2.csv";
+            await converter.parse();
+            expect(converter.parseMeta.fields.length).toEqual(5);
+        });
+        
         it("Ne doit enregistrer aucune erreur de lecture si le fichier est ok.", async () =>
         {
             converter.datasViewElt={ id:"datas" };
@@ -88,20 +96,46 @@ describe("freeCSV2HTML", () =>
             expect(converter.parseErrors.length).toEqual(0);
         });
 
+        it("Doit générer une erreur si au moins un des deux paramètres nécessaires au fonctionnement n'est pas fourni.", async () =>
+        {
+            await expectAsync(converter.run()).toBeRejectedWith(new Error(errors.needDatasElt));
+            converter.datasViewElt={ id:"datas" };
+            await expectAsync(converter.run()).toBeRejectedWith(new Error(errors.needUrl));
+        });
+        
         it("Ne doit pas générer d'erreur si les deux paramètres fournis sont ok.", async () =>
         {
             converter.datasViewElt={ id:"datas" };
             converter.datasSourceUrl="http://localhost:9876/datas/datas1.csv";
-            await expectAsync( converter.run()).toBeResolved();
+            await expectAsync(converter.run()).toBeResolved();
         }); 
 
-        it("Doit afficher une erreur dans la page si aucune donnée n'a été trouvée dans le fichier.", async () =>
+        it("Doit générer une erreur si aucune donnée n'a été trouvée dans le fichier et ne rien afficher dans l'emplacement prévu pour les données.", async () =>
         {
             converter.datasViewElt={ id:"datas" };
             converter.datasSourceUrl="http://localhost:9876/datas/nodatas.csv";
+            await expectAsync(converter.run()).toBeRejectedWith(new Error(errors.datasNotFound));
+            let txtDatasViewsElt=document.getElementById("datas").innerHTML;
+            expect(txtDatasViewsElt).toEqual("");
+        });
+        
+        it("Si la moindre erreur est rencontrée durant la parsage et que cela est demandé, ne rien afficher dans l'emplacement prévu pour les données.", async () =>
+        {
+            converter.datasViewElt={ id:"datas" };
+            converter.datasSourceUrl="http://localhost:9876/datas/datas-errors1.csv";
+            converter.stopIfParseErrors=true;
             await converter.run();
             let txtDatasViewsElt=document.getElementById("datas").innerHTML;
-            expect(txtDatasViewsElt).toEqual(errors.datasNotFound);
+            expect(txtDatasViewsElt).toEqual("");
+        });
+        
+        it("Sauf si cela est demandé, même si des erreurs sont rencontrées durant la parsage, les données trouvées dans le fichier seront affichées.", async () =>
+        {
+            converter.datasViewElt={ id:"datas" };
+            converter.datasSourceUrl="http://localhost:9876/datas/datas-errors1.csv";
+            await converter.run();
+            let txtDatasViewsElt=document.getElementById("datas").innerHTML;
+            expect(txtDatasViewsElt).not.toEqual("");
         });
 
         it("Doit afficher un tableau correspondant aux données du fichier csv", async () =>