@ca-plant-list/ca-plant-list 0.4.26 → 0.4.28

package/lib/index.d.ts

@@ -15,6 +15,10 @@ type RefSourceCode =
     | "jepson"
     | "rpi";
 
+type SiteGeneratorOptions = {
+    passThroughPatterns?: string[];
+};
+
 type TaxaColDef<T> = {
     title: string;
     class?: string;
@@ -53,8 +57,13 @@ export type TaxonOverrides = {
 // Classes
 
 export class BasePageRenderer {
-    static renderBasePages<T extends Taxon>(
+    static newSiteGenerator(
+        config: Config,
         outputDir: string,
+        options?: SiteGeneratorOptions,
+    ): SiteGenerator;
+    static renderBasePages<T extends Taxon>(
+        siteGenerator: SiteGenerator,
         taxa: Taxa<T>,
         familyCols?: TaxaColDef<T>[],
     ): void;
@@ -150,6 +159,10 @@ export class HTML {
     ): string;
 }
 
+export class HTMLFragments {
+    static getMarkdownSection(filePath: string): string;
+}
+
 export class HTMLTaxon {
     static addLink(
         links: string[],
@@ -174,13 +187,6 @@ export class HTMLTaxon {
         header: string,
         className?: string,
     ): string;
-    static getMarkdownSection(filePath: string): string;
-}
-
-export class Jekyll {
-    static hasInclude(baseDir: string, path: string): boolean;
-    static include(fileName: string): string;
-    static writeInclude(baseDir: string, path: string, data: string): void;
 }
 
 export class Photo {
@@ -196,6 +202,12 @@ export class Program {
     static getProgram(): Command;
 }
 
+export class SiteGenerator {
+    generate(outputDir: string): Promise<void>;
+    getBaseDir(): string;
+    getFrontMatter(atts: Record<string, string | undefined>): string;
+}
+
 export class Taxa<T> {
     constructor(
         inclusionList: Record<string, TaxonOverrides> | true,

package/lib/index.js

@@ -7,10 +7,11 @@ import { ExternalSites } from "./externalsites.js";
 import { Families } from "./taxonomy/families.js";
 import { Files } from "./files.js";
 import { HTML } from "./html.js";
+import { HTMLFragments } from "./utils/htmlFragments.js";
 import { HTMLTaxon } from "./htmltaxon.js";
-import { Jekyll } from "./jekyll.js";
 import { PlantBook } from "./ebook/plantbook.js";
 import { Program } from "./program.js";
+import { SiteGenerator } from "./sitegenerator.js";
 import { Taxa } from "./taxonomy/taxa.js";
 import { Taxon } from "./taxonomy/taxon.js";
 
@@ -24,10 +25,11 @@ export {
     Families,
     Files,
     HTML,
+    HTMLFragments,
     HTMLTaxon,
-    Jekyll,
     PlantBook,
     Program,
+    SiteGenerator,
     Taxa,
     Taxon,
 };

package/lib/jekyll.js

@@ -1,71 +1,52 @@
+import * as child_process from "node:child_process";
+import * as path from "node:path";
 import { Files } from "./files.js";
 import { SiteGenerator } from "./sitegenerator.js";
-
-const FRONT_DELIM = "---";
-
-class Jekyll extends SiteGenerator {
-    /**
-     * @param {string} baseDir
-     */
-    constructor(baseDir) {
-        super(baseDir);
+import { Config } from "./config.js";
+
+export class Jekyll extends SiteGenerator {
+    copyGeneratorFiles() {
+        // First copy default files from package.
+        Files.copyDir(
+            path.join(Config.getPackageDir(), "./generators/jekyll"),
+            this.getBaseDir(),
+        );
+        // Then copy files from current dir (which may override default files).
+        Files.copyDir("./generators/jekyll", this.getBaseDir());
     }
 
-    /**
-     * @param {Object<string,string>} atts
-     */
-    static getFrontMatter(atts) {
-        const lines = [FRONT_DELIM];
-        for (const [k, v] of Object.entries(atts)) {
-            lines.push(k + ': "' + v + '"');
+    async generate() {
+        /**
+         * @param {string[]} configFiles
+         * @param {string} dir
+         * @param {string} name
+         */
+        function addConfigFile(configFiles, dir, name) {
+            const fullPath = path.join(dir, name);
+            if (Files.exists(fullPath)) {
+                configFiles.push(fullPath);
+            }
         }
-        if (!atts.layout) {
-            lines.push("layout: default");
-        }
-        lines.push(FRONT_DELIM);
-        return lines.join("\n") + "\n";
-    }
 
-    /**
-     * @param {string} baseDir
-     * @param {string} path
-     */
-    static hasInclude(baseDir, path) {
-        return Files.exists(baseDir + "/_includes/" + path);
-    }
+        const srcDir = "./output";
+        const destDir = "./public";
 
-    /**
-     * @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 }}"
-        );
-    }
+        // Remove existing files.
+        Files.rmDir(destDir);
 
-    /**
-     * @param {string} baseDir
-     * @param {string} path
-     * @param {string} data
-     */
-    static writeInclude(baseDir, path, data) {
-        Files.write(baseDir + "/_includes/" + path, data);
-    }
+        const options = ["--source", srcDir, "--destination", destDir];
 
-    /**
-     * @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
+        // Find out what config files are available.
+        /** @type {string[]} */
+        const configFiles = [];
+        addConfigFile(configFiles, srcDir, "_config.yml");
+        addConfigFile(configFiles, srcDir, "_config-local.yml");
+        addConfigFile(configFiles, ".", "_config-dev.yml");
+        options.push("--config", `"${configFiles.join()}"`);
+
+        const result = child_process.execSync(
+            "bundle exec jekyll build " + options.join(" "),
         );
+        console.log(result.toString());
     }
 }
-
-export { Jekyll };

package/lib/markdown.js

@@ -1,16 +1,16 @@
 import markdownIt from "markdown-it";
 import { Files } from "./files.js";
 
-class Markdown {
+export class Markdown {
     static #md = new markdownIt({ xhtmlOut: true });
 
     /**
      * @param {string} filePath
-     * @returns {string|undefined}
+     * @returns {string}
      */
     static fileToHTML(filePath) {
         if (!Files.exists(filePath)) {
-            return;
+            return "";
         }
         return this.strToHTML(Files.read(filePath));
     }
@@ -22,5 +22,3 @@ class Markdown {
         return this.#md.render(str);
     }
 }
-
-export { Markdown };

package/lib/sitegenerator.js

@@ -1,16 +1,29 @@
+import path from "node:path";
 import { optimize } from "svgo-ll";
 
 import { Config } from "./config.js";
 import { Files } from "./files.js";
 
-class SiteGenerator {
+const FRONT_DELIM = "---";
+
+export class SiteGenerator {
+    #config;
     #baseDir;
+    #options;
 
     /**
+     * @param {Config} config
      * @param {string} baseDir
+     * @param {import("./index.js").SiteGeneratorOptions} [options]
      */
-    constructor(baseDir) {
+    constructor(config, baseDir, options = {}) {
+        this.#config = config;
         this.#baseDir = baseDir;
+        this.#options = options;
+    }
+
+    copyGeneratorFiles() {
+        throw new Error("must be implemented by subclass");
     }
 
     /**
@@ -23,11 +36,11 @@ class SiteGenerator {
          */
         function createFlowerColorIcons(outputDir, flowerColors) {
             // Read generic input.
-            const inputFileName = Files.join(outputDir, "flower.svg");
+            const inputFileName = path.join(outputDir, "flower.svg");
             const srcSVG = Files.read(inputFileName);
             for (const color of flowerColors) {
                 Files.write(
-                    Files.join(outputDir, "f-" + color.getColorName() + ".svg"),
+                    path.join(outputDir, "f-" + color.getColorName() + ".svg"),
                     srcSVG.replace("#ff0", color.getColorCode()),
                 );
             }
@@ -59,26 +72,69 @@ class SiteGenerator {
         createFlowerColorIcons(outputDir, flowerColors);
     }
 
+    copyStaticFiles() {
+        // First copy default files from ca-plant-list.
+        Files.copyDir(
+            path.join(Config.getPackageDir(), "static"),
+            this.#baseDir,
+        );
+        // Then copy files from current directory (which may override default files).
+        Files.copyDir("./static", this.#baseDir);
+    }
+
+    /**
+     * @param {string} webDir
+     */
+    // eslint-disable-next-line no-unused-vars
+    async generate(webDir) {
+        throw new Error("must be implemented by subclass");
+    }
+
     getBaseDir() {
         return this.#baseDir;
     }
 
+    getConfig() {
+        return this.#config;
+    }
+
     /**
-     * @param {string} path
+     * @param {Object<string,string|undefined>} atts
      */
-    mkdir(path) {
-        Files.mkdir(Files.join(this.#baseDir, path));
+    getFrontMatter(atts) {
+        const lines = [FRONT_DELIM];
+        for (const [k, v] of Object.entries(atts)) {
+            if (v) {
+                lines.push(k + ': "' + v + '"');
+            }
+        }
+        lines.push(FRONT_DELIM);
+        return lines.join("\n") + "\n\n";
+    }
+
+    /**
+     * @returns {string[]}
+     */
+    getPassThroughPatterns() {
+        return this.#options.passThroughPatterns ?? [];
+    }
+
+    /**
+     * @param {string} outputSubdir
+     */
+    mkdir(outputSubdir) {
+        Files.mkdir(path.join(this.#baseDir, outputSubdir));
     }
 
     /**
      * @param {string} content
-     * @param {{title:string}} attributes
+     * @param {Object<string,string>} attributes
      * @param {string} filename
      */
-    // eslint-disable-next-line no-unused-vars
     writeTemplate(content, attributes, filename) {
-        throw new Error("must be implemented by subclass");
+        Files.write(
+            path.join(this.getBaseDir(), filename),
+            this.getFrontMatter(attributes) + content,
+        );
     }
 }
-
-export { SiteGenerator };

package/lib/taxonomy/taxon.js

@@ -282,7 +282,11 @@ class Taxon extends Taxonomy {
     }
 
     isCANative() {
-        return this.#status === "N" || this.#status === "NC";
+        return (
+            this.#status === "N" ||
+            this.#status === "NC" ||
+            this.#status === "U"
+        );
     }
 
     /**

package/lib/tools/cch2.js

@@ -1,9 +1,9 @@
 import path from "node:path";
+import { renameSync } from "node:fs";
+import puppeteer from "puppeteer";
 import { CSV } from "../csv.js";
 import { TaxaCSV } from "./taxacsv.js";
 import { Files } from "../files.js";
-import puppeteer from "puppeteer";
-import { renameSync } from "node:fs";
 
 /**
  * @typedef {{id:string}} CCHTaxon
@@ -29,12 +29,12 @@ export class CCH2 {
     ) {
         const toolsDataPath = path.join(toolsDataDir, "cch2");
 
-        const cchTaxa = await getCCHTaxa(toolsDataPath, taxa);
+        const cchTaxa = await getCCHTaxa(toolsDataPath);
 
         const idsToUpdate = new Map();
         for (const taxon of taxa.getTaxonList()) {
             const name = taxon.getName();
-            const cchTaxon = cchTaxa.get(name);
+            const cchTaxon = getCCHTaxon(taxon, cchTaxa);
             if (!cchTaxon) {
                 if (!exceptions.hasException(name, "cch", "notincch")) {
                     errorLog.log(name, "not found in CCH data");
@@ -106,27 +106,18 @@ export class CCH2 {
 
 /**
  * @param {string} toolsDataPath
- * @param {import("../types.js").Taxa} taxa
  * @returns {Promise<CCHTaxa>}
  */
-async function getCCHTaxa(toolsDataPath, taxa) {
+async function getCCHTaxa(toolsDataPath) {
     /**
-     * @param {{taxonID:string,scientificName:string,rankID:string,acceptance:"0"|"1",acceptedTaxonID:string}} record
+     * @param {{taxonID:string,scientificName:string,rankID:string,acceptance:"0"|"1",acceptedTaxonID:string,acceptedScientificName:string}} record
      */
     function callback(record) {
         if (parseInt(record.rankID) < 220) {
             // Ignore ranks above species.
             return;
         }
-        if (!taxa.getTaxon(record.scientificName)) {
-            // If we're not tracking the taxon, ignore it.
-            return;
-        }
-        if (record.acceptance !== "1" && data.has(record.scientificName)) {
-            // Only add the synonym if there is no main entry.
-            return;
-        }
-        data.set(record.scientificName, { id: record.acceptedTaxonID });
+        cchTaxa.set(record.scientificName, { id: record.taxonID });
     }
 
     const fileName = path.join(toolsDataPath, "taxa.csv");
@@ -134,11 +125,39 @@ async function getCCHTaxa(toolsDataPath, taxa) {
         await retrieveDataFile(toolsDataPath);
     }
 
-    const data = new Map();
+    const cchTaxa = new Map();
 
     await CSV.parseFileStream(fileName, callback);
 
-    return data;
+    return cchTaxa;
+}
+
+/**
+ * @param {import("../types.js").Taxon} taxon
+ * @param {CCHTaxa} cchTaxa
+ * @returns {CCHTaxon|undefined}
+ */
+function getCCHTaxon(taxon, cchTaxa) {
+    /**
+     * @param {string} name
+     */
+    function getTaxon(name) {
+        return cchTaxa.get(name);
+    }
+
+    const name = taxon.getName();
+    const cchTaxon = getTaxon(name);
+    if (cchTaxon) {
+        return cchTaxon;
+    }
+
+    // No reference for the current name; try synonyms and see if any of them work.
+    for (const synonym of taxon.getSynonyms()) {
+        const cchTaxon = getTaxon(synonym);
+        if (cchTaxon) {
+            return cchTaxon;
+        }
+    }
 }
 
 /**

package/lib/tools/jepsonfamilies.js

@@ -8,7 +8,7 @@ export class JepsonFamilies {
      * @param {string} outputdir
      */
     static async build(toolsDataDir, outputdir) {
-        const url = "https://ucjeps.berkeley.edu/eflora/toc.html";
+        const url = "https://ucjeps.berkeley.edu/IJM_keys/toc.html";
         const indexFileName = path.basename(url);
         const toolsDataPath = toolsDataDir + "/jepsonfam";
         const indexFilePath = toolsDataPath + "/" + indexFileName;

package/lib/types.js

@@ -1,8 +1,12 @@
 /**
+ * Types
+ * @typedef {{t:string,c?:string,s?:string[]}} NameSearchData
+ *
  * Classes
  * @typedef {import("./config.js").Config} Config
  * @typedef {import("./taxonomy/families.js").Families} Families
  * @typedef {import("./taxonomy/families.js").Family} Family
+ * @typedef {import("./sitegenerator.js").SiteGenerator} SiteGenerator
  * @typedef {import("./taxonomy/taxa.js").Taxa} Taxa
  * @typedef {import("./index.js").TaxaColDef<import("./types.js").Taxon>} TaxaColDef
  * @typedef {import("./taxonomy/taxon.js").Taxon} Taxon

package/lib/utils/eleventyGenerator.js

@@ -0,0 +1,82 @@
+// @ts-ignore
+import { Eleventy } from "@11ty/eleventy";
+import { SiteGenerator } from "../sitegenerator.js";
+import path from "node:path";
+import { Files } from "../files.js";
+import { Config } from "../config.js";
+
+export class EleventyGenerator extends SiteGenerator {
+    copyGeneratorFiles() {
+        // First copy default files from package.
+        const layoutSrc = "./generators/eleventy/layouts";
+        const commonSrc = "./generators/_includes";
+        const dest = path.join(this.getBaseDir(), "_includes");
+
+        Files.copyDir(path.join(Config.getPackageDir(), commonSrc), dest);
+        Files.copyDir(path.join(Config.getPackageDir(), layoutSrc), dest);
+
+        // Then copy files from current dir (which may override default files).
+        if (Files.isDir(commonSrc)) {
+            Files.copyDir(commonSrc, dest);
+        }
+        if (Files.isDir(layoutSrc)) {
+            Files.copyDir(layoutSrc, dest);
+        }
+    }
+
+    /**
+     * @param {string} webDir
+     */
+    async generate(webDir) {
+        const srcDir = this.getBaseDir();
+        const config = this.getConfig();
+        const generator = this;
+        let elev = new Eleventy(srcDir, webDir, {
+            quietMode: true,
+            config:
+                // @ts-ignore
+                function (eleventyConfig) {
+                    // Not running in project root, so using .gitignore will break things.
+                    eleventyConfig.setUseGitIgnore(false);
+
+                    // Don't change file system structure when writing output files.
+                    eleventyConfig.addGlobalData("permalink", () => {
+                        // @ts-ignore
+                        return (data) => {
+                            // Include directories in the generated content.
+                            const inputPath = path.relative(
+                                srcDir,
+                                data.page.inputPath,
+                            );
+                            // Remove the file extension.
+                            const parsed = path.parse(inputPath);
+                            return path.join(parsed.dir, `${parsed.name}.html`);
+                        };
+                    });
+
+                    // Use layout with <h1> by default.
+                    eleventyConfig.addGlobalData("layout", "h1.njk");
+
+                    // Set site name for use in nav bar.
+                    eleventyConfig.addGlobalData(
+                        "siteName",
+                        config.getSiteName(),
+                    );
+
+                    const passThroughPatterns = [
+                        "assets",
+                        "i",
+                        "errors.tsv",
+                        ...generator.getPassThroughPatterns(),
+                    ];
+                    for (const pattern of passThroughPatterns) {
+                        eleventyConfig.addPassthroughCopy(
+                            // Eleventy apparently can't handle windows paths in globs, so change it.
+                            path.join(srcDir, pattern).replaceAll("\\", "/"),
+                        );
+                    }
+                },
+        });
+        await elev.write();
+    }
+}

package/lib/utils/htmlFragments.js

@@ -0,0 +1,19 @@
+import { HTML } from "../html.js";
+import { Markdown } from "../markdown.js";
+
+/**
+ * Utilities to create HTML fragments specific to ca-plant-list.
+ */
+export class HTMLFragments {
+    /**
+     * @param {string} filePath
+     * @returns {string}
+     */
+    static getMarkdownSection(filePath) {
+        const footerMarkdown = Markdown.fileToHTML(filePath);
+        if (footerMarkdown) {
+            return HTML.wrap("div", footerMarkdown, "section");
+        }
+        return "";
+    }
+}

package/lib/web/glossarypages.js

@@ -1,11 +1,11 @@
 import { Glossary } from "../plants/glossary.js";
 import { Markdown } from "../markdown.js";
 import { HTML } from "../html.js";
-import { Files } from "../files.js";
+import path from "node:path";
 
 const ENTRY_DIR = "g";
 
-class GlossaryPages {
+export class GlossaryPages {
     #siteGenerator;
     #glossary;
 
@@ -22,14 +22,13 @@ class GlossaryPages {
      */
     #generateEntryPage(entry) {
         const title = entry.getTermName();
-        let html = HTML.textElement("h1", title);
-        html += HTML.wrap("div", Markdown.strToHTML(entry.getMarkdown()), {
+        let html = HTML.wrap("div", Markdown.strToHTML(entry.getMarkdown()), {
             class: "glossary",
         });
         this.#siteGenerator.writeTemplate(
             html,
             { title: title },
-            Files.join(ENTRY_DIR, title + ".html"),
+            path.posix.join(ENTRY_DIR, title + ".html"),
         );
     }
 
@@ -49,13 +48,12 @@ class GlossaryPages {
         for (const entry of entries) {
             links.push(
                 HTML.getLink(
-                    Files.join(ENTRY_DIR, entry.getHTMLFileName()),
+                    path.posix.join(ENTRY_DIR, entry.getHTMLFileName()),
                     entry.getTermName(),
                 ),
             );
         }
-        let html = HTML.wrap("h1", "Glossary");
-        html += HTML.wrap("ol", HTML.arrayToLI(links));
+        const html = HTML.wrap("ol", HTML.arrayToLI(links));
         this.#siteGenerator.writeTemplate(
             html,
             { title: "Glossary" },
@@ -72,5 +70,3 @@ class GlossaryPages {
         this.#generateEntryPages();
     }
 }
-
-export { GlossaryPages };