@ca-plant-list/ca-plant-list 0.0.0

package/lib/pagerenderer.js

@@ -0,0 +1,120 @@
+import * as fs from "node:fs";
+import { Families } from "./families.js";
+import { HTML } from "./html.js";
+import { Taxa } from "./taxa.js";
+import { HTMLPage } from "./htmlpage.js";
+import { PageTaxon } from "./pagetaxon.js";
+import { Config } from "./config.js";
+
+class PageRenderer {
+
+    static render( packageDir, outputDir ) {
+
+        // Copy static files
+        fs.rmSync( outputDir, { force: true, recursive: true } );
+        // First copy default Jekyll files from package.
+        fs.cpSync( packageDir + "/jekyll", outputDir, { recursive: true } );
+        // Then copy Jekyll files from current dir (which may override default files).
+        fs.cpSync( "jekyll", outputDir, { recursive: true } );
+
+        this.renderLists( outputDir );
+        this.renderTools( outputDir );
+
+        Families.renderPages( outputDir );
+
+        const taxa = Taxa.getTaxa();
+        for ( const taxon of taxa ) {
+            new PageTaxon( taxon ).render( outputDir );
+        }
+
+    }
+
+    static renderLists( outputDir ) {
+
+        const 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 },
+        ];
+
+        const listsHTML = [];
+        for ( const list of listInfo ) {
+            const taxa = [];
+            const calfloraTaxa = [];
+            const iNatTaxa = [];
+            for ( const taxon of Taxa.getTaxa() ) {
+                if ( list.include( taxon ) ) {
+                    taxa.push( taxon );
+                    calfloraTaxa.push( taxon.getCalfloraName() );
+                    iNatTaxa.push( taxon.getINatName() );
+                }
+            }
+
+            fs.writeFileSync( outputDir + "/calflora_" + list.filename + ".txt", calfloraTaxa.join( "\n" ) );
+            fs.writeFileSync( outputDir + "/inat_" + list.filename + ".txt", iNatTaxa.join( "\n" ) );
+
+            new PageTaxonList().render( outputDir, taxa, list.filename, list.name );
+            listsHTML.push( HTML.getLink( "./" + list.filename + ".html", list.name ) + " (" + taxa.length + ")" );
+        }
+
+        // Write lists to includes directory so it can be inserted into pages.
+        fs.writeFileSync( outputDir + "/_includes/plantlists.html", "<ul>" + HTML.arrayToLI( listsHTML ) + "</ul>" );
+
+    }
+
+    static renderTools( outputDir ) {
+
+        const commonNames = [];
+        for ( const taxon of Taxa.getTaxa() ) {
+            for ( const commonName of taxon.getCommonNames() ) {
+                commonNames.push( [ commonName, taxon.getName() ] );
+            }
+        }
+
+        const cnObj = {};
+        for ( const commonName of commonNames.sort( ( a, b ) => a[ 0 ].localeCompare( b[ 0 ] ) ) ) {
+            const normalizedName = commonName[ 0 ].toLowerCase().replaceAll( "-", " " ).replaceAll( "'", "" );
+            let data = cnObj[ normalizedName ];
+            if ( !data ) {
+                data = { cn: commonName[ 0 ], names: [] };
+                cnObj[ normalizedName ] = data;
+            }
+            data.names.push( commonName[ 1 ] );
+        }
+        fs.writeFileSync( outputDir + "/_includes/common_names.json", JSON.stringify( cnObj ) );
+
+
+    }
+
+}
+
+class PageTaxonList extends HTMLPage {
+
+    render( outputDir, taxa, baseName, title ) {
+
+        let html = this.getFrontMatter( title );
+
+        html += HTML.getElement( "h1", title );
+
+        html += "<div class=\"wrapper\">";
+
+        html += "<div class=\"section\">";
+        html += Taxa.getHTMLTable( taxa );
+        html += "</div>";
+
+        html += "<div class=\"section\">";
+        html += HTML.getElement( "h2", "Download" );
+        html += "<ul>";
+        html += "<li>" + HTML.getLink( "./calflora_" + baseName + ".txt", "Calflora List" ) + "</li>";
+        html += "<li>" + HTML.getLink( "./inat_" + baseName + ".txt", "iNaturalist List" ) + "</li>";
+        html += "</ul>";
+        html += "</div>";
+
+        html += "</div>";
+
+        this.writeFile( outputDir, baseName + ".html", html );
+
+    }
+}
+
+export { PageRenderer };

package/lib/pagetaxon.js

@@ -0,0 +1,154 @@
+import * as fs from "node:fs";
+import { HTML, HTML_OPTIONS } from "./html.js";
+import { Jepson } from "./jepson.js";
+import { HTMLPage } from "./htmlpage.js";
+import { Config } from "./config.js";
+
+class PageTaxon extends HTMLPage {
+
+    #taxon;
+
+    constructor( taxon ) {
+        super();
+        this.#taxon = taxon;
+    }
+
+    #getInfoLinks() {
+        const links = [];
+        const jepsonID = this.#taxon.getJepsonID();
+        if ( jepsonID ) {
+            links.push( Jepson.getEFloraLink( jepsonID ) );
+        }
+        const calRecNum = this.#taxon.getCalRecNum();
+        if ( calRecNum ) {
+            links.push(
+                HTML.getLink(
+                    "https://www.calflora.org/app/taxon?crn=" + calRecNum,
+                    "Calflora",
+                    {},
+                    HTML_OPTIONS.OPEN_NEW
+                )
+            );
+        }
+        const iNatID = this.#taxon.getINatID();
+        if ( iNatID ) {
+            links.push(
+                HTML.getLink(
+                    "https://www.inaturalist.org/taxa/" + iNatID,
+                    "iNaturalist",
+                    {},
+                    HTML_OPTIONS.OPEN_NEW
+                )
+            );
+        }
+        return links;
+    }
+
+    #getObsLinks() {
+        const links = [];
+        links.push(
+            HTML.getLink(
+                "https://www.calflora.org/entry/observ.html?track=m#srch=t&grezc=5&cols=b&lpcli=t&cc="
+                + Config.getConfigValue( "calflora", "counties" ).join( "!" ) + "&incobs=f&taxon="
+                + this.#taxon.getCalfloraName().replaceAll( " ", "+" ),
+                "Calflora",
+                {},
+                HTML_OPTIONS.OPEN_NEW
+            )
+        );
+        const iNatID = this.#taxon.getINatID();
+        if ( iNatID ) {
+            links.push(
+                HTML.getLink(
+                    "https://www.inaturalist.org/observations?project_id=" + Config.getConfigValue( "inat", "project" )
+                    + "&quality_grade=research&subview=map&taxon_id=" + iNatID,
+                    "iNaturalist",
+                    {},
+                    HTML_OPTIONS.OPEN_NEW
+                )
+            );
+        }
+
+        return links;
+    }
+
+    #getListSectionHTML( list, header, className ) {
+        let html = "";
+        if ( list.length > 0 ) {
+            html += "<div class=\"section " + className + "\">";
+            html += HTML.getElement( "h2", header );
+            html += "<ul>";
+            html += HTML.arrayToLI( list );
+            html += "</ul>";
+            html += "</div>";
+        }
+        return html;
+    }
+
+    #getRelatedTaxaLinks() {
+        const links = [];
+        const genus = this.#taxon.getGenus();
+        if ( genus ) {
+            const taxa = genus.getTaxa();
+            for ( const taxon of taxa ) {
+                if ( taxon.getName() !== this.#taxon.getName() ) {
+                    links.push(
+                        HTML.getLink(
+                            "./" + taxon.getFileName(),
+                            taxon.getName(),
+                            { class: taxon.getHTMLClassName() }
+                        )
+                    );
+                }
+            }
+        }
+        return links;
+    }
+
+    #getSynonyms() {
+        return this.#taxon.getSynonyms();
+    }
+
+    render( outputDir ) {
+
+        let html = this.getFrontMatter( this.#taxon.getName() );
+
+        html += HTML.getElement( "h1", this.#taxon.getName() );
+
+        html += "<div class=\"wrapper\">";
+
+        const cn = this.#taxon.getCommonNames();
+        if ( cn.length > 0 ) {
+            html += HTML.getElement( "div", cn.join( ", " ), { class: "section common-names" } );
+        }
+        html += HTML.getElement( "div", this.#taxon.getStatusDescription(), { class: "section" } );
+
+        const family = this.#taxon.getFamily();
+        html += HTML.getElement(
+            "div",
+            "Family: " + HTML.getLink( "./" + family.getFileName(), family.getName() ),
+            { class: "section" },
+            HTML_OPTIONS.NO_ESCAPE
+        );
+
+        html += "</div>";
+
+        const introName = "intros/" + this.#taxon.getFileName( "md" );
+        if ( fs.existsSync( "./jekyll/_includes/" + introName ) ) {
+            html += HTML.getElement( "div", "{% capture my_include %}{% include " + introName + "%}{% endcapture %}{{ my_include | markdownify }}" );
+        }
+
+        html += "<div class=\"wrapper\">";
+        html += this.#getListSectionHTML( this.#getInfoLinks(), "Information", "info" );
+        html += this.#getListSectionHTML( this.#getObsLinks(), "Observations", "obs" );
+        html += this.#getListSectionHTML( this.#getRelatedTaxaLinks(), "Related Species", "rel-taxa" );
+        html += this.#getListSectionHTML( this.#getSynonyms(), "Synonyms", "synonyms" );
+        html += "</div>";
+
+        this.writeFile( outputDir, this.#taxon.getFileName(), html );
+
+    }
+
+}
+
+export { PageTaxon };

package/lib/taxa.js

@@ -0,0 +1,86 @@
+import { Taxon } from "./taxon.js";
+import { ErrorLog } from "./errorlog.js";
+import { HTML, HTML_OPTIONS } from "./html.js";
+import { CSV } from "./csv.js";
+
+class Taxa {
+
+    static #taxa = {};
+    static #sortedTaxa;
+
+    static getHTMLTable( taxa ) {
+        let html = "<table><thead>";
+        html += HTML.getElement( "th", "Species" );
+        html += HTML.getElement( "th", "Common Name" );
+        html += "</thead>";
+        html += "<tbody>";
+
+        for ( const taxon of taxa ) {
+            html += "<tr>";
+            html += HTML.getElement(
+                "td",
+                HTML.getLink( "./" + taxon.getFileName(), taxon.getName(), { class: taxon.getHTMLClassName() } ),
+                undefined,
+                HTML_OPTIONS.NO_ESCAPE
+            );
+            html += HTML.getElement( "td", taxon.getCommonNames().join( ", " ) );
+            html += "</tr>";
+        }
+
+        html += "</tbody>";
+        html += "</table>";
+
+        return html;
+    }
+
+    static getTaxa() {
+        return this.#sortedTaxa;
+    }
+
+    static getTaxon( name ) {
+        return this.#taxa[ name ];
+    }
+
+    static init( dataDir ) {
+        const taxaCSV = CSV.parseFile( dataDir, "taxa.csv" );
+        for ( const row of taxaCSV ) {
+            const name = row[ "taxon" ];
+            const status = row[ "status" ];
+            const jepsonID = row[ "jepson id" ];
+            switch ( status ) {
+                case "N":
+                case "NC":
+                case "X": {
+                    if ( this.#taxa[ name ] ) {
+                        ErrorLog.log( name, "has multiple entries" );
+                    }
+                    const commonName = row[ "common name" ];
+                    this.#taxa[ name ] = new Taxon( name, commonName, status, jepsonID, row[ "calrecnum" ], row[ "inat id" ] );
+                    if ( !jepsonID ) {
+                        ErrorLog.log( name, "has no Jepson ID" );
+                    }
+                    break;
+                }
+                default:
+                    ErrorLog.log( name, "has unrecognized status", status );
+            }
+        }
+
+        this.#sortedTaxa = Object.values( this.#taxa ).sort( ( a, b ) => a.getName().localeCompare( b.getName() ) );
+
+        const synCSV = CSV.parseFile( dataDir, "synonyms.csv" );
+        for ( const syn of synCSV ) {
+            const currName = syn[ "Current" ];
+            const taxon = this.getTaxon( currName );
+            if ( !taxon ) {
+                ErrorLog.log( currName, "has synonym but not in taxa.csv" );
+                continue;
+            }
+            taxon.addSynonym( syn[ "Former" ], syn[ "Type" ] );
+        }
+
+    }
+
+}
+
+export { Taxa };

package/lib/taxon.js

@@ -0,0 +1,116 @@
+import { Config } from "./config.js";
+import { ErrorLog } from "./errorlog.js";
+import { Genera } from "./genera.js";
+
+class Taxon {
+
+    #name;
+    #genus;
+    #commonNames;
+    #status;
+    #jepsonID;
+    #calRecNum;
+    #iNatID;
+    #iNatName;
+    #synonyms = [];
+
+    constructor( name, commonNames, status, jepsonID, calRecNum, iNatID ) {
+        this.#name = name;
+        this.#genus = name.split( " " )[ 0 ];
+        this.#commonNames = commonNames ? commonNames.split( "," ).map( t => t.trim() ) : [];
+        this.#status = status;
+        this.#jepsonID = jepsonID;
+        this.#calRecNum = calRecNum;
+        this.#iNatID = iNatID;
+        Genera.addTaxon( this );
+        if ( !calRecNum ) {
+            ErrorLog.log( this.getName(), "has no Calflora ID" );
+        }
+        if ( !iNatID ) {
+            ErrorLog.log( this.getName(), "has no iNat ID" );
+        }
+    }
+
+    addSynonym( syn, type ) {
+        this.#synonyms.push( syn );
+        if ( type === "INAT" ) {
+            this.#iNatName = syn;
+        }
+    }
+
+    getCalfloraName() {
+        return this.#name.replace( " subsp.", " ssp." ).replace( "×", "X" );
+    }
+
+    getCalRecNum() {
+        return this.#calRecNum;
+    }
+
+    getCommonNames() {
+        return this.#commonNames;
+    }
+
+    getFamily() {
+        return Genera.getFamily( this.#genus );
+    }
+
+    getFileName( ext = "html" ) {
+        // Convert spaces to "-" and remove ".".
+        return this.getName().replaceAll( " ", "-" ).replaceAll( ".", "" ) + "." + ext;
+    }
+
+    getGenus() {
+        return Genera.getGenus( this.#genus );
+    }
+
+    getHTMLClassName() {
+        return this.isNative() ? "native" : "non-native";
+    }
+
+    getGenusName() {
+        return this.#genus;
+    }
+
+    getINatID() {
+        return this.#iNatID;
+    }
+
+    getINatName() {
+        const name = this.#iNatName ? this.#iNatName : this.#name;
+        return name.replace( / (subsp|var)\./, "" ).replace( "×", "× " );
+    }
+
+    getJepsonID() {
+        return this.#jepsonID;
+    }
+
+    getName() {
+        return this.#name;
+    }
+
+    getStatus() {
+        return this.#status;
+    }
+
+    getStatusDescription() {
+        switch ( this.#status ) {
+            case "N":
+                return "Native";
+            case "NC":
+                return Config.getLabel( "status-NC", "Introduced" );
+            case "X":
+                return "Introduced";
+        }
+        throw new Error( this.#status );
+    }
+    getSynonyms() {
+        return this.#synonyms;
+    }
+
+    isNative() {
+        return this.#status === "N";
+    }
+
+}
+
+export { Taxon };

package/package.json

@@ -0,0 +1,16 @@
+{
+    "name": "@ca-plant-list/ca-plant-list",
+    "version": "0.0.0",
+    "description": "Tools to create Jekyll files for a website listing plants in an area of California.",
+    "license": "MIT",
+    "type": "module",
+    "bin": {
+        "ca-plant-list": "build-site.js"
+    },
+    "dependencies": {
+        "csv-parse": "^5.3.1"
+    },
+    "devDependencies": {
+        "eslint": "^8.26.0"
+    }
+}