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

package/lib/config.js

@@ -3,46 +3,69 @@ import * as url from "node:url";
 import { Files } from "./files.js";
 
 class Config {
+    static #packageDir = path.dirname(
+        path.dirname(url.fileURLToPath(import.meta.url))
+    );
 
-    static #packageDir = path.dirname( path.dirname( url.fileURLToPath( import.meta.url ) ) );
-
+    /** @type {Object<string,Object<string,Object<string,{}>>>} */
     #config = {};
 
-    constructor( dataDir ) {
-        this.#config = JSON.parse( Files.read( dataDir + "/config.json" ) );
+    /**
+     * @param {string} dataDir
+     */
+    constructor(dataDir) {
+        this.#config = JSON.parse(Files.read(dataDir + "/config.json"));
     }
 
-    getConfigValue( prefix, name, subcat, dflt ) {
-        const obj = this.#config[ prefix ];
-        if ( obj ) {
-            if ( Object.hasOwn( obj, name ) ) {
-                const nameObj = obj[ name ];
-                if ( nameObj === undefined ) {
+    /**
+     * @param {string} prefix
+     * @param {string} name
+     * @param {string|undefined} subcat
+     * @param {string} dflt
+     * @returns {string}
+     */
+    getConfigValue(prefix, name, subcat, dflt) {
+        const obj = this.#config[prefix];
+        if (obj) {
+            if (Object.hasOwn(obj, name)) {
+                const nameObj = obj[name];
+                if (nameObj === undefined) {
                     return dflt;
                 }
-                if ( subcat === undefined ) {
-                    return nameObj;
+                if (subcat === undefined) {
+                    return typeof nameObj === "string" ? nameObj : dflt;
                 }
-                if ( Object.hasOwn( nameObj, subcat ) ) {
-                    return nameObj[ subcat ];
+                if (Object.hasOwn(nameObj, subcat)) {
+                    const v = nameObj[subcat];
+                    return typeof v === "string" ? v : dflt;
                 }
             }
         }
         return dflt;
     }
 
+    /**
+     * @returns {string[]}
+     */
     getCountyCodes() {
-        return this.#config[ "counties" ];
+        const counties = this.#config["counties"];
+        if (counties instanceof Array) {
+            return counties;
+        }
+        return [];
     }
 
-    getLabel( name, dflt ) {
-        return this.getConfigValue( "labels", name, undefined, dflt );
+    /**
+     * @param {string} name
+     * @param {string} dflt
+     */
+    getLabel(name, dflt) {
+        return this.getConfigValue("labels", name, undefined, dflt);
     }
 
     static getPackageDir() {
         return this.#packageDir;
     }
-
 }
 
-export { Config };
+export { Config };

package/lib/csv.js

@@ -5,81 +5,99 @@ import { parse as parseSync } from "csv-parse/sync";
 import { parse } from "csv-parse";
 
 class CSV {
+    /**
+     * @param {string} dir
+     * @param {string} fileName
+     */
+    static getMap(dir, fileName) {
+        /** @type {string[]} */
+        let headers = [];
 
-    static getMap( dir, fileName ) {
-
-        let headers;
-
-        function setHeaders( h ) {
+        /**
+         * @param {string[]} h
+         */
+        function setHeaders(h) {
             headers = h;
             return h;
         }
 
-        const csv = this.parseFile( dir, fileName, setHeaders );
+        const csv = this.parseFile(dir, fileName, setHeaders);
+        /** @type {Object<string,string[]>} */
         const map = {};
-        for ( const row of csv ) {
-            map[ row[ headers[ 0 ] ] ] = row[ headers[ 1 ] ];
+        for (const row of csv) {
+            map[row[headers[0]]] = row[headers[1]];
         }
 
         return map;
     }
 
-    static #getOptions( fileName, columns, delimiter ) {
+    /**
+     * @param {string} fileName
+     * @param {import("csv-parse").ColumnOption[]|boolean|function (string[]):string[]} columns
+     * @param {string|undefined} delimiter
+     */
+    static #getOptions(fileName, columns, delimiter) {
+        /** @type {import("csv-parse").Options} */
         const options = { relax_column_count_less: true };
         options.columns = columns;
-        if ( path.extname( fileName ) === ".tsv" ) {
+        if (path.extname(fileName) === ".tsv") {
             options.delimiter = "\t";
             options.quote = false;
         } else {
             options.delimiter = delimiter ? delimiter : ",";
         }
-        if ( options.delimiter === "\t" ) {
+        if (options.delimiter === "\t") {
             options.quote = null;
         }
         return options;
     }
 
     /**
-     * @param {string} dir 
-     * @param {string} fileName 
-     * @param {boolean|undefined} [columns] 
-     * @param {string|undefined} [delimiter] 
+     * @param {string} dir
+     * @param {string} fileName
+     * @param {boolean|import("csv-parse").ColumnOption[]|function (string[]):string[]} [columns]
+     * @param {string} [delimiter]
      */
-    static parseFile( dir, fileName, columns = true, delimiter ) {
-        const content = fs.readFileSync( dir + "/" + fileName );
+    static parseFile(dir, fileName, columns = true, delimiter) {
+        const content = fs.readFileSync(dir + "/" + fileName);
 
-        const options = this.#getOptions( fileName, columns, delimiter );
-        return parseSync( content, options );
+        const options = this.#getOptions(fileName, columns, delimiter);
+        return parseSync(content, options);
     }
 
     /**
-     * @param {string} dir 
-     * @param {string} fileName 
-     * @param {boolean|undefined} columns 
-     * @param {string|undefined} delimiter 
-     * @param {*} callback 
+     * @param {string} dir
+     * @param {string} fileName
+     * @param {boolean|import("csv-parse").ColumnOption[]} columns
+     * @param {string|undefined} delimiter
+     * @param {function (any):void} callback
      */
-    static async parseStream( dir, fileName, columns = true, delimiter, callback ) {
-        const options = this.#getOptions( fileName, columns, delimiter );
+    static async parseStream(
+        dir,
+        fileName,
+        columns = true,
+        delimiter,
+        callback
+    ) {
+        const options = this.#getOptions(fileName, columns, delimiter);
         const processFile = async () => {
+            /** @type {string[][]} */
             const records = [];
             const parser = fs
-                .createReadStream( dir + "/" + fileName )
-                .pipe( parse( options ) );
-            parser.on( "readable", function () {
+                .createReadStream(dir + "/" + fileName)
+                .pipe(parse(options));
+            parser.on("readable", function () {
                 let record;
-                while ( ( record = parser.read() ) !== null ) {
-                    callback( record );
+                while ((record = parser.read()) !== null) {
+                    callback(record);
                 }
-            } );
-            await finished( parser );
+            });
+            await finished(parser);
             return records;
         };
         // Parse the CSV content
         await processFile();
-
     }
-
 }
 
-export { CSV };
+export { CSV };

package/lib/ebook/ebook.js

@@ -9,34 +9,40 @@ const MEDIA_TYPES = {
     XHTML: "application/xhtml+xml",
 };
 
+/**
+ * @type {Object<string,string>}
+ */
 const EXT_MEDIA_MAP = {
-    "jpeg": MEDIA_TYPES.JPG,
-    "jpg": MEDIA_TYPES.JPG,
-    "svg": MEDIA_TYPES.SVG,
+    jpeg: MEDIA_TYPES.JPG,
+    jpg: MEDIA_TYPES.JPG,
+    svg: MEDIA_TYPES.SVG,
 };
 
 class EBook {
-
     #outputDir;
     #filename;
     #pub_id;
     #title;
 
-    constructor( outputDir, filename, pub_id, title ) {
-
+    /**
+     *
+     * @param {string} outputDir
+     * @param {string} filename
+     * @param {string} pub_id
+     * @param {string} 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 } );
-
+        fs.rmSync(this.#outputDir, { force: true, recursive: true });
+        fs.mkdirSync(this.getContentDir(), { recursive: true });
     }
 
     async create() {
-
         const contentDir = this.getContentDir();
 
         this.#createContainerFile();
@@ -44,36 +50,35 @@ class EBook {
         this.#createPackageFile();
 
         // Copy assets
-        // const cssDirTarget = contentDir + "/css";
-        // fs.mkdirSync( cssDirTarget, { recursive: true } );
-        fs.cpSync( Config.getPackageDir() + "/ebook", contentDir, { recursive: true } );
+        fs.cpSync(Config.getPackageDir() + "/ebook", contentDir, {
+            recursive: true,
+        });
 
         this.createZip();
-
     }
 
     #createContainerFile() {
-
         const metaDir = this.#getMetaDir();
 
-        fs.mkdirSync( metaDir, { recursive: true } );
+        fs.mkdirSync(metaDir, { recursive: true });
 
-        let xml = "<?xml version=\"1.0\"?>"
-            + "<container version=\"1.0\" xmlns=\"urn:oasis:names:tc:opendocument:xmlns:container\">";
+        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 +=
+            '<rootfiles><rootfile full-path="epub/package.opf" media-type="application/oebps-package+xml" /></rootfiles>';
         xml += "</container>";
 
-        fs.writeFileSync( metaDir + "/container.xml", xml );
-
+        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\">";
+        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();
@@ -81,50 +86,67 @@ class EBook {
 
         xml += "</package>";
 
-        fs.writeFileSync( dir + "/package.opf", xml );
-
+        fs.writeFileSync(dir + "/package.opf", xml);
     }
 
     async createPages() {
-        throw new Error( "must be implemented by subclass" );
+        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.
-            }
-        );
+        const output = fs.createWriteStream(filename);
+        const archive = archiver("zip", {
+            zlib: { level: 9 }, // Sets the compression level.
+        });
 
-        archive.pipe( output );
+        archive.pipe(output);
 
-        archive.append( "application/epub+zip", { name: "mimetype", store: true } );
+        archive.append("application/epub+zip", {
+            name: "mimetype",
+            store: true,
+        });
 
-        archive.directory( this.#getMetaDir(), "META-INF" );
-        archive.directory( this.getContentDir(), "epub" );
+        archive.directory(this.#getMetaDir(), "META-INF");
+        archive.directory(this.getContentDir(), "epub");
 
         archive.finalize();
-
     }
 
     getContentDir() {
         return this.#outputDir + "/epub";
     }
 
-    static getManifestEntry( id, href, mediaType = MEDIA_TYPES.XHTML ) {
-        return "<item id=\"" + id + "\" href=\"" + href + "\" media-type=\"" + mediaType + "\" />";
+    /**
+     * @param {string} id
+     * @param {string} href
+     * @param {string} mediaType
+     */
+    static getManifestEntry(id, href, mediaType = MEDIA_TYPES.XHTML) {
+        return (
+            '<item id="' +
+            id +
+            '" href="' +
+            href +
+            '" media-type="' +
+            mediaType +
+            '" />'
+        );
     }
 
-    static getMediaTypeForExt( ext ) {
-        return EXT_MEDIA_MAP[ ext ];
+    /**
+     * @param {string} ext
+     */
+    static getMediaTypeForExt(ext) {
+        return EXT_MEDIA_MAP[ext];
     }
 
-    static getSpineEntry( id ) {
-        return "<itemref idref=\"" + id + "\"/>";
+    /**
+     * @param {string} id
+     */
+    static getSpineEntry(id) {
+        return '<itemref idref="' + id + '"/>';
     }
 
     #getMetaDir() {
@@ -133,38 +155,43 @@ class EBook {
 
     #renderManifest() {
         let xml = "<manifest>";
-        xml += "<item id=\"c0\" href=\"css/main.css\" media-type=\"text/css\" />";
+        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\" />";
+        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" );
+        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" } );
+        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 );
+        xml += XHTML.textElement("dc:title", this.#title);
         const d = new Date();
-        d.setUTCMilliseconds( 0 );
-        xml += "<meta property=\"dcterms:modified\">" + d.toISOString().replace( ".000", "" ) + "</meta>";
+        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 += '<itemref idref="toc"/>';
         xml += this.renderSpineElements();
         return xml + "</spine>";
     }
 
     renderSpineElements() {
-        throw new Error( "must be implemented by subclass" );
+        throw new Error("must be implemented by subclass");
     }
-
 }
 
-export { EBook };
+export { EBook };

package/lib/ebook/ebookpage.js

@@ -1,22 +1,27 @@
 import * as fs from "node:fs";
 
 class EBookPage {
-
     #fileName;
     #title;
     #rootPrefix;
 
-    constructor( fileName, title, rootPrefix = "" ) {
+    /**
+     *
+     * @param {string} fileName
+     * @param {string} title
+     * @param {string} rootPrefix
+     */
+    constructor(fileName, title, rootPrefix = "") {
         this.#fileName = fileName;
         this.#title = title;
         this.#rootPrefix = rootPrefix;
     }
 
     create() {
-        let html = this.#renderPageStart( this.#title );
+        let html = this.#renderPageStart(this.#title);
         html += this.renderPageBody();
         html += this.#renderPageEnd();
-        fs.writeFileSync( this.#fileName, html );
+        fs.writeFileSync(this.#fileName, html);
     }
 
     getTitle() {
@@ -28,22 +33,28 @@ class EBookPage {
     }
 
     renderPageBody() {
-        throw new Error( "must be implemented by subclass" );
+        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\">";
+    /**
+     * @param {string} title
+     */
+    #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=\"" + this.#rootPrefix + "css/main.css\" rel=\"stylesheet\" />";
+        html +=
+            '<link href="' +
+            this.#rootPrefix +
+            'css/main.css" rel="stylesheet" />';
         html += "</head>" + this.#renderBodyStart();
         return html;
     }
-
 }
 
-export { EBookPage };
+export { EBookPage };

package/lib/ebook/ebooksitegenerator.js

@@ -2,33 +2,55 @@ import { Files } from "../files.js";
 import { SiteGenerator } from "../sitegenerator.js";
 
 class EBookSiteGenerator extends SiteGenerator {
-
-    constructor( baseDir ) {
-        super( baseDir );
+    /**
+     * @param {string} baseDir
+     */
+    constructor(baseDir) {
+        super(baseDir);
     }
 
     #pageEnd() {
         return "</body></html>";
     }
 
-    #pageStart( depth, attributes ) {
-        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\">";
+    /**
+     * @param {number} depth
+     * @param {{title:string}} attributes
+     */
+    #pageStart(depth, attributes) {
+        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>" + attributes.title + "</title>";
-        html += "<link href=\"" + "../".repeat( depth ) + "css/main.css\" rel=\"stylesheet\" />";
+        html +=
+            '<link href="' +
+            "../".repeat(depth) +
+            'css/main.css" rel="stylesheet" />';
         html += "</head><body>";
         return html;
     }
 
-    #wrap( depth, content, attributes ) {
-        return this.#pageStart( depth, attributes ) + content + this.#pageEnd();
+    /**
+     * @param {number} depth
+     * @param {string} content
+     * @param {{title:string}} attributes
+     */
+    #wrap(depth, content, attributes) {
+        return this.#pageStart(depth, attributes) + content + this.#pageEnd();
     }
 
-    writeTemplate( content, attributes, filename ) {
-        const depth = ( filename.match( /\//g ) || [] ).length;
-        Files.write( Files.join( this.getBaseDir(), filename ), this.#wrap( depth, content, attributes ) );
+    /**
+     * @param {string} content
+     * @param {{title:string}} attributes
+     * @param {string} filename
+     */
+    writeTemplate(content, attributes, filename) {
+        const depth = (filename.match(/\//g) || []).length;
+        Files.write(
+            Files.join(this.getBaseDir(), filename),
+            this.#wrap(depth, content, attributes)
+        );
     }
-
 }
 
-export { EBookSiteGenerator };
+export { EBookSiteGenerator };

package/lib/ebook/glossarypages.js

@@ -2,39 +2,42 @@ import { GlossaryPages as BaseGlossaryPages } from "../web/glossarypages.js";
 import { EBook } from "./ebook.js";
 
 class GlossaryPages extends BaseGlossaryPages {
-
-    constructor( siteGenerator ) {
-        super( siteGenerator );
+    /**
+     * @param {SiteGenerator} siteGenerator
+     */
+    constructor(siteGenerator) {
+        super(siteGenerator);
     }
 
     getManifestEntries() {
-
         const glossaryEntries = this.getGlossary().getEntries();
         const manifestEntries = [];
 
-        manifestEntries.push( EBook.getManifestEntry( "g", "glossary.html" ) );
-        for ( let index = 0; index < glossaryEntries.length; index++ ) {
-            const entry = glossaryEntries[ index ];
-            manifestEntries.push( EBook.getManifestEntry( "g" + index, "g/" + entry.getHTMLFileName() ) );
+        manifestEntries.push(EBook.getManifestEntry("g", "glossary.html"));
+        for (let index = 0; index < glossaryEntries.length; index++) {
+            const entry = glossaryEntries[index];
+            manifestEntries.push(
+                EBook.getManifestEntry(
+                    "g" + index,
+                    "g/" + entry.getHTMLFileName()
+                )
+            );
         }
 
-        return manifestEntries.join( "" );
+        return manifestEntries.join("");
     }
 
     getSpineEntries() {
-
         const glossaryEntries = this.getGlossary().getEntries();
         const spineEntries = [];
 
-        spineEntries.push( EBook.getSpineEntry( "g", "glossary.html" ) );
-        for ( let index = 0; index < glossaryEntries.length; index++ ) {
-            spineEntries.push( EBook.getSpineEntry( "g" + index ) );
+        spineEntries.push(EBook.getSpineEntry("g"));
+        for (let index = 0; index < glossaryEntries.length; index++) {
+            spineEntries.push(EBook.getSpineEntry("g" + index));
         }
 
-        return spineEntries.join( "" );
-
+        return spineEntries.join("");
     }
-
 }
 
-export { GlossaryPages };
+export { GlossaryPages };