@ca-plant-list/ca-plant-list 0.3.6 → 0.4.0

package/lib/index.js

@@ -1,58 +1,30 @@
-/**
- * @typedef {{
- * bloom_end:string;
- * bloom_start:string;
- * calrecnum:string;
- * CESA:string;
- * CRPR:string;
- * "common name":string;
- * FESA:string;
- * flower_color:string;
- * GRank:string;
- * "inat id":string;
- * "jepson id":string;
- * life_cycle:"annual"|"perennial"|undefined
- * SRank:string;
- * status:string;
- * "RPI ID":string;
- * taxon_name:string}} TaxonData
- */
-
 import { BasePageRenderer } from "./basepagerenderer.js";
-import { CommandProcessor } from "./commandprocessor.js";
-import { CommandAndTaxaProcessor } from "./commandandtaxaprocessor.js";
 import { Config } from "./config.js";
 import { CSV } from "./csv.js";
 import { ErrorLog } from "./errorlog.js";
 import { Exceptions } from "./exceptions.js";
 import { Families } from "./families.js";
 import { Files } from "./files.js";
-import { GenericTaxaLoader } from "./generictaxaloader.js";
 import { HTML } from "./html.js";
 import { Jekyll } from "./jekyll.js";
 import { PlantBook } from "./ebook/plantbook.js";
+import { Program } from "./program.js";
 import { Taxa } from "./taxa.js";
-import { TaxaLoader } from "./taxaloader.js";
-import { TaxaProcessor } from "./taxaprocessor.js";
 import { Taxon, TAXA_COLNAMES } from "./taxon.js";
 
 export {
     BasePageRenderer,
-    CommandProcessor,
-    CommandAndTaxaProcessor,
     Config,
     CSV,
     ErrorLog,
     Exceptions,
     Families,
     Files,
-    GenericTaxaLoader,
     HTML,
     Jekyll,
     PlantBook,
+    Program,
     Taxa,
-    TaxaLoader,
-    TaxaProcessor,
     TAXA_COLNAMES,
     Taxon,
 };

package/lib/jekyll.js

@@ -4,40 +4,68 @@ import { SiteGenerator } from "./sitegenerator.js";
 const FRONT_DELIM = "---";
 
 class Jekyll extends SiteGenerator {
-
-    constructor( baseDir ) {
-        super( baseDir );
+    /**
+     * @param {string} baseDir
+     */
+    constructor(baseDir) {
+        super(baseDir);
     }
 
-    static getFrontMatter( atts ) {
-        const lines = [ FRONT_DELIM ];
-        for ( const [ k, v ] of Object.entries( atts ) ) {
-            lines.push( k + ": \"" + v + "\"" );
+    /**
+     * @param {Object<string,string>} atts
+     */
+    static getFrontMatter(atts) {
+        const lines = [FRONT_DELIM];
+        for (const [k, v] of Object.entries(atts)) {
+            lines.push(k + ': "' + v + '"');
         }
-        if ( !atts.layout ) {
-            lines.push( "layout: default" );
+        if (!atts.layout) {
+            lines.push("layout: default");
         }
-        lines.push( FRONT_DELIM );
-        return lines.join( "\n" ) + "\n";
+        lines.push(FRONT_DELIM);
+        return lines.join("\n") + "\n";
     }
 
-    static hasInclude( baseDir, path ) {
-        return Files.exists( baseDir + "/_includes/" + path );
+    /**
+     * @param {string} baseDir
+     * @param {string} path
+     */
+    static hasInclude(baseDir, path) {
+        return Files.exists(baseDir + "/_includes/" + path);
     }
 
-    static include( path ) {
+    /**
+     * @param {string} path
+     */
+    static include(path) {
         // This works for .md includes; should have conditional logic to detect other types.
-        return "{% capture my_include %}{% include " + path + " %}{% endcapture %}{{ my_include | markdownify }}";
+        return (
+            "{% capture my_include %}{% include " +
+            path +
+            " %}{% endcapture %}{{ my_include | markdownify }}"
+        );
     }
 
-    static writeInclude( baseDir, path, data ) {
-        Files.write( baseDir + "/_includes/" + path, data );
+    /**
+     * @param {string} baseDir
+     * @param {string} path
+     * @param {string} data
+     */
+    static writeInclude(baseDir, path, data) {
+        Files.write(baseDir + "/_includes/" + path, data);
     }
 
-    writeTemplate( content, attributes, filename ) {
-        Files.write( Files.join( this.getBaseDir(), filename ), Jekyll.getFrontMatter( attributes ) + content );
+    /**
+     * @param {string} content
+     * @param {Object<string,string>} attributes
+     * @param {string} filename
+     */
+    writeTemplate(content, attributes, filename) {
+        Files.write(
+            Files.join(this.getBaseDir(), filename),
+            Jekyll.getFrontMatter(attributes) + content
+        );
     }
-
 }
 
-export { Jekyll };
+export { Jekyll };

package/lib/jepson.js

@@ -1,18 +1,17 @@
-import { HTML, HTML_OPTIONS } from "./html.js";
+import { HTML } from "./html.js";
 
 class Jepson {
-
-    static getEFloraLink( id ) {
-
+    /**
+     * @param {string} id
+     */
+    static getEFloraLink(id) {
         return HTML.getLink(
             "https://ucjeps.berkeley.edu/eflora/eflora_display.php?tid=" + id,
             "Jepson eFlora",
             {},
-            HTML_OPTIONS.OPEN_NEW
+            true
         );
-
     }
-
 }
 
-export { Jepson };
+export { Jepson };

package/lib/markdown.js

@@ -1,18 +1,22 @@
 import markdownIt from "markdown-it";
-import { Files } from "@ca-plant-list/ca-plant-list";
+import { Files } from "./files.js";
 
 class Markdown {
+    static #md = new markdownIt({ xhtmlOut: true });
 
-    static #md = new markdownIt( { xhtmlOut: true } );
-
-    static fileToHTML( filePath ) {
-        return this.strToHTML( Files.read( filePath ) );
+    /**
+     * @param {string} filePath
+     */
+    static fileToHTML(filePath) {
+        return this.strToHTML(Files.read(filePath));
     }
 
-    static strToHTML( str ) {
-        return this.#md.render( str );
+    /**
+     * @param {string} str
+     */
+    static strToHTML(str) {
+        return this.#md.render(str);
     }
-
 }
 
-export { Markdown };
+export { Markdown };

package/lib/pagerenderer.js

@@ -1,84 +1,144 @@
-import { Files, Taxa, HTML } from "@ca-plant-list/ca-plant-list";
-import { TAXA_LIST_COLS } from "./taxa.js";
 import { PageTaxon } from "./web/pagetaxon.js";
 import { RarePlants } from "./rareplants.js";
 import { BasePageRenderer } from "./basepagerenderer.js";
 import { GenericPage } from "./genericpage.js";
-
-const ENDANGERED_COLS = [ TAXA_LIST_COLS.SPECIES, TAXA_LIST_COLS.COMMON_NAME, TAXA_LIST_COLS.CESA, TAXA_LIST_COLS.FESA ];
-const RPI_COLUMNS = [ TAXA_LIST_COLS.SPECIES_BARE, TAXA_LIST_COLS.COMMON_NAME, TAXA_LIST_COLS.CNPS_RANK ];
+import { Files } from "./files.js";
+import { HTML } from "./html.js";
+import { HTMLTaxon, TAXA_LIST_COLS } from "./htmltaxon.js";
+
+const ENDANGERED_COLS = [
+    TAXA_LIST_COLS.SPECIES,
+    TAXA_LIST_COLS.COMMON_NAME,
+    TAXA_LIST_COLS.CESA,
+    TAXA_LIST_COLS.FESA,
+];
+const RPI_COLUMNS = [
+    TAXA_LIST_COLS.SPECIES_BARE,
+    TAXA_LIST_COLS.COMMON_NAME,
+    TAXA_LIST_COLS.CNPS_RANK,
+];
 
 class PageRenderer extends BasePageRenderer {
+    /**
+     * @param {string} outputDir
+     * @param {Config} config
+     * @param {Taxa} taxa
+     */
+    static render(outputDir, config, taxa) {
+        super.renderBasePages(outputDir, taxa);
 
-    static render( outputDir, config, taxa ) {
-
-        super.render( outputDir, taxa );
-
-        this.renderLists( outputDir, config, taxa );
+        this.renderLists(outputDir, config, taxa);
 
         const taxonList = taxa.getTaxonList();
-        for ( const taxon of taxonList ) {
-            new PageTaxon( outputDir, config, taxon ).render();
+        for (const taxon of taxonList) {
+            new PageTaxon(outputDir, config, taxon).render();
         }
-
     }
 
-    static renderLists( outputDir, config, taxa ) {
-
-        function getListArray( listInfo, attributes = {}, columns ) {
-
+    /**
+     * @param {string} outputDir
+     * @param {Config} config
+     * @param {Taxa} taxa
+     */
+    static renderLists(outputDir, config, taxa) {
+        /**
+         * @param {ListInfo[]} listInfo
+         * @param {Object<string,string>} attributes
+         * @param {TaxaCol[]} [columns]
+         * @returns {string}
+         */
+        function getListArray(listInfo, attributes = {}, columns) {
             const listArray = [];
-            for ( const list of listInfo ) {
+            for (const list of listInfo) {
                 const listTaxa = [];
                 const calfloraTaxa = [];
                 const iNatTaxa = [];
-                for ( const taxon of taxa.getTaxonList() ) {
-                    if ( list.include( taxon ) ) {
-                        listTaxa.push( taxon );
-                        calfloraTaxa.push( taxon.getCalfloraName() );
-                        iNatTaxa.push( taxon.getINatName() );
+                for (const taxon of taxa.getTaxonList()) {
+                    if (list.include(taxon)) {
+                        listTaxa.push(taxon);
+                        calfloraTaxa.push(taxon.getCalfloraName());
+                        iNatTaxa.push(taxon.getINatName());
                     }
                 }
 
-                if ( listTaxa.length === 0 ) {
+                if (listTaxa.length === 0) {
                     continue;
                 }
 
-                Files.write( outputDir + "/calflora_" + list.filename + ".txt", calfloraTaxa.join( "\n" ) );
-                Files.write( outputDir + "/inat_" + list.filename + ".txt", iNatTaxa.join( "\n" ) );
+                Files.write(
+                    outputDir + "/calflora_" + list.filename + ".txt",
+                    calfloraTaxa.join("\n")
+                );
+                Files.write(
+                    outputDir + "/inat_" + list.filename + ".txt",
+                    iNatTaxa.join("\n")
+                );
 
                 const cols = columns ? columns : list.columns;
-                new PageTaxonList( outputDir, list.name, list.filename ).render( listTaxa, cols );
+                new PageTaxonList(outputDir, list.name, list.filename).render(
+                    listTaxa,
+                    cols
+                );
 
                 // Check for sublists.
-                const subListHTML = list.listInfo ? getListArray( list.listInfo, { class: "indent" }, cols ) : "";
-
-                listArray.push( HTML.getLink( "./" + list.filename + ".html", list.name ) + " (" + listTaxa.length + ")" + subListHTML );
+                const subListHTML = list.listInfo
+                    ? getListArray(list.listInfo, { class: "indent" }, cols)
+                    : "";
+
+                listArray.push(
+                    HTML.getLink("./" + list.filename + ".html", list.name) +
+                        " (" +
+                        listTaxa.length +
+                        ")" +
+                        subListHTML
+                );
             }
 
-            return renderList( listArray, attributes );
+            return renderList(listArray, attributes);
         }
 
-        function renderList( listsHTML, attributes = {} ) {
-            return HTML.wrap( "ul", HTML.arrayToLI( listsHTML ), attributes );
+        /**
+         * @param {string[]} listsHTML
+         * @param {Object<string,string>} attributes
+         */
+        function renderList(listsHTML, attributes = {}) {
+            return HTML.wrap("ul", HTML.arrayToLI(listsHTML), attributes);
         }
 
-        function renderSection( title, listsHTML ) {
-            let html = "<div class=\"section\">";
-            html += HTML.textElement( "h2", title );
+        /**
+         * @param {string} title
+         * @param {string} listsHTML
+         */
+        function renderSection(title, listsHTML) {
+            let html = '<div class="section">';
+            html += HTML.textElement("h2", title);
             html += listsHTML;
             html += "</div>";
             return html;
         }
 
+        /** @typedef {{name:string,filename:string,include:function(Taxon):boolean,columns?:TaxaCol[],listInfo?:ListInfo[]}} ListInfo */
+        /** @type {{title:string,listInfo:ListInfo[]}[]} */
         const sections = [
             {
                 title: "All Species",
                 listInfo: [
-                    { name: config.getLabel( "native", "Native" ), filename: "list_native", include: ( t ) => t.isNative() },
-                    { name: config.getLabel( "introduced", "Introduced" ), filename: "list_introduced", include: ( t ) => !t.isNative() },
-                    { name: "All Plants", filename: "list_all", include: () => true },
-                ]
+                    {
+                        name: config.getLabel("native", "Native"),
+                        filename: "list_native",
+                        include: (t) => t.isNative(),
+                    },
+                    {
+                        name: config.getLabel("introduced", "Introduced"),
+                        filename: "list_introduced",
+                        include: (t) => !t.isNative(),
+                    },
+                    {
+                        name: "All Plants",
+                        filename: "list_all",
+                        include: () => true,
+                    },
+                ],
             },
             {
                 title: "Rare Plants",
@@ -86,101 +146,121 @@ class PageRenderer extends BasePageRenderer {
                     {
                         name: "CNPS Ranked Plants",
                         filename: "list_rpi",
-                        include: ( t ) => t.getRPIRank() !== undefined,
+                        include: (t) => t.getRPIRank() !== undefined,
                         columns: RPI_COLUMNS,
                         listInfo: [
                             {
-                                name: RarePlants.getRPIRankDescription( "1A" ),
+                                name: RarePlants.getRPIRankDescription("1A"),
                                 filename: "list_rpi_1a",
-                                include: ( t ) => t.getRPIRank() === "1A",
+                                include: (t) => t.getRPIRank() === "1A",
                             },
                             {
-                                name: RarePlants.getRPIRankDescription( "1B" ),
+                                name: RarePlants.getRPIRankDescription("1B"),
                                 filename: "list_rpi_1b",
-                                include: ( t ) => t.getRPIRank() === "1B",
+                                include: (t) => t.getRPIRank() === "1B",
                             },
                             {
-                                name: RarePlants.getRPIRankDescription( "2A" ),
+                                name: RarePlants.getRPIRankDescription("2A"),
                                 filename: "list_rpi_2a",
-                                include: ( t ) => t.getRPIRank() === "2A",
+                                include: (t) => t.getRPIRank() === "2A",
                             },
                             {
-                                name: RarePlants.getRPIRankDescription( "2B" ),
+                                name: RarePlants.getRPIRankDescription("2B"),
                                 filename: "list_rpi_2b",
-                                include: ( t ) => t.getRPIRank() === "2B",
+                                include: (t) => t.getRPIRank() === "2B",
                             },
                             {
-                                name: RarePlants.getRPIRankDescription( "3" ),
+                                name: RarePlants.getRPIRankDescription("3"),
                                 filename: "list_rpi_3",
-                                include: ( t ) => t.getRPIRank() === "3",
+                                include: (t) => t.getRPIRank() === "3",
                             },
                             {
-                                name: RarePlants.getRPIRankDescription( "4" ),
+                                name: RarePlants.getRPIRankDescription("4"),
                                 filename: "list_rpi_4",
-                                include: ( t ) => t.getRPIRank() === "4",
+                                include: (t) => t.getRPIRank() === "4",
                             },
-                        ]
+                        ],
                     },
                     {
                         name: "Endangered Species",
                         filename: "list_endangered",
-                        include: ( t ) => ( t.getCESA() || t.getFESA() ),
+                        include: (t) =>
+                            t.getCESA() !== undefined ||
+                            t.getFESA() !== undefined,
                         columns: ENDANGERED_COLS,
                     },
-                ]
+                ],
             },
         ];
 
-        let html = "<div class=\"wrapper\">";
-        for ( const section of sections ) {
+        let html = '<div class="wrapper">';
+        for (const section of sections) {
+            const listHTML = getListArray(section.listInfo);
 
-            const listHTML = getListArray( section.listInfo, section.listInfo.columns );
-
-            if ( listHTML.length > 0 ) {
-                html += renderSection( section.title, listHTML );
+            if (listHTML.length > 0) {
+                html += renderSection(section.title, listHTML);
             }
-
         }
-        html += renderSection( "Taxonomy", renderList( [ HTML.getLink( "./list_families.html", "Plant Families" ) ] ) );
+        html += renderSection(
+            "Taxonomy",
+            renderList([HTML.getLink("./list_families.html", "Plant Families")])
+        );
 
         html += "</div>";
 
         // Write lists to includes directory so it can be inserted into pages.
-        Files.write( outputDir + "/_includes/plantlists.html", html );
-
+        Files.write(outputDir + "/_includes/plantlists.html", html);
     }
-
 }
 
 class PageTaxonList extends GenericPage {
-
-    constructor( outputDir, title, baseName ) {
-        super( outputDir, title, baseName );
+    /**
+     * @param {string} outputDir
+     * @param {string} title
+     * @param {string} baseName
+     */
+    constructor(outputDir, title, baseName) {
+        super(outputDir, title, baseName);
     }
 
-    render( taxa, columns ) {
-
+    /**
+     *
+     * @param {Taxon[]} taxa
+     * @param {TaxaCol[]|undefined} columns
+     */
+    render(taxa, columns) {
         let html = this.getDefaultIntro();
 
-        html += "<div class=\"wrapper\">";
+        html += '<div class="wrapper">';
 
-        html += "<div class=\"section\">";
-        html += Taxa.getHTMLTable( taxa, columns );
+        html += '<div class="section">';
+        html += HTMLTaxon.getTaxaTable(taxa, columns);
         html += "</div>";
 
-        html += "<div class=\"section\">";
-        html += HTML.textElement( "h2", "Download" );
+        html += '<div class="section">';
+        html += HTML.textElement("h2", "Download");
         html += "<ul>";
-        html += "<li>" + HTML.getLink( "./calflora_" + this.getBaseFileName() + ".txt", "Calflora List" ) + "</li>";
-        html += "<li>" + HTML.getLink( "./inat_" + this.getBaseFileName() + ".txt", "iNaturalist List" ) + "</li>";
+        html +=
+            "<li>" +
+            HTML.getLink(
+                "./calflora_" + this.getBaseFileName() + ".txt",
+                "Calflora List"
+            ) +
+            "</li>";
+        html +=
+            "<li>" +
+            HTML.getLink(
+                "./inat_" + this.getBaseFileName() + ".txt",
+                "iNaturalist List"
+            ) +
+            "</li>";
         html += "</ul>";
         html += "</div>";
 
         html += "</div>";
 
-        this.writeFile( html );
-
+        this.writeFile(html);
     }
 }
 
-export { PageRenderer };
+export { PageRenderer };

package/lib/plants/glossary.js

@@ -1,38 +1,39 @@
-import { Config, Files } from "@ca-plant-list/ca-plant-list";
+import { Config } from "../config.js";
+import { Files } from "../files.js";
 
 class Glossary {
-
     #srcPath;
+    /** @type {GlossaryEntry[]} */
     #srcEntries = [];
 
     constructor() {
-
         this.#srcPath = Config.getPackageDir() + "/data/glossary";
 
         // Find all entries in the glossary directory.
-        const entries = Files.getDirEntries( this.#srcPath ).sort();
-        for ( const entry of entries ) {
-            this.#srcEntries.push( new GlossaryEntry( this.#srcPath, entry ) );
+        const entries = Files.getDirEntries(this.#srcPath).sort();
+        for (const entry of entries) {
+            this.#srcEntries.push(new GlossaryEntry(this.#srcPath, entry));
         }
-
     }
 
     getEntries() {
         return this.#srcEntries;
     }
-
 }
 
 class GlossaryEntry {
-
     #srcPath;
     #fileName;
     #term;
 
-    constructor( srcPath, fileName ) {
+    /**
+     * @param {string} srcPath
+     * @param {string} fileName
+     */
+    constructor(srcPath, fileName) {
         this.#srcPath = srcPath;
         this.#fileName = fileName;
-        this.#term = fileName.split( "." )[ 0 ];
+        this.#term = fileName.split(".")[0];
     }
 
     getHTMLFileName() {
@@ -40,13 +41,12 @@ class GlossaryEntry {
     }
 
     getMarkdown() {
-        return Files.read( this.#srcPath + "/" + this.#fileName );
+        return Files.read(this.#srcPath + "/" + this.#fileName);
     }
 
     getTermName() {
         return this.#term;
     }
-
 }
 
-export { Glossary };
+export { Glossary };

package/lib/program.js

@@ -0,0 +1,47 @@
+import { Command } from "commander";
+import { Files } from "./files.js";
+import { CSV } from "./csv.js";
+
+class Program {
+    /**
+     * @param {string} dataDir
+     */
+    static 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");
+            return true;
+        }
+        const includeCSV = CSV.parseFile(dataDir, includeFileName);
+        /** @type {Object<string,TaxonData>} */
+        const include = {};
+        for (const row of includeCSV) {
+            include[row["taxon_name"]] = row;
+        }
+        return include;
+    }
+
+    static getProgram() {
+        const program = new Command();
+        program
+            .option(
+                "-d, --datadir <dir>",
+                "The directory containing plant data.",
+                "./data"
+            )
+            .option(
+                "-f, --show-flower-errors",
+                "Include missing flower color/flowering time in the error log when loading taxa."
+            )
+            .option(
+                "-o, --outputdir <dir>",
+                "The directory to which output should be written.",
+                "./output"
+            );
+        return program;
+    }
+}
+
+export { Program };