@ca-plant-list/ca-plant-list 0.4.11 → 0.4.13

package/lib/csv.js

@@ -109,17 +109,53 @@ class CSV {
         return parseSync(content, options);
     }
 
+    /**
+     * @param {string} fileName
+     * @param {string} [delimiter]
+     * @returns {{headers:string[],data:Object<string,any>[]}}
+     */
+    static readFileAndHeaders(fileName, delimiter) {
+        let headers;
+        /**
+         * @param {string[]} h
+         */
+        function getHeaders(h) {
+            headers = h;
+            return h;
+        }
+
+        const content = fs.readFileSync(fileName);
+        const options = this.#getOptions(fileName, getHeaders, delimiter);
+
+        const data = parseSync(content, options);
+        if (headers === undefined) {
+            throw new Error();
+        }
+        return { headers: headers, data: data };
+    }
+
     /**
      *
      * @param {string} fileName
      * @param {string[][]} data
      * @param {string[]} [headerData]
      */
-    static writeFile(fileName, data, headerData) {
+    static writeFileArray(fileName, data, headerData) {
         const header = headerData ? stringify([headerData]) : "";
         const content = header + stringify(data);
         fs.writeFileSync(fileName, content);
     }
+
+    /**
+     *
+     * @param {string} fileName
+     * @param {Object<string,any>[]} data
+     * @param {string[]} headerData
+     */
+    static writeFileObject(fileName, data, headerData) {
+        const content = stringify(data, { columns: headerData, header: true });
+        fs.writeFileSync(fileName, content.replaceAll(/,+\n/g, "\n"));
+    }
 }
 
 export { CSV };

package/lib/exceptions.js

@@ -18,7 +18,7 @@ class Exceptions {
 
         // Read default configuration.
         this.#exceptions = readConfig(
-            Config.getPackageDir() + "/data/exceptions.json"
+            Config.getPackageDir() + "/data/exceptions.json",
         );
 
         // Add/overwrite with local configuration.
@@ -38,7 +38,7 @@ class Exceptions {
      * @param {string} name
      * @param {string} cat
      * @param {string} subcat
-     * @param {string} defaultValue
+     * @param {string} [defaultValue]
      */
     getValue(name, cat, subcat, defaultValue) {
         const taxonData = this.#exceptions[name];

package/lib/genera.js

@@ -58,7 +58,7 @@ class Genus {
 
     getTaxa() {
         return this.#data.taxa.sort((a, b) =>
-            a.getName().localeCompare(b.getName())
+            a.getName().localeCompare(b.getName()),
         );
     }
 }

package/lib/htmltaxon.js

@@ -43,6 +43,23 @@ const DEFAULT_TAXA_COLUMNS = [
 ];
 
 class HTMLTaxon {
+    /**
+     * @param {Taxon} taxon
+     * @returns {string|undefined}
+     */
+    static getCalscapeLink(taxon) {
+        const calscapeCN = taxon.getCalscapeCommonName();
+        if (!calscapeCN) {
+            return;
+        }
+        return HTML.getLink(
+            `https://www.calscape.org/${taxon.getCalscapeName().replaceAll(" ", "-")}-()`,
+            "Calscape",
+            {},
+            true,
+        );
+    }
+
     /**
      * @param {string[]|undefined} colors
      */

package/lib/index.d.ts

@@ -6,14 +6,14 @@ export class Config {
         prefix: string,
         name: string,
         subcategory?: string,
-        defaultValue?: string
+        defaultValue?: string,
     ): string;
     getCountyCodes(): string[];
     getLabel(name: string, dflt: string): string;
 }
 
 export class CSV {
-    static parseFile(dir: string, fileName: string): void;
+    static parseFile(dir: string, fileName: string): Record<string, string>[];
 }
 
 export class ErrorLog {
@@ -31,7 +31,7 @@ export class Files {
     static exists(fileName: string): boolean;
     static fetch(
         url: string | URL,
-        targetFileName: string | undefined
+        targetFileName: string | undefined,
     ): Promise<Headers>;
     static mkdir(dir: string): void;
     static rmDir(dir: string): void;
@@ -50,7 +50,7 @@ export class Taxa {
         showFlowerErrors: boolean,
         taxonFactory?: (td: TaxonData, g: Genera) => Taxon,
         extraTaxa?: TaxonData[],
-        extraSynonyms?: SynonymData[]
+        extraSynonyms?: SynonymData[],
     );
     getTaxon(name: string): Taxon;
     getTaxonList(): Taxon[];

package/lib/taxa.js

@@ -8,6 +8,7 @@ import { Taxon } from "./taxon.js";
 import { Families } from "./families.js";
 import { FlowerColor } from "./flowercolor.js";
 import { InatPhoto } from "./inat_photo.js";
+import { TaxaCSV } from "./tools/taxacsv.js";
 
 const FLOWER_COLORS = [
     { name: "white", color: "white" },
@@ -61,13 +62,21 @@ class Taxa {
         const dataDir = Config.getPackageDir() + "/data";
 
         this.#families = new Families();
+        const genera = new Genera(this.#families);
 
-        const taxaCSV = CSV.parseFile(dataDir, "taxa.csv");
-        this.#loadTaxa(taxaCSV, inclusionList, taxonFactory, showFlowerErrors);
+        const taxaCSV = new TaxaCSV(dataDir);
+        this.#loadTaxa(
+            taxaCSV.getTaxa(),
+            inclusionList,
+            taxonFactory,
+            genera,
+            showFlowerErrors,
+        );
         this.#loadTaxa(
             extraTaxa,
             inclusionList,
             taxonFactory,
+            genera,
             showFlowerErrors,
         );
 
@@ -178,10 +187,10 @@ class Taxa {
      * @param {TaxonData[]} taxaCSV
      * @param {Object<string,TaxonData>|true} inclusionList
      * @param {function(TaxonData,Genera):Taxon} taxonFactory
+     * @param {Genera} genera
      * @param {boolean} showFlowerErrors
      */
-    #loadTaxa(taxaCSV, inclusionList, taxonFactory, showFlowerErrors) {
-        const genera = new Genera(this.#families);
+    #loadTaxa(taxaCSV, inclusionList, taxonFactory, genera, showFlowerErrors) {
         for (const row of taxaCSV) {
             const name = row["taxon_name"];
 

package/lib/taxon.js

@@ -22,6 +22,7 @@ class Taxon {
     #iNatID;
     /**@type {string|undefined} */
     #iNatSyn;
+    #calscapeCN;
     #lifeCycle;
     #flowerColors;
     #bloomStart;
@@ -58,6 +59,8 @@ class Taxon {
         this.#jepsonID = data["jepson id"];
         this.#calRecNum = data["calrecnum"];
         this.#iNatID = data["inat id"];
+        this.#calscapeCN =
+            data.calscape_cn === "" ? undefined : data.calscape_cn;
         this.#lifeCycle = data.life_cycle;
         const colors = data["flower_color"];
         this.#flowerColors = colors ? colors.split(",") : undefined;
@@ -98,7 +101,7 @@ class Taxon {
      * @param {InatPhoto} photo
      */
     addPhoto(photo) {
-        this.#photos = this.#photos.concat( [photo] );
+        this.#photos = this.#photos.concat([photo]);
     }
 
     getPhotos() {
@@ -144,11 +147,26 @@ class Taxon {
             "https://www.calflora.org/app/taxon?crn=" + calfloraID,
             "Calflora",
             {},
-            true
+            true,
         );
         return this.#cfSyn ? link + " (" + this.#cfSyn + ")" : link;
     }
 
+    getCalscapeCommonName() {
+        return this.#calscapeCN;
+    }
+
+    getCalscapeName() {
+        return Taxon.getCalscapeName(this.getName());
+    }
+
+    /**
+     * @param {string} name
+     */
+    static getCalscapeName(name) {
+        return name.replace(" subsp.", " ssp.");
+    }
+
     getCESA() {
         return this.#cesa;
     }
@@ -206,7 +224,7 @@ class Taxon {
         const link = HTML.wrap(
             "span",
             HTML.getLink(href, this.getName()),
-            attributes
+            attributes,
         );
         if (isRare) {
             return HTML.getToolTip(link, this.getRPIRankAndThreatTooltip(), {
@@ -238,7 +256,7 @@ class Taxon {
             "https://www.inaturalist.org/taxa/" + iNatID,
             "iNaturalist",
             {},
-            true
+            true,
         );
         return this.#iNatSyn ? link + " (" + this.#iNatSyn + ")" : link;
     }
@@ -272,7 +290,7 @@ class Taxon {
 
     getRPIRankAndThreatTooltip() {
         return RarePlants.getRPIRankAndThreatDescriptions(
-            this.getRPIRankAndThreat()
+            this.getRPIRankAndThreat(),
         ).join("<br>");
     }
 
@@ -285,7 +303,7 @@ class Taxon {
             "https://rareplants.cnps.org/Plants/Details/" + rpiID,
             "CNPS Rare Plant Inventory",
             {},
-            true
+            true,
         );
         return link;
     }

package/lib/tools/calflora.js

@@ -0,0 +1,220 @@
+import * as path from "path";
+import { CSV } from "../csv.js";
+import { Files } from "../files.js";
+
+const CALFLORA_URL_ALL =
+    "https://www.calflora.org/app/downtext?xun=117493&table=species&format=Tab&cols=0,1,4,5,8,38,41,43&psp=lifeform::grass,Tree,Herb,Fern,Shrub,Vine!!&par=f&active=";
+const CALFLORA_URL_COUNTY =
+    "https://www.calflora.org/app/downtext?xun=117493&table=species&format=Tab&cols=0,1,4,5,8,38,41,43&psp=countylist::ALA,CCA!!&active=1";
+
+/**
+ * @typedef {{
+ * "Native Status":string,
+ * TJMTID:string
+ * "Active in Calflora?":string
+ * Calrecnum:string
+ * }} CalfloraData
+ */
+
+class Calflora {
+    /** @type {Object<string,CalfloraData>} */
+    static #taxa = {};
+
+    /**
+     *
+     * @param {string} toolsDataDir
+     * @param {Taxa} taxa
+     * @param {import("../exceptions.js").Exceptions} exceptions
+     * @param {ErrorLog} errorLog
+     */
+    static async analyze(toolsDataDir, taxa, exceptions, errorLog) {
+        /**
+         * @param {string} url
+         * @param {string} targetFile
+         */
+        async function retrieveCalfloraFile(url, targetFile) {
+            // Retrieve file if it's not there.
+            targetFile = toolsDataPath + "/" + targetFile;
+            if (Files.exists(targetFile)) {
+                return;
+            }
+            console.log("retrieving " + targetFile);
+            await Files.fetch(url, targetFile);
+        }
+
+        const toolsDataPath = toolsDataDir + "/calflora";
+        // Create data directory if it's not there.
+        Files.mkdir(toolsDataPath);
+
+        const calfloraDataFileNameActive = "calflora_taxa_active.tsv";
+        const calfloraDataFileNameCounties = "calflora_taxa_counties.tsv";
+
+        await retrieveCalfloraFile(
+            CALFLORA_URL_ALL + "1",
+            calfloraDataFileNameActive,
+        );
+        // County list and "all" lists are both incomplete; load everything to get as much as possible.
+        await retrieveCalfloraFile(
+            CALFLORA_URL_COUNTY,
+            calfloraDataFileNameCounties,
+        );
+
+        const csvActive = CSV.readFile(
+            path.join(toolsDataPath, calfloraDataFileNameActive),
+        );
+        const csvCounties = CSV.readFile(
+            path.join(toolsDataPath, calfloraDataFileNameCounties),
+        );
+
+        for (const row of csvActive) {
+            this.#taxa[row["Taxon"]] = row;
+        }
+        for (const row of csvCounties) {
+            this.#taxa[row["Taxon"]] = row;
+        }
+
+        for (const taxon of taxa.getTaxonList()) {
+            const name = taxon.getName();
+            if (name.includes(" unknown")) {
+                continue;
+            }
+            const cfName = taxon.getCalfloraName();
+            const cfData = Calflora.#taxa[cfName];
+            if (!cfData) {
+                if (
+                    !exceptions.hasException(name, "calflora", "notintaxondata")
+                ) {
+                    errorLog.log(name, "not found in Calflora files");
+                }
+                continue;
+            }
+
+            // Check native status.
+            const cfNative = cfData["Native Status"];
+            let cfIsNative = cfNative === "rare" || cfNative === "native";
+            // Override if exception is specified.
+            const nativeException = exceptions.getValue(
+                name,
+                "calflora",
+                "native",
+                undefined,
+            );
+            if (typeof nativeException === "boolean") {
+                if (nativeException === cfIsNative) {
+                    errorLog.log(
+                        name,
+                        "has unnecessary Calflora native override",
+                    );
+                }
+                cfIsNative = nativeException;
+            }
+            if (cfIsNative !== taxon.isCANative()) {
+                errorLog.log(
+                    name,
+                    "has different nativity status in Calflora",
+                    cfIsNative.toString(),
+                );
+            }
+
+            // Check if it is active in Calflora.
+            const isActive = cfData["Active in Calflora?"];
+            if (isActive !== "YES") {
+                errorLog.log(name, "is not active in Calflora", isActive);
+            }
+
+            // Check Jepson IDs.
+            const cfJepsonID = cfData.TJMTID;
+            if (cfJepsonID !== taxon.getJepsonID()) {
+                if (
+                    !exceptions.hasException(name, "calflora", "badjepsonid") &&
+                    !exceptions.hasException(name, "calflora", "notintaxondata")
+                ) {
+                    errorLog.log(
+                        name,
+                        "Jepson ID in Calflora is different than taxa.csv",
+                        cfJepsonID,
+                        taxon.getJepsonID(),
+                    );
+                }
+            }
+
+            // Check Calflora ID.
+            const cfID = cfData["Calrecnum"];
+            if (cfID !== taxon.getCalfloraID()) {
+                errorLog.log(
+                    name,
+                    "Calflora ID in Calflora is different than taxa.csv",
+                    cfID,
+                    taxon.getCalfloraID(),
+                );
+            }
+        }
+
+        this.#checkExceptions(taxa, exceptions, errorLog);
+    }
+
+    /**
+     * @param {Taxa} taxa
+     * @param {import("../exceptions.js").Exceptions} exceptions
+     * @param {ErrorLog} errorLog
+     */
+    static #checkExceptions(taxa, exceptions, errorLog) {
+        // Check the Calflora exceptions and make sure they still apply.
+        for (const [name, v] of exceptions.getExceptions()) {
+            const exceptions = v.calflora;
+            if (!exceptions) {
+                continue;
+            }
+
+            // Make sure the taxon is still in our list.
+            const taxon = taxa.getTaxon(name);
+            if (!taxon) {
+                // Don't process global exceptions if taxon is not in local list.
+                if (taxa.isSubset() && !v.local) {
+                    continue;
+                }
+                errorLog.log(
+                    name,
+                    "has Calflora exceptions but not in Taxa collection",
+                );
+                continue;
+            }
+
+            for (const [k] of Object.entries(exceptions)) {
+                const cfData = Calflora.#taxa[name];
+                switch (k) {
+                    case "badjepsonid": {
+                        // Make sure Jepson ID is still wrong.
+                        const cfID = cfData.TJMTID;
+                        const jepsID = taxon.getJepsonID();
+                        if (cfID === jepsID) {
+                            errorLog.log(
+                                name,
+                                "has Calflora badjepsonid exception but IDs are the same",
+                            );
+                        }
+                        break;
+                    }
+                    case "native":
+                        break;
+                    case "notintaxondata":
+                        if (cfData) {
+                            errorLog.log(
+                                name,
+                                "found in Calflora data but has notintaxondata exception",
+                            );
+                        }
+                        break;
+                    default:
+                        errorLog.log(
+                            name,
+                            "unrecognized Calflora exception",
+                            k,
+                        );
+                }
+            }
+        }
+    }
+}
+
+export { Calflora };