@ca-plant-list/ca-plant-list 0.3.2 → 0.3.4

package/lib/families.js

@@ -4,30 +4,38 @@ import { Jepson } from "./jepson.js";
 import { Taxa } from "./taxa.js";
 import { Files } from "./files.js";
 import { Config } from "./config.js";
+// eslint-disable-next-line no-unused-vars
+import { Taxon } from "./index.js";
 
 class Family {
-
     #name;
     #data;
 
-    constructor( name, data ) {
+    /**
+     * @param {string} name
+     * @param {*} data
+     */
+    constructor(name, data) {
         this.#name = name;
         this.#data = data;
     }
 
-    addTaxon( taxon ) {
-        if ( !this.#data.taxa ) {
+    /**
+     * @param {Taxon} taxon
+     */
+    addTaxon(taxon) {
+        if (!this.#data.taxa) {
             this.#data.taxa = [];
         }
-        this.#data.taxa.push( taxon );
-        Sections.addTaxon( this.getSectionName(), taxon );
+        this.#data.taxa.push(taxon);
+        Sections.addTaxon(this.getSectionName(), taxon);
     }
 
     getBaseFileName() {
         return this.getName();
     }
 
-    getFileName( ext = "html" ) {
+    getFileName(ext = "html") {
         return this.getBaseFileName() + "." + ext;
     }
 
@@ -46,163 +54,190 @@ class Family {
     getTaxa() {
         return this.#data.taxa;
     }
-
 }
 
 class Families {
+    #families;
 
-    static #families;
-
-    static {
-
+    constructor() {
         const dataDir = Config.getPackageDir() + "/data";
 
-        this.#families = JSON.parse( Files.read( dataDir + "/families.json" ) );
-        for ( const [ k, v ] of Object.entries( this.#families ) ) {
-            this.#families[ k ] = new Family( k, v );
+        this.#families = JSON.parse(Files.read(dataDir + "/families.json"));
+        for (const [k, v] of Object.entries(this.#families)) {
+            this.#families[k] = new Family(k, v);
         }
-
     }
 
-    static getFamilies() {
-        return Object.values( this.#families ).sort( ( a, b ) => a.getName().localeCompare( b.getName() ) );
+    getFamilies() {
+        return Object.values(this.#families).sort((a, b) =>
+            a.getName().localeCompare(b.getName())
+        );
     }
 
-    static getFamily( familyName ) {
-        return this.#families[ familyName ];
+    /**
+     * @param {string} familyName
+     */
+    getFamily(familyName) {
+        return this.#families[familyName];
     }
 
-    static renderPages( outputDir, taxaColumns ) {
-        new PageFamilyList( outputDir, this.#families ).render( taxaColumns );
+    /**
+     * @param {string} outputDir
+     * @param {import("./index.js").TaxaCol[]} taxaColumns
+     */
+    renderPages(outputDir, taxaColumns) {
+        new PageFamilyList(outputDir, this.#families).render(taxaColumns);
 
-        const names = Object.keys( this.#families );
-        for ( const name of names.sort() ) {
-            const family = this.#families[ name ];
-            if ( family.getTaxa() ) {
-                new PageFamily( outputDir, family ).render( taxaColumns );
+        const names = Object.keys(this.#families);
+        for (const name of names.sort()) {
+            const family = this.#families[name];
+            if (family.getTaxa()) {
+                new PageFamily(outputDir, family).render(taxaColumns);
             }
         }
     }
-
 }
 
 class PageFamilyList extends GenericPage {
-
     #families;
 
-    constructor( outputDir, families ) {
-        super( outputDir, "Families", "list_families" );
+    /**
+     * @param {string} outputDir
+     * @param {Object<string,Family>} families
+     */
+    constructor(outputDir, families) {
+        super(outputDir, "Families", "list_families");
         this.#families = families;
     }
 
-    render( taxaColumns ) {
-
+    /**
+     * @param {import("./index.js").TaxaCol[]} taxaColumns
+     */
+    render(taxaColumns) {
         let html = this.getDefaultIntro();
 
         const sections = Sections.getSections();
         const sectionLinks = [];
-        for ( const name of Object.keys( sections ).sort() ) {
-
-            const taxa = sections[ name ];
+        for (const name of Object.keys(sections).sort()) {
+            const taxa = sections[name];
 
             // Render the section page.
-            new PageSection( this.getOutputDir(), name, taxa ).render( taxaColumns );
+            new PageSection(this.getOutputDir(), name, taxa).render(
+                taxaColumns
+            );
 
             // Render the link.
             const href = "./" + name + ".html";
-            sectionLinks.push( HTML.getLink( href, name ) + " (" + taxa.length + ")" );
+            sectionLinks.push(
+                HTML.getLink(href, name) + " (" + taxa.length + ")"
+            );
         }
-        html += HTML.wrap( "ul", HTML.arrayToLI( sectionLinks ), { class: "listmenu" } );
+        html += HTML.wrap("ul", HTML.arrayToLI(sectionLinks), {
+            class: "listmenu",
+        });
 
         html += "<table>";
         html += "<thead>";
-        html += HTML.textElement( "th", "Family" );
-        html += HTML.textElement( "th", "Number of Species", { class: "right" } );
+        html += HTML.textElement("th", "Family");
+        html += HTML.textElement("th", "Number of Species", { class: "right" });
         html += "</thead>";
 
         html += "<tbody>";
-        const names = Object.keys( this.#families ).sort();
-        for ( const name of names ) {
-            const family = this.#families[ name ];
+        const names = Object.keys(this.#families).sort();
+        for (const name of names) {
+            const family = this.#families[name];
             const taxa = family.getTaxa();
-            if ( !taxa ) {
+            if (!taxa) {
                 continue;
             }
-            let cols = HTML.wrap( "td", HTML.getLink( "./" + family.getFileName(), family.getName() ) );
-            cols += HTML.wrap( "td", taxa.length, { class: "right" } );
-            html += HTML.wrap( "tr", cols );
+            let cols = HTML.wrap(
+                "td",
+                HTML.getLink("./" + family.getFileName(), family.getName())
+            );
+            cols += HTML.wrap("td", taxa.length, { class: "right" });
+            html += HTML.wrap("tr", cols);
         }
         html += "</tbody>";
 
         html += "</table>";
 
-        this.writeFile( html );
+        this.writeFile(html);
     }
 }
 
 class PageFamily extends GenericPage {
-
     #family;
 
-    constructor( outputDir, family ) {
-        super( outputDir, family.getName(), family.getBaseFileName() );
+    /**
+     * @param {string} outputDir
+     * @param {Family} family
+     */
+    constructor(outputDir, family) {
+        super(outputDir, family.getName(), family.getBaseFileName());
         this.#family = family;
     }
 
-    render( columns ) {
-
+    /**
+     *
+     * @param {import("./index.js").TaxaCol[]} columns
+     */
+    render(columns) {
         let html = this.getDefaultIntro();
 
         html += HTML.wrap(
             "div",
-            Jepson.getEFloraLink( this.#family.getJepsonID() ),
+            Jepson.getEFloraLink(this.#family.getJepsonID()),
             { class: "section" }
         );
 
-        html += Taxa.getHTMLTable( this.#family.getTaxa(), columns );
-
-        this.writeFile( html );
+        html += Taxa.getHTMLTable(this.#family.getTaxa(), columns);
 
+        this.writeFile(html);
     }
 }
 
 class PageSection extends GenericPage {
-
     #taxa;
 
-    constructor( outputDir, name, taxa ) {
-        super( outputDir, name, name );
+    /**
+     * @param {string} outputDir
+     * @param {string} name
+     * @param {Taxon[]} taxa
+     */
+    constructor(outputDir, name, taxa) {
+        super(outputDir, name, name);
         this.#taxa = taxa;
     }
 
-    render( columns ) {
-
+    render(columns) {
         let html = this.getDefaultIntro();
 
-        html += Taxa.getHTMLTable( this.#taxa, columns );
-
-        this.writeFile( html );
+        html += Taxa.getHTMLTable(this.#taxa, columns);
 
+        this.writeFile(html);
     }
 }
 
 class Sections {
-
+    /** @type {Object<string,Taxon[]} */
     static #sections = {};
 
-    static addTaxon( name, taxon ) {
-        let section = this.#sections[ name ];
-        if ( !section ) {
+    /**
+     * @param {string} name
+     * @param {Taxon} taxon
+     */
+    static addTaxon(name, taxon) {
+        let section = this.#sections[name];
+        if (!section) {
             section = [];
-            this.#sections[ name ] = section;
+            this.#sections[name] = section;
         }
-        section.push( taxon );
+        section.push(taxon);
     }
 
     static getSections() {
         return this.#sections;
     }
-
 }
 
-export { Families };
+export { Families };

package/lib/files.js

@@ -3,91 +3,149 @@ import * as path from "node:path";
 import { default as unzipper } from "unzipper";
 
 class Files {
-
-    static copyDir( srcDir, targetDir ) {
-        fs.cpSync( srcDir, targetDir, { recursive: true } );
+    /**
+     * @param {string} srcDir
+     * @param {string} targetDir
+     */
+    static copyDir(srcDir, targetDir) {
+        fs.cpSync(srcDir, targetDir, { recursive: true });
     }
 
-    static createFileFromStream( fileName, inStream ) {
-
-        function implementation( fileName, inStream, resolve ) {
-            const outStream = fs.createWriteStream( fileName );
-            outStream.on( "finish", () => { resolve( true ); } );
-            inStream.pipe( outStream );
+    /**
+     * @param {string} fileName
+     * @param {*} inStream
+     * @access private
+     */
+    static #createFileFromStream(fileName, inStream) {
+        /**
+         *
+         * @param {string} fileName
+         * @param {*} inStream
+         * @param {*} resolve
+         */
+        function implementation(fileName, inStream, resolve) {
+            const outStream = fs.createWriteStream(fileName);
+            outStream.on("finish", () => {
+                resolve(true);
+            });
+            inStream.pipe(outStream);
         }
 
-        return new Promise( ( resolve ) => { implementation( fileName, inStream, resolve ); } );
+        return new Promise((resolve) => {
+            implementation(fileName, inStream, resolve);
+        });
     }
 
-    static exists( path ) {
-        return fs.existsSync( path );
+    /**
+     * @param {string} path
+     * @returns {boolean}
+     */
+    static exists(path) {
+        return fs.existsSync(path);
     }
 
     /**
      * Retrieve data from a URL and write it to a file. If the response status is anything other than 200, an Error is thrown.
-     * @param {string|URL} url 
+     * @param {string|URL} url
      * @param {string|undefined} targetFileName If targetFileName is undefined, the data will be retrieved but not written to a file.
      * @param {Object} [headers={}] Request Headers.
      * @returns {Promise<Headers>} The Response headers.
      */
-    static async fetch( url, targetFileName, headers = {} ) {
-        const response = await fetch( url, headers );
-        if ( response.status !== 200 ) {
-            throw new Error( response.status + " retrieving " + url );
+    static async fetch(url, targetFileName, headers = {}) {
+        const response = await fetch(url, headers);
+        if (response.status !== 200) {
+            throw new Error(response.status + " retrieving " + url);
         }
         const data = await response.blob();
         const arrayBuffer = await data.arrayBuffer();
-        const buffer = Buffer.from( arrayBuffer );
-        if ( targetFileName ) {
-            fs.writeFileSync( targetFileName, buffer );
+        const buffer = Buffer.from(arrayBuffer);
+        if (targetFileName) {
+            fs.writeFileSync(targetFileName, buffer);
         }
         return response.headers;
     }
 
-    static getDirEntries( path ) {
-        return fs.readdirSync( path );
+    /**
+     * @param {string} path
+     * @returns {string[]}
+     */
+    static getDirEntries(path) {
+        return fs.readdirSync(path);
     }
 
-    static isDir( path ) {
-        const stats = fs.statSync( path, { throwIfNoEntry: false } );
+    /**
+     * @param {string} path
+     * @returns {boolean}
+     */
+    static isDir(path) {
+        const stats = fs.statSync(path, { throwIfNoEntry: false });
         return stats !== undefined && stats.isDirectory();
     }
 
-    static join( ...paths ) {
-        return path.join( ...paths ).replaceAll( "\\", "/" );
+    /**
+     * @param {string[]} paths
+     * @returns {string}
+     */
+    static join(...paths) {
+        return path.join(...paths).replaceAll("\\", "/");
     }
 
-    static mkdir( path ) {
-        fs.mkdirSync( path, { recursive: true } );
+    /**
+     * @param {string} path
+     */
+    static mkdir(path) {
+        fs.mkdirSync(path, { recursive: true });
     }
 
-    static read( path ) {
-        return fs.readFileSync( path, "utf8" );
+    /**
+     * @param {string} path
+     * @returns {string}
+     */
+    static read(path) {
+        return fs.readFileSync(path, "utf8");
     }
 
-    static rmDir( dir ) {
-        fs.rmSync( dir, { force: true, recursive: true, maxRetries: 2, retryDelay: 1000 } );
+    /**
+     * @param {string} dir
+     */
+    static rmDir(dir) {
+        fs.rmSync(dir, {
+            force: true,
+            recursive: true,
+            maxRetries: 2,
+            retryDelay: 1000,
+        });
     }
 
-    static write( path, data, overwrite = false ) {
-        if ( !overwrite && this.exists( path ) ) {
-            throw new Error( path + " already exists" );
+    /**
+     * @param {string} path
+     * @param {string} data
+     * @param {boolean} overwrite
+     */
+    static write(path, data, overwrite = false) {
+        if (!overwrite && this.exists(path)) {
+            throw new Error(path + " already exists");
         }
-        fs.writeFileSync( path, data );
+        fs.writeFileSync(path, data);
     }
 
-    static async zipFileExtract( zipFilePath, fileNameToUnzip, targetFilePath ) {
-
-        const zipDir = await unzipper.Open.file( zipFilePath );
-        for ( const entry of zipDir.files ) {
-            if ( entry.path === fileNameToUnzip ) {
-                await this.createFileFromStream( targetFilePath, entry.stream() );
+    /**
+     * @param {string} zipFilePath
+     * @param {string} fileNameToUnzip
+     * @param {string} targetFilePath
+     */
+    static async zipFileExtract(zipFilePath, fileNameToUnzip, targetFilePath) {
+        const zipDir = await unzipper.Open.file(zipFilePath);
+        for (const entry of zipDir.files) {
+            if (entry.path === fileNameToUnzip) {
+                await this.#createFileFromStream(
+                    targetFilePath,
+                    entry.stream()
+                );
                 break;
             }
         }
-
     }
-
 }
 
-export { Files };
+export { Files };

package/lib/genera.js

@@ -1,62 +1,76 @@
 import { Config } from "./config.js";
 import { Families } from "./families.js";
 import { Files } from "./files.js";
+// eslint-disable-next-line no-unused-vars
+import { Taxon } from "./taxon.js";
 
 class Genera {
+    #families;
+    #genera;
 
-    static #genera;
-
-    static {
+    /**
+     * @param {Families} families
+     */
+    constructor(families) {
         const dataDir = Config.getPackageDir() + "/data";
-        this.#genera = JSON.parse( Files.read( dataDir + "/genera.json" ) );
+        this.#genera = JSON.parse(Files.read(dataDir + "/genera.json"));
+        this.#families = families;
     }
 
-    static addTaxon( taxon ) {
-
+    /**
+     * @param {Taxon} taxon
+     */
+    addTaxon(taxon) {
         const genusName = taxon.getGenusName();
-        const genusData = this.#genera[ genusName ];
-        if ( !genusData ) {
-            console.log( taxon.getName() + " genus not found" );
+        const genusData = this.#genera[genusName];
+        if (!genusData) {
+            console.log(taxon.getName() + " genus not found");
             return;
         }
 
-        if ( genusData.taxa === undefined ) {
+        if (genusData.taxa === undefined) {
             genusData.taxa = [];
         }
-        genusData.taxa.push( taxon );
+        genusData.taxa.push(taxon);
 
-        const family = this.getFamily( genusName );
-        if ( !family ) {
-            console.log( taxon.getName() + " family not found" );
+        const family = this.getFamily(genusName);
+        if (!family) {
+            console.log(taxon.getName() + " family not found");
             return;
         }
-        family.addTaxon( taxon );
+        family.addTaxon(taxon);
     }
 
-    static getGenus( genusName ) {
-        return new Genus( this.#genera[ genusName ] );
+    /**
+     * @param {string} genusName
+     */
+    getGenus(genusName) {
+        return new Genus(this.#genera[genusName]);
     }
 
-    static getFamily( genusName ) {
-        const genus = this.#genera[ genusName ];
-        if ( genus ) {
-            return Families.getFamily( genus.family );
+    /**
+     * @param {string} genusName
+     */
+    getFamily(genusName) {
+        const genus = this.#genera[genusName];
+        if (genus) {
+            return this.#families.getFamily(genus.family);
         }
     }
-
 }
 
 class Genus {
-
     #data;
 
-    constructor( data ) {
+    constructor(data) {
         this.#data = data;
     }
 
     getTaxa() {
-        return this.#data.taxa.sort( ( a, b ) => a.getName().localeCompare( b.getName() ) );
+        return this.#data.taxa.sort((a, b) =>
+            a.getName().localeCompare(b.getName())
+        );
     }
 }
 
-export { Genera };
+export { Genera };

package/lib/generictaxaloader.js

@@ -1,16 +1,22 @@
-import { ErrorLog } from "./errorlog.js";
+import { ErrorLog } from "./index.js";
 
 class GenericTaxaLoader {
-
     #options;
     #errorLog;
+    /** @type {import("./index.js").Taxa|undefined}*/
     #taxa;
 
-    constructor( options ) {
+    /**
+     * @param {*} options
+     */
+    constructor(options) {
         this.#options = options;
-        this.#errorLog = new ErrorLog( options.outputdir + "/errors.tsv" );
+        this.#errorLog = new ErrorLog(options.outputdir + "/errors.tsv");
     }
 
+    /**
+     * @returns {ErrorLog}
+     */
     getErrorLog() {
         return this.#errorLog;
     }
@@ -27,14 +33,16 @@ class GenericTaxaLoader {
         this.#taxa = await this.loadTaxa();
     }
 
+    /**
+     * @return {Promise<import("./index.js").Taxa>}
+     */
     async loadTaxa() {
-        throw new Error( "must be implemented by subclass" );
+        throw new Error("must be implemented by subclass");
     }
 
     writeErrorLog() {
         this.#errorLog.write();
     }
-
 }
 
-export { GenericTaxaLoader };
+export { GenericTaxaLoader };