@ca-plant-list/ca-plant-list 0.3.2 → 0.3.3

package/lib/taxa.js

@@ -1,8 +1,8 @@
 import { Config } from "./config.js";
-import { Taxon } from "./taxon.js";
 import { HTML } from "./html.js";
 import { CSV } from "./csv.js";
 import { RarePlants } from "./rareplants.js";
+import { ErrorLog, Taxon } from "./index.js";
 
 const FLOWER_COLORS = [
     { name: "white", color: "white" },
@@ -14,50 +14,65 @@ const FLOWER_COLORS = [
     { name: "purple", color: "purple" },
 ];
 
+/**
+ * @type {Object.<string,import("./index.js").TaxaCol>}
+ */
 const TAXA_LIST_COLS = {
     CESA: {
         title: "California",
-        data: ( t ) => RarePlants.getCESADescription( t.getCESA() )
+        data: (t) => RarePlants.getCESADescription(t.getCESA()),
     },
     COMMON_NAME: {
         title: "Common Name",
-        data: ( t ) => t.getCommonNames().join( ", " )
+        data: (t) => t.getCommonNames().join(", "),
     },
     CNPS_RANK: {
         title: "CNPS Rank",
-        data: ( t ) => HTML.getToolTip( HTML.textElement( "span", t.getRPIRankAndThreat() ), t.getRPIRankAndThreatTooltip() )
+        data: (t) =>
+            HTML.getToolTip(
+                HTML.textElement("span", t.getRPIRankAndThreat()),
+                t.getRPIRankAndThreatTooltip()
+            ),
     },
     FESA: {
         title: "Federal",
-        data: ( t ) => RarePlants.getFESADescription( t.getFESA() )
+        data: (t) => RarePlants.getFESADescription(t.getFESA()),
     },
     SPECIES: {
         title: "Species",
-        data: ( t ) => t.getHTMLLink( true, true )
+        data: (t) => t.getHTMLLink(true, true),
     },
     SPECIES_BARE: {
         title: "Species",
-        data: ( t ) => t.getHTMLLink( true, false )
+        data: (t) => t.getHTMLLink(true, false),
     },
 };
 
-const DEFAULT_COLUMNS = [ TAXA_LIST_COLS.SPECIES, TAXA_LIST_COLS.COMMON_NAME ];
+const DEFAULT_COLUMNS = [TAXA_LIST_COLS.SPECIES, TAXA_LIST_COLS.COMMON_NAME];
 
 class FlowerColor {
-
     #color;
+    /** @type {Taxon[]} */
     #taxa = [];
 
-    constructor( color ) {
+    /**
+     * @param {string} color
+     */
+    constructor(color) {
         this.#color = color;
     }
 
-    addTaxon( taxon ) {
-        this.#taxa.push( taxon );
+    /**
+     * @param {Taxon} taxon
+     */
+    addTaxon(taxon) {
+        this.#taxa.push(taxon);
     }
 
-    getColorName( uc = false ) {
-        return uc ? ( this.#color[ 0 ].toUpperCase() + this.#color.substring( 1 ) ) : this.#color;
+    getColorName(uc = false) {
+        return uc
+            ? this.#color[0].toUpperCase() + this.#color.substring(1)
+            : this.#color;
     }
 
     getFileName() {
@@ -67,67 +82,100 @@ class FlowerColor {
     getTaxa() {
         return this.#taxa;
     }
-
 }
 
 class Taxa {
-
     #errorLog;
+    /** @type {Object<string,Taxon>} */
     #taxa = {};
+    /** @type {Object<string,FlowerColor>} */
     #flower_colors = {};
     #sortedTaxa;
     #synonyms = new Set();
     #isSubset;
 
-    constructor( inclusionList, errorLog, showFlowerErrors, taxaMeta = {}, taxonClass = Taxon, extraTaxa = [], extraSynonyms = [] ) {
-
-        this.#isSubset = ( inclusionList !== true );
+    /**
+     *
+     * @param {*} inclusionList
+     * @param {ErrorLog} errorLog
+     * @param {*} showFlowerErrors
+     * @param {*} taxaMeta
+     * @param {*} taxonClass
+     * @param {*} extraTaxa
+     * @param {*} extraSynonyms
+     */
+    constructor(
+        inclusionList,
+        errorLog,
+        showFlowerErrors,
+        taxaMeta = {},
+        taxonClass = Taxon,
+        extraTaxa = [],
+        extraSynonyms = []
+    ) {
+        this.#isSubset = inclusionList !== true;
 
         this.#errorLog = errorLog;
 
-        for ( const color of FLOWER_COLORS ) {
-            this.#flower_colors[ color.name ] = new FlowerColor( color.name );
+        for (const color of FLOWER_COLORS) {
+            this.#flower_colors[color.name] = new FlowerColor(color.name);
         }
 
         const dataDir = Config.getPackageDir() + "/data";
 
-        const taxaCSV = CSV.parseFile( dataDir, "taxa.csv" );
-        this.#loadTaxa( taxaCSV, inclusionList, taxaMeta, taxonClass, showFlowerErrors );
-        this.#loadTaxa( extraTaxa, inclusionList, taxaMeta, taxonClass, showFlowerErrors );
+        const taxaCSV = CSV.parseFile(dataDir, "taxa.csv");
+        this.#loadTaxa(
+            taxaCSV,
+            inclusionList,
+            taxaMeta,
+            taxonClass,
+            showFlowerErrors
+        );
+        this.#loadTaxa(
+            extraTaxa,
+            inclusionList,
+            taxaMeta,
+            taxonClass,
+            showFlowerErrors
+        );
 
         // Make sure everything in the inclusionList has been loaded.
-        for ( const name of Object.keys( inclusionList ) ) {
-            if ( !this.getTaxon( name ) ) {
-                this.#errorLog.log( name, "not found in taxon list" );
+        for (const name of Object.keys(inclusionList)) {
+            if (!this.getTaxon(name)) {
+                this.#errorLog.log(name, "not found in taxon list");
             }
         }
 
-        this.#sortedTaxa = Object.values( this.#taxa ).sort( ( a, b ) => a.getName().localeCompare( b.getName() ) );
-
-        const synCSV = CSV.parseFile( dataDir, "synonyms.csv" );
-        this.#loadSyns( synCSV, inclusionList );
-        this.#loadSyns( extraSynonyms, inclusionList );
+        this.#sortedTaxa = Object.values(this.#taxa).sort((a, b) =>
+            a.getName().localeCompare(b.getName())
+        );
 
+        const synCSV = CSV.parseFile(dataDir, "synonyms.csv");
+        this.#loadSyns(synCSV, inclusionList);
+        this.#loadSyns(extraSynonyms, inclusionList);
     }
 
-    static getHTMLTable( taxa, columns = DEFAULT_COLUMNS ) {
-
+    /**
+     * @param {Taxon[]} taxa
+     * @param {import("./index.js").TaxaCol[]} columns
+     */
+    static getHTMLTable(taxa, columns = DEFAULT_COLUMNS) {
         let html = "<table><thead>";
-        for ( const col of columns ) {
+        for (const col of columns) {
             const className = col.class;
             const atts = className ? { class: className } : {};
-            html += HTML.textElement( "th", col.title, atts );
+            html += HTML.textElement("th", col.title, atts);
         }
         html += "</thead>";
         html += "<tbody>";
 
-        for ( const taxon of taxa ) {
+        for (const taxon of taxa) {
             html += "<tr>";
-            for ( const col of columns ) {
-                const data = col.data( taxon );
+            for (const col of columns) {
+                const data = col.data(taxon);
                 const className = col.class;
                 const atts = className ? { class: className } : {};
-                html += HTML.wrap( "td", data, atts );
+                html += HTML.wrap("td", data, atts);
             }
             html += "</tr>";
         }
@@ -138,28 +186,37 @@ class Taxa {
         return html;
     }
 
-    getFlowerColor( name ) {
-        return this.#flower_colors[ name ];
+    /**
+     * @param {string} name
+     */
+    getFlowerColor(name) {
+        return this.#flower_colors[name];
     }
 
     static getFlowerColorNames() {
-        return FLOWER_COLORS.map( ( o ) => o.name );
+        return FLOWER_COLORS.map((o) => o.name);
     }
 
     static getFlowerColors() {
         return FLOWER_COLORS;
     }
 
-    getTaxon( name ) {
-        return this.#taxa[ name ];
+    /**
+     * @param {string} name
+     */
+    getTaxon(name) {
+        return this.#taxa[name];
     }
 
     getTaxonList() {
         return this.#sortedTaxa;
     }
 
-    hasSynonym( formerName ) {
-        return this.#synonyms.has( formerName );
+    /**
+     * @param {string} formerName
+     */
+    hasSynonym(formerName) {
+        return this.#synonyms.has(formerName);
     }
 
     /**
@@ -170,75 +227,95 @@ class Taxa {
         return this.#isSubset;
     }
 
-    #loadSyns( synCSV, inclusionList ) {
-        for ( const syn of synCSV ) {
-            const currName = syn[ "Current" ];
-            const taxon = this.getTaxon( currName );
-            if ( !taxon ) {
-                if ( inclusionList === true && !syn.Type ) {
+    /**
+     * @param {*} synCSV
+     * @param {*} inclusionList
+     */
+    #loadSyns(synCSV, inclusionList) {
+        for (const syn of synCSV) {
+            const currName = syn["Current"];
+            const taxon = this.getTaxon(currName);
+            if (!taxon) {
+                if (inclusionList === true && !syn.Type) {
                     // If including all taxa, note the error - the target is not defined, and this is not
                     // a synonym for a non-Jepson system.
-                    console.log( "synonym target not found: " + currName );
+                    console.log("synonym target not found: " + currName);
                 }
                 continue;
             }
-            const formerName = syn[ "Former" ];
-            this.#synonyms.add( formerName );
-            taxon.addSynonym( formerName, syn[ "Type" ] );
+            const formerName = syn["Former"];
+            this.#synonyms.add(formerName);
+            taxon.addSynonym(formerName, syn["Type"]);
         }
     }
 
-    #loadTaxa( taxaCSV, inclusionList, taxaMeta, taxonClass, showFlowerErrors ) {
-        for ( const row of taxaCSV ) {
-
-            const name = row[ "taxon_name" ];
+    /**
+     * @param {*} taxaCSV
+     * @param {*} inclusionList
+     * @param {*} taxaMeta
+     * @param {Taxon} taxonClass
+     * @param {boolean} showFlowerErrors
+     */
+    #loadTaxa(taxaCSV, inclusionList, taxaMeta, taxonClass, showFlowerErrors) {
+        for (const row of taxaCSV) {
+            const name = row["taxon_name"];
 
             let taxon_overrides = {};
-            if ( inclusionList !== true ) {
-                taxon_overrides = inclusionList[ name ];
-                if ( !taxon_overrides ) {
+            if (inclusionList !== true) {
+                taxon_overrides = inclusionList[name];
+                if (!taxon_overrides) {
                     continue;
                 }
             }
 
-            if ( this.#taxa[ name ] ) {
-                this.#errorLog.log( name, "has multiple entries" );
+            if (this.#taxa[name]) {
+                this.#errorLog.log(name, "has multiple entries");
             }
 
-            const status = taxon_overrides[ "status" ];
-            if ( status !== undefined ) {
-                row[ "status" ] = status;
+            const status = taxon_overrides["status"];
+            if (status !== undefined) {
+                row["status"] = status;
             }
-            const taxon = new taxonClass( row, taxaMeta[ name ] );
-            this.#taxa[ name ] = taxon;
+            const taxon = new taxonClass(row, taxaMeta[name]);
+            this.#taxa[name] = taxon;
             const colors = taxon.getFlowerColors();
-            if ( colors ) {
-                for ( const colorName of colors ) {
-                    const color = this.#flower_colors[ colorName ];
-                    if ( !color ) {
-                        throw new Error( "flower color \"" + colorName + "\" not found" );
+            if (colors) {
+                for (const colorName of colors) {
+                    const color = this.#flower_colors[colorName];
+                    if (!color) {
+                        throw new Error(
+                            'flower color "' + colorName + '" not found'
+                        );
                     }
-                    color.addTaxon( taxon );
+                    color.addTaxon(taxon);
                 }
             }
 
-            if ( showFlowerErrors ) {
+            if (showFlowerErrors) {
                 // Make sure flower colors/bloom times are present or not depending on taxon.
-                if ( taxon.shouldHaveFlowers() ) {
-                    if ( !colors || !taxon.getBloomStart() || !taxon.getBloomEnd() ) {
-                        this.#errorLog.log( name, "does not have all flower info" );
+                if (taxon.shouldHaveFlowers()) {
+                    if (
+                        !colors ||
+                        !taxon.getBloomStart() ||
+                        !taxon.getBloomEnd()
+                    ) {
+                        this.#errorLog.log(
+                            name,
+                            "does not have all flower info"
+                        );
                     }
                 } else {
-                    if ( colors || taxon.getBloomStart() || taxon.getBloomEnd() ) {
-                        this.#errorLog.log( name, "should not have flower info" );
+                    if (
+                        colors ||
+                        taxon.getBloomStart() ||
+                        taxon.getBloomEnd()
+                    ) {
+                        this.#errorLog.log(name, "should not have flower info");
                     }
                 }
             }
         }
-
     }
-
-
 }
 
-export { Taxa, TAXA_LIST_COLS };
+export { Taxa, TAXA_LIST_COLS };

package/lib/taxaloader.js

@@ -1,35 +1,48 @@
-import { CSV } from "./csv.js";
-import { Files } from "./files.js";
 import { GenericTaxaLoader } from "./generictaxaloader.js";
-import { Taxa } from "./taxa.js";
+import { CSV, Files, Taxa } from "./index.js";
 
 class TaxaLoader extends GenericTaxaLoader {
-
-    constructor( options ) {
-        super( options );
+    /**
+     * @param {*} options
+     */
+    constructor(options) {
+        super(options);
     }
 
+    /**
+     * @return {Promise<Taxa>}
+     */
     async loadTaxa() {
-        function getIncludeList( dataDir ) {
+        /**
+         *
+         * @param {string} dataDir
+         * @returns
+         */
+        function getIncludeList(dataDir) {
             // Read inclusion list.
             const includeFileName = "taxa_include.csv";
             const includeFilePath = dataDir + "/" + includeFileName;
-            if ( !Files.exists( includeFilePath ) ) {
-                console.log( includeFilePath + " not found; loading all taxa" );
+            if (!Files.exists(includeFilePath)) {
+                console.log(includeFilePath + " not found; loading all taxa");
                 return true;
             }
-            const includeCSV = CSV.parseFile( dataDir, includeFileName );
+            /**@type { import("./index.js").TaxonData[]} */
+            const includeCSV = CSV.parseFile(dataDir, includeFileName);
+            /** @type {Object<string,import("./index.js").TaxonData>} */
             const include = {};
-            for ( const row of includeCSV ) {
-                include[ row[ "taxon_name" ] ] = row;
+            for (const row of includeCSV) {
+                include[row["taxon_name"]] = row;
             }
             return include;
         }
 
         const options = this.getOptions();
-        return new Taxa( getIncludeList( options.datadir ), this.getErrorLog(), options[ "show-flower-errors" ] );
+        return new Taxa(
+            getIncludeList(options.datadir),
+            this.getErrorLog(),
+            options["show-flower-errors"]
+        );
     }
-
 }
 
-export { TaxaLoader };
+export { TaxaLoader };

package/lib/taxaprocessor.js

@@ -1,12 +1,11 @@
 import { TaxaLoader } from "./taxaloader.js";
 
 class TaxaProcessor {
-
     #options;
     #taxaLoaderClass;
     #taxaLoader;
 
-    constructor( options, taxaLoaderClass = TaxaLoader ) {
+    constructor(options, taxaLoaderClass = TaxaLoader) {
         this.#options = options;
         this.#taxaLoaderClass = taxaLoaderClass;
     }
@@ -23,14 +22,13 @@ class TaxaProcessor {
         return this.#taxaLoader.getTaxa();
     }
 
-    async process( commandRunner ) {
-        console.log( "loading data" );
-        this.#taxaLoader = new this.#taxaLoaderClass( this.#options );
+    async process(commandRunner) {
+        console.log("loading data");
+        this.#taxaLoader = new this.#taxaLoaderClass(this.#options);
         await this.#taxaLoader.load();
+        await commandRunner(this);
         this.#taxaLoader.writeErrorLog();
-        await commandRunner( this );
     }
-
 }
 
-export { TaxaProcessor };
+export { TaxaProcessor };