@ca-plant-list/ca-plant-list 0.1.22 → 0.2.1

package/data/text/Leptosiphon-bicolor.md

@@ -0,0 +1 @@
+Flowers pedicelled. Corolla tube at least twice as long as calyx. Calyx membrane much narrower than lobes.

package/data/text/Leptosiphon-ciliatus.md

@@ -0,0 +1 @@
+Flowers pedicelled. Corolla tube at least twice as long as calyx. Calyx membrane at least as wide as lobes.

package/data/text/Leptosiphon-grandiflorus.md

@@ -0,0 +1 @@
+Flowers sessile.

package/data/text/Lupinus-bicolor.md

@@ -0,0 +1 @@
+Banner longer than wide; pedicels generally < 3 mm.

package/data/text/Lupinus-nanus.md

@@ -0,0 +1 @@
+Banner as wide as or wider than long; pedicels generally > 3 mm.

package/ebook/css/main.css

@@ -0,0 +1,59 @@
+img {
+    width: 100%;
+}
+
+figure {
+    page-break-inside: avoid;
+}
+
+span.color {
+    border: solid black 1px;
+    border-radius: .25rem;
+    margin-right: .5rem;
+    padding: .25rem;
+}
+
+span.color.blue {
+    background-color: blue;
+    color: white;
+}
+
+span.color.pink {
+    background-color: pink;
+    color: white;
+}
+
+span.color.red {
+    background-color: red;
+    color: white;
+}
+
+span.color.yellow {
+    background-color: yellow;
+    color: black;
+}
+
+span.color.white {
+    background-color: white;
+    color: black;
+}
+
+span.color.blue::after {
+    content: "Blue"
+}
+
+span.color.pink::after {
+    content: "Pink"
+}
+
+span.color.red::after {
+    content: "Red"
+}
+
+span.color.white::after {
+    content: "White"
+}
+
+span.color.yellow::after {
+    content: "Yellow"
+}

package/lib/dataloader.js

@@ -1,6 +1,8 @@
+import { CSV } from "./csv.js";
 import { Taxa } from "./taxa.js";
 import { Families } from "./families.js";
 import { Exceptions } from "./exceptions.js";
+import { Files } from "./files.js";
 
 const OPTION_DEFS = [
     { name: "datadir", type: String, defaultValue: "./data" },
@@ -19,12 +21,28 @@ class DataLoader {
 
     static load( options ) {
 
+        function getIncludeList() {
+            // Read inclusion list.
+            const includeFileName = "taxa_include.csv";
+            if ( !Files.exists( taxaDir + "/" + includeFileName ) ) {
+                console.log( includeFileName + " not found; loading all taxa" );
+                return true;
+            }
+            const includeCSV = CSV.parseFile( taxaDir, includeFileName );
+            const include = {};
+            for ( const row of includeCSV ) {
+                include[ row[ "taxon_name" ] ] = row;
+            }
+            return include;
+        }
+
         const taxaDir = options.datadir;
 
         console.log( "loading data" );
 
         this.init( taxaDir );
-        Taxa.init( taxaDir );
+
+        Taxa.init( getIncludeList() );
 
     }
 

package/lib/ebook/ebook.js

@@ -0,0 +1,146 @@
+import * as fs from "node:fs";
+import { default as archiver } from "archiver";
+import { XHTML } from "./xhtml.js";
+import { Config } from "../config.js";
+
+class EBook {
+
+    #outputDir;
+    #filename;
+    #pub_id;
+    #title;
+
+    constructor( outputDir, filename, pub_id, title ) {
+
+        this.#outputDir = outputDir;
+        this.#filename = filename;
+        this.#pub_id = pub_id;
+        this.#title = title;
+
+        // Initialize output directory.
+        fs.rmSync( this.#outputDir, { force: true, recursive: true } );
+        fs.mkdirSync( this.getContentDir(), { recursive: true } );
+
+    }
+
+    async create() {
+
+        const contentDir = this.getContentDir();
+
+        this.#createContainerFile();
+        await this.createPages();
+        this.#createPackageFile();
+
+        // Copy assets
+        const cssDirTarget = contentDir + "/css";
+        fs.mkdirSync( cssDirTarget, { recursive: true } );
+        fs.cpSync( Config.getPackageDir() + "/ebook/css", cssDirTarget, { recursive: true } );
+
+        this.createZip();
+
+    }
+
+    #createContainerFile() {
+
+        const metaDir = this.#getMetaDir();
+
+        fs.mkdirSync( metaDir, { recursive: true } );
+
+        let xml = "<?xml version=\"1.0\"?>"
+            + "<container version=\"1.0\" xmlns=\"urn:oasis:names:tc:opendocument:xmlns:container\">";
+
+        xml += "<rootfiles><rootfile full-path=\"epub/package.opf\" media-type=\"application/oebps-package+xml\" /></rootfiles>";
+        xml += "</container>";
+
+        fs.writeFileSync( metaDir + "/container.xml", xml );
+
+    }
+
+    #createPackageFile() {
+
+        const dir = this.getContentDir();
+
+        let xml = "<?xml version=\"1.0\"?>\n"
+            + "<package version=\"3.0\" xml:lang=\"en\" xmlns=\"http://www.idpf.org/2007/opf\" unique-identifier=\"pub-id\">";
+
+        xml += this.#renderMetadata();
+        xml += this.#renderManifest();
+        xml += this.#renderSpine();
+
+        xml += "</package>";
+
+        fs.writeFileSync( dir + "/package.opf", xml );
+
+    }
+
+    async createPages() {
+        throw new Error( "must be implemented by subclass" );
+    }
+
+    createZip() {
+        // Create zip.
+        const filename = this.#outputDir + "/" + this.#filename + ".epub";
+        const output = fs.createWriteStream( filename );
+        const archive = archiver(
+            "zip",
+            {
+                zlib: { level: 9 } // Sets the compression level.
+            }
+        );
+
+        archive.pipe( output );
+
+        archive.append( "application/epub+zip", { name: "mimetype", store: true } );
+
+        archive.directory( this.#getMetaDir(), "META-INF" );
+        archive.directory( this.getContentDir(), "epub" );
+
+        archive.finalize();
+
+    }
+
+    getContentDir() {
+        return this.#outputDir + "/epub";
+    }
+
+    #getMetaDir() {
+        return this.#outputDir + "/META-INF";
+    }
+
+    #renderManifest() {
+        let xml = "<manifest>";
+        xml += "<item id=\"c0\" href=\"css/main.css\" media-type=\"text/css\" />";
+        xml += this.renderManifestEntries();
+        xml += "<item id=\"toc\" href=\"toc.xhtml\" media-type=\"application/xhtml+xml\" properties=\"nav\" />";
+        return xml + "</manifest>";
+    }
+
+    renderManifestEntries() {
+        throw new Error( "must be implemented by subclass" );
+    }
+
+    #renderMetadata() {
+        let xml = "<metadata xmlns:dc=\"http://purl.org/dc/elements/1.1/\">";
+        xml += XHTML.textElement( "dc:identifier", this.#pub_id, { id: "pub-id" } );
+        xml += "<dc:language>en-US</dc:language>";
+        xml += XHTML.textElement( "dc:title", this.#title );
+        const d = new Date();
+        d.setUTCMilliseconds( 0 );
+        xml += "<meta property=\"dcterms:modified\">" + d.toISOString().replace( ".000", "" ) + "</meta>";
+        return xml + "</metadata>";
+    }
+
+    #renderSpine() {
+        let xml = "<spine>";
+        xml += "<itemref idref=\"toc\"/>";
+        xml += this.renderSpineElements();
+        return xml + "</spine>";
+    }
+
+    renderSpineElements() {
+        throw new Error( "must be implemented by subclass" );
+    }
+
+}
+
+export { EBook };

package/lib/ebook/ebookpage.js

@@ -0,0 +1,43 @@
+import * as fs from "node:fs";
+
+class EBookPage {
+
+    #fileName;
+    #title;
+
+    constructor( fileName, title ) {
+        this.#fileName = fileName;
+        this.#title = title;
+    }
+
+    create() {
+        let html = this.#renderPageStart( this.#title );
+        html += this.renderPageBody();
+        html += this.#renderPageEnd();
+        fs.writeFileSync( this.#fileName, html );
+    }
+
+    #renderBodyStart() {
+        return "<body>";
+    }
+
+    renderPageBody() {
+        throw new Error( "must be implemented by subclass" );
+    }
+
+    #renderPageEnd() {
+        return "</body></html>";
+    }
+
+    #renderPageStart( title ) {
+        let html = "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n";
+        html += "<html xmlns=\"http://www.w3.org/1999/xhtml\" xmlns:epub=\"http://www.idpf.org/2007/ops\">";
+        html += "<head><title>" + title + "</title>";
+        html += "<link href=\"./css/main.css\" rel=\"stylesheet\" />";
+        html += "</head>" + this.#renderBodyStart();
+        return html;
+    }
+
+}
+
+export { EBookPage };

package/lib/ebook/image.js

@@ -0,0 +1,21 @@
+class Image {
+
+    #src;
+    #credit;
+
+    constructor( src, credit ) {
+        this.#src = src;
+        this.#credit = credit;
+    }
+
+    getCaption() {
+        return this.#credit ? this.#credit : undefined;
+    }
+
+    getSrc() {
+        return this.#src;
+    }
+
+}
+
+export { Image };

package/lib/ebook/pages/taxonpage.js

@@ -0,0 +1,77 @@
+import sizeOf from "image-size";
+import markdownIt from "markdown-it";
+import { Config, Files } from "@ca-plant-list/ca-plant-list";
+import { EBookPage } from "../ebookpage.js";
+import { XHTML } from "../xhtml.js";
+
+class TaxonPage extends EBookPage {
+
+    #outputDir;
+    #taxon;
+    #photos;
+
+    constructor( outputDir, taxon, photos ) {
+        super( outputDir + "/" + taxon.getFileName(), taxon.getName() );
+        this.#outputDir = outputDir;
+        this.#taxon = taxon;
+        this.#photos = photos;
+    }
+
+    renderPageBody() {
+
+        function renderColors( colors ) {
+            if ( !colors ) {
+                return "";
+            }
+            let html = "";
+            for ( const color of colors ) {
+                html += XHTML.textElement( "span", "", { class: "color " + color } );
+            }
+            return html;
+        }
+
+
+        function renderCustomText( name ) {
+            // See if there is custom text.
+            const fileName = Config.getPackageDir() + "/data/text/" + name + ".md";
+            if ( !Files.exists( fileName ) ) {
+                return "";
+            }
+            const text = Files.read( fileName );
+            const md = new markdownIt();
+            return md.render( text );
+        }
+
+        const name = this.#taxon.getName();
+        let html = XHTML.textElement( "h1", name );
+
+        html += XHTML.textElement( "div", this.#taxon.getFamily().getName() );
+
+        const cn = this.#taxon.getCommonNames();
+        if ( cn && cn.length > 0 ) {
+            html += XHTML.textElement( "p", cn.join( ", " ) );
+        }
+
+        html += renderColors( this.#taxon.getFlowerColors() );
+
+        html += renderCustomText( this.#taxon.getBaseFileName() );
+
+        if ( this.#photos ) {
+            for ( const photo of this.#photos ) {
+                const src = photo.getSrc();
+                const dimensions = sizeOf( this.#outputDir + "/" + src );
+                let img = XHTML.textElement( "img", "", { src: src, style: "max-width:" + dimensions.width + "px" } );
+                const caption = photo.getCaption();
+                if ( caption ) {
+                    img += XHTML.textElement( "figcaption", caption );
+                }
+                html += XHTML.wrap( "figure", img );
+            }
+        }
+
+        return html;
+    }
+
+}
+
+export { TaxonPage };

package/lib/ebook/pages/tocpage.js

@@ -0,0 +1,30 @@
+import { HTML } from "@ca-plant-list/ca-plant-list";
+import { EBookPage } from "../ebookpage.js";
+
+class TOCPage extends EBookPage {
+
+    #taxa;
+
+    constructor( outputDir, taxa ) {
+        super( outputDir + "/toc.xhtml", "Table of Contents" );
+        this.#taxa = taxa;
+    }
+
+    renderPageBody() {
+
+        let html = "<nav id=\"toc\" role=\"doc-toc\" epub:type=\"toc\">";
+        html += "<h2 epub:type=\"title\">Table of Contents</h2>";
+
+        html += "<ol>";
+        for ( const taxon of this.#taxa ) {
+            html += "<li>" + HTML.getLink( "./" + taxon.getFileName(), taxon.getName() ) + "</li>";
+        }
+        html += "</ol>";
+
+        html += "</nav>";
+
+        return html;
+    }
+}
+
+export { TOCPage };

package/lib/ebook/plantbook.js

@@ -0,0 +1,122 @@
+import * as fs from "node:fs";
+import path from "node:path";
+import sharp from "sharp";
+import { CSV, Families, Files, Taxa } from "@ca-plant-list/ca-plant-list";
+import { EBook } from "./ebook.js";
+import { Image } from "./image.js";
+import { TaxonPage } from "./pages/taxonpage.js";
+import { TOCPage } from "./pages/tocpage.js";
+import { Config } from "../config.js";
+
+class PlantBook extends EBook {
+
+    #images = {};
+
+    constructor() {
+
+        super(
+            "output",
+            Config.getConfigValue( "ebook", "filename" ),
+            Config.getConfigValue( "ebook", "pub_id" ),
+            Config.getConfigValue( "ebook", "title" )
+        );
+
+        Families.init();
+
+    }
+
+    async createPages() {
+        await this.#importImages();
+
+        const contentDir = this.getContentDir();
+        const taxa = Taxa.getTaxa();
+        for ( const taxon of taxa ) {
+            const name = taxon.getName();
+            new TaxonPage( contentDir, taxon, this.#images[ name ] ).create();
+        }
+        new TOCPage( contentDir, taxa ).create();
+    }
+
+    #getMapEntry( map, key, initialValue ) {
+        const value = map[ key ];
+        if ( value ) {
+            return value;
+        }
+        map[ key ] = initialValue;
+        return initialValue;
+    }
+
+    async #importImages() {
+
+        const photoDirSrc = "external_data/photos";
+        const imagePrefix = "i";
+        const photoDirTarget = this.getContentDir() + "/" + imagePrefix;
+        fs.mkdirSync( photoDirSrc, { recursive: true } );
+        fs.mkdirSync( photoDirTarget, { recursive: true } );
+
+        const rows = CSV.parseFile( Config.getPackageDir() + "/data", "photos.csv" );
+        for ( const row of rows ) {
+
+            const name = row[ "taxon_name" ];
+            const taxon = Taxa.getTaxon( name );
+            if ( !taxon ) {
+                continue;
+            }
+
+            let imageList = this.#images[ name ];
+            if ( !imageList ) {
+                imageList = [];
+                this.#images[ name ] = imageList;
+            }
+
+            const src = new URL( row[ "source" ] );
+            const parts = path.parse( src.pathname ).dir.split( "/" );
+            const prefix = src.host.includes( "calflora" ) ? "cf-" : "inat-";
+            const filename = prefix + parts.slice( -1 )[ 0 ] + ".jpg";
+            const srcFileName = photoDirSrc + "/" + filename;
+            const targetFileName = photoDirTarget + "/" + filename;
+
+            if ( !fs.existsSync( srcFileName ) ) {
+                // File is not there; retrieve it.
+                console.log( "retrieving " + srcFileName );
+                await Files.fetch( src, srcFileName );
+            }
+
+            await new sharp( srcFileName ).resize( { width: 400 } ).jpeg( { quality: 40 } ).toFile( targetFileName );
+
+            imageList.push( new Image( imagePrefix + "/" + filename, row[ "credit" ] ) );
+
+        }
+    }
+
+    renderManifestEntries() {
+        let xml = "";
+
+        // Add taxon pages.
+        const taxa = Taxa.getTaxa();
+        for ( let index = 0; index < taxa.length; index++ ) {
+            const taxon = taxa[ index ];
+            xml += "<item id=\"t" + index + "\" href=\"" + taxon.getFileName() + "\" media-type=\"application/xhtml+xml\" />";
+        }
+
+        // Add images.
+        let index = 0;
+        for ( const imageList of Object.values( this.#images ) ) {
+            for ( const image of imageList ) {
+                xml += "<item id=\"i" + index + "\" href=\"" + image.getSrc() + "\" media-type=\"image/jpeg\" />";
+                index++;
+            }
+        }
+        return xml;
+    }
+
+    renderSpineElements() {
+        let xml = "";
+        for ( let index = 0; index < Taxa.getTaxa().length; index++ ) {
+            xml += "<itemref idref=\"t" + index + "\"/>";
+        }
+        return xml;
+    }
+}
+
+export { PlantBook };

package/lib/ebook/xhtml.js

@@ -0,0 +1,7 @@
+import { HTML } from "@ca-plant-list/ca-plant-list";
+
+class XHTML extends HTML {
+
+}
+
+export { XHTML };

package/lib/files.js

@@ -43,6 +43,10 @@ class Files {
         return response.headers;
     }
 
+    static getDirEntries( path ) {
+        return fs.readdirSync( path );
+    }
+
     static mkdir( path ) {
         fs.mkdirSync( path, { recursive: true } );
     }

package/lib/genera.js

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

package/lib/html.js

@@ -41,8 +41,11 @@ export class HTML {
         if ( escape && ( typeof text === "string" ) ) {
             text = this.escapeText( text );
         }
-        html += ">" + text + "</" + elName + ">";
-        return html;
+        // If tag is empty, make it self-closing so it is XHTML (epub) compatible.
+        if ( text === "" ) {
+            return html + "/>";
+        }
+        return html + ">" + text + "</" + elName + ">";
     }
 
     /**