@lsbjordao/type-taxon-script 1.1.8 → 1.1.9

package/dist/src/exportToCsv.js

@@ -0,0 +1,268 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = ttsExportToCsv;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
+const csv_parser_1 = __importDefault(require("csv-parser"));
+const plainjs_1 = require("@json2csv/plainjs");
+const transforms_1 = require("@json2csv/transforms");
+const cli_spinner_1 = require("cli-spinner");
+function deleteJSFiles(folderPath) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const files = yield fs_1.default.promises.readdir(folderPath);
+            for (const file of files) {
+                if (file.endsWith('.js')) {
+                    yield fs_1.default.promises.unlink(`${folderPath}/${file}`);
+                }
+            }
+        }
+        catch (err) {
+            console.error('Error deleting files:', err);
+        }
+    });
+}
+function ttsExportToCsv(genus, load) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (genus === '') {
+            console.error('\x1b[31m✖ Argument `--genus` cannot be empty.\x1b[0m');
+            return;
+        }
+        if (!fs_1.default.existsSync('./input') && !fs_1.default.existsSync('./output')) {
+            console.error("\x1b[31m✖ The ./input and ./output directories are not present within the project.\x1b[0m\n\x1b[36mℹ️ Please run \x1b[33m`tts init`\x1b[36m before attempting to export a database.\x1b[0m");
+            return;
+        }
+        const spinner = new cli_spinner_1.Spinner('\x1b[36mProcessing... %s\x1b[0m');
+        spinner.setSpinnerString('|/-\\'); // spinner sequence
+        spinner.start();
+        const taxa = [];
+        fs_1.default.mkdirSync('./temp', { recursive: true });
+        if (load === 'all') {
+            const directoryPath = `./taxon/${genus}/`;
+            fs_1.default.readdir(directoryPath, (err, files) => {
+                if (err) {
+                    spinner.stop();
+                    console.error('Error reading directory:', err);
+                    process.exit();
+                }
+                const taxa = files
+                    .filter(file => file.endsWith('.ts') && file !== 'index.ts')
+                    .map(file => path_1.default.parse(file).name);
+                const importStatements = taxa.map((species) => {
+                    return `import { ${species.replace(/\s/g, '_').replace(/\-([a-z])/, (_, match) => match.toUpperCase())} } from '../taxon/${genus}/${species.replace(/\s/g, '_')}'`;
+                }).join('\n');
+                const speciesCall = taxa.map((species) => {
+                    return `    ${species.replace(/\s/g, '_').replace(/\-([a-z])/, (_, match) => match.toUpperCase())},`;
+                }).join('\n');
+                const fileContent = `// Import genus ${genus}
+import { ${genus} } from '../taxon/${genus}'
+            
+// Import species of ${genus}
+${importStatements}
+            
+const ${genus}_species: ${genus}[] = [
+    ${speciesCall}
+]
+            
+// Export ${genus}DB.json
+//import { writeFileSync } from 'fs'
+const jsonData = JSON.stringify(${genus}_species);
+console.log(jsonData)
+//const inputFilePath = '../output/${genus}DB.json'
+//writeFileSync(inputFilePath, jsonData, 'utf-8')
+//console.log('\\x1b[1m\\x1b[32m✔ Process finished.\\x1b[0m')`;
+                const tempFilePath = './temp/exportTemp.ts';
+                fs_1.default.writeFileSync(tempFilePath, fileContent, 'utf-8');
+                const fileToTranspile = 'exportTemp';
+                (0, child_process_1.exec)(`tsc ./temp/${fileToTranspile}.ts`, (error, stdout, stderr) => {
+                    if (stdout) {
+                        spinner.stop();
+                        console.error('\x1b[31m✖ TS Error:\x1b[0m\n\n' + `${stdout}`);
+                        process.exit();
+                    }
+                    if (stderr) {
+                        spinner.stop();
+                        console.error('\x1b[31m✖ TS Error:\x1b[0m\n\n' + `${stderr}`);
+                        process.exit();
+                    }
+                    try {
+                        fs_1.default.unlinkSync(`./temp/${fileToTranspile}.ts`);
+                    }
+                    catch (err) {
+                        spinner.stop();
+                        console.error(`An error occurred while deleting the file: ${err}`);
+                        process.exit();
+                    }
+                    (0, child_process_1.exec)(`node ./temp/${fileToTranspile}.js > ./output/${genus}DB.json`, (error, stdout, stderr) => {
+                        // if (error) {
+                        //     spinner.stop()
+                        //     console.error('\x1b[31m✖ JS execution time error:\x1b[0m\n\n' + `${error.message}`)
+                        //     process.exit()
+                        // }
+                        if (stdout) {
+                            spinner.stop();
+                            console.error('\x1b[31m✖ JS execution time error:\x1b[0m\n\n' + `${stdout}`);
+                            process.exit();
+                        }
+                        if (stderr) {
+                            spinner.stop();
+                            console.error('\x1b[31m✖ JS execution time error:\x1b[0m\n\n' + `${stderr}`);
+                            process.exit();
+                        }
+                        deleteJSFiles(`./taxon/${genus}`).then(() => {
+                            const filePath = './output/';
+                            try {
+                                const data = fs_1.default.readFileSync(`./output/${genus}DB.json`, 'utf8');
+                                const opts = {
+                                    transforms: [
+                                        (0, transforms_1.flatten)({ separator: '.' })
+                                    ]
+                                };
+                                const parser = new plainjs_1.Parser(opts);
+                                const csv = parser.parse(JSON.parse(data));
+                                fs_1.default.writeFileSync(`./output/${genus}DB.csv`, csv);
+                            }
+                            catch (err) {
+                                console.error('Error reading the file:', err);
+                            }
+                            console.log(`\x1b[1m\x1b[32m✔ CSV database exported: \x1b[33m${filePath}${genus}DB.csv\x1b[0m\x1b[1m\x1b[32m\x1b[0m`);
+                            spinner.stop();
+                            try {
+                                fs_1.default.unlinkSync(`./temp/${fileToTranspile}.js`);
+                                fs_1.default.rm('./temp', { recursive: true }, (err) => {
+                                    if (err) {
+                                        console.error('Error deleting directory:', err);
+                                        process.exit();
+                                    }
+                                });
+                            }
+                            catch (err) {
+                                console.error(`An error occurred while deleting the file: ${err}`);
+                                process.exit();
+                            }
+                        });
+                    });
+                });
+            });
+        }
+        if (load === 'csv') {
+            const inputFilePath = './input/taxaToExport.csv';
+            const tempFilePath = './temp/exportTemp.ts';
+            fs_1.default.createReadStream(inputFilePath)
+                .pipe((0, csv_parser_1.default)({ headers: false }))
+                .on('data', (data) => {
+                taxa.push(data['0']);
+            })
+                .on('end', () => __awaiter(this, void 0, void 0, function* () {
+                const importStatements = taxa.map((species) => {
+                    return `import { ${species.replace(/\s/g, '_').replace(/\-([a-z])/, (_, match) => match.toUpperCase())} } from '../taxon/${genus}/${species.replace(/\s/g, '_')}'`;
+                }).join('\n');
+                const speciesCall = taxa.map((species) => {
+                    return `    ${species.replace(/\s/g, '_').replace(/\-([a-z])/, (_, match) => match.toUpperCase())},`;
+                }).join('\n');
+                const fileContent = `// Import genus ${genus}
+import { ${genus} } from '../taxon/${genus}'
+                
+// Import species of ${genus}
+${importStatements}
+                
+const ${genus}_species: ${genus}[] = [
+    ${speciesCall}
+]
+                
+// Export ${genus}DB.json
+const jsonData = JSON.stringify(${genus}_species);
+console.log(jsonData)
+// import { writeFileSync } from 'fs'
+// const jsonData = JSON.stringify(${genus}_species)
+// const inputFilePath = '../output/${genus}DB.json'
+// writeFileSync(inputFilePath, jsonData, 'utf-8')
+// console.log('\\x1b[1m\\x1b[32m✔ Process finished.\\x1b[0m')`;
+                fs_1.default.writeFileSync(tempFilePath, fileContent, 'utf-8');
+                const fileToTranspile = 'exportTemp';
+                (0, child_process_1.exec)(`tsc ./temp/${fileToTranspile}.ts`, (error, stdout, stderr) => {
+                    if (stdout) {
+                        spinner.stop();
+                        console.error('\x1b[31m✖ TS Error:\x1b[0m\n\n' + `${stdout}`);
+                        process.exit();
+                    }
+                    if (stderr) {
+                        spinner.stop();
+                        console.error('\x1b[31m✖ TS Error:\x1b[0m\n\n' + `${stdout}`);
+                        process.exit();
+                    }
+                    try {
+                        fs_1.default.unlinkSync(`./temp/${fileToTranspile}.ts`);
+                    }
+                    catch (err) {
+                        spinner.stop();
+                        console.error(`An error occurred while deleting the file: ${err}`);
+                        process.exit();
+                    }
+                    (0, child_process_1.exec)(`node ./temp/${fileToTranspile}.js > ./output/${genus}DB.json`, (error, stdout, stderr) => {
+                        // if (error) {
+                        //     spinner.stop()
+                        //     console.error('\x1b[31m✖ JS execution time error:\x1b[0m\n\n' + `${error.message}`)
+                        //     process.exit()
+                        // }
+                        if (stdout) {
+                            spinner.stop();
+                            console.error('\x1b[31m✖ JS execution time error:\x1b[0m\n\n' + `${stdout}`);
+                            process.exit();
+                        }
+                        if (stderr) {
+                            spinner.stop();
+                            console.error('\x1b[31m✖ JS execution time error:\x1b[0m\n\n' + `${stderr}`);
+                            process.exit();
+                        }
+                        deleteJSFiles(`./taxon/${genus}`).then(() => {
+                            const filePath = './output/';
+                            try {
+                                const data = fs_1.default.readFileSync(`./output/${genus}DB.json`, 'utf8');
+                                const opts = {
+                                    transforms: [
+                                        (0, transforms_1.flatten)({ separator: '.' })
+                                    ]
+                                };
+                                const parser = new plainjs_1.Parser(opts);
+                                const csv = parser.parse(JSON.parse(data));
+                                fs_1.default.writeFileSync(`./output/${genus}DB.csv`, csv);
+                            }
+                            catch (err) {
+                                console.error('Error reading the file:', err);
+                            }
+                            console.log(`\x1b[1m\x1b[32m✔ CSV database exported: \x1b[33m${filePath}${genus}DB.csv\x1b[0m\x1b[1m\x1b[32m\x1b[0m`);
+                            spinner.stop();
+                            try {
+                                fs_1.default.unlinkSync(`./temp/${fileToTranspile}.js`);
+                                fs_1.default.rm('./temp', { recursive: true }, (err) => {
+                                    if (err) {
+                                        console.error('Error deleting directory:', err);
+                                        process.exit();
+                                    }
+                                });
+                            }
+                            catch (err) {
+                                console.error(`An error occurred while deleting the file: ${err}`);
+                                process.exit();
+                            }
+                        });
+                    });
+                });
+            }));
+        }
+    });
+}

package/dist/src/findProperty.js

@@ -0,0 +1,58 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = ttsfindProperty;
+const fs_1 = __importDefault(require("fs"));
+const lodash_1 = __importDefault(require("lodash"));
+function ttsfindProperty(property, genus) {
+    if (property === '') {
+        console.error('\x1b[31m✖ Argument `--property` cannot be empty.\x1b[0m');
+        return;
+    }
+    if (genus === '') {
+        console.error('\x1b[31m✖ Argument `--genus` cannot be empty.\x1b[0m');
+        return;
+    }
+    const filePath = `./output/${genus}DB.json`;
+    const propertyPathToFind = property;
+    fs_1.default.readFile(filePath, 'utf8', (err, data) => {
+        if (err) {
+            console.error('Error reading the file:', err);
+            return;
+        }
+        try {
+            const jsonData = JSON.parse(data);
+            const findPropertyPath = (obj, propertyPath, currentPath = []) => {
+                const paths = [];
+                const findPathsRecursively = (currentObj, path) => {
+                    const lastKey = path[path.length - 1];
+                    if (lodash_1.default.get(currentObj, propertyPath)) {
+                        if (typeof lastKey !== 'number') {
+                            paths.push(path.join('.'));
+                        }
+                    }
+                    lodash_1.default.forEach(currentObj, (value, key) => {
+                        if (lodash_1.default.isObject(value)) {
+                            findPathsRecursively(value, [...path, key]);
+                        }
+                    });
+                };
+                findPathsRecursively(obj, currentPath);
+                return paths;
+            };
+            const resultIndicesAndPaths = jsonData.flatMap((item, index) => {
+                const paths = findPropertyPath(item, propertyPathToFind);
+                if (paths.length > 0) {
+                    return { index, paths, specificEpithet: jsonData[index].specificEpithet };
+                }
+                return [];
+            });
+            console.log(`\x1b[36mℹ️ Indices and paths of objects with the property \x1b[33m${propertyPathToFind}\x1b[0m\x1b[36m:\n\n\x1b[0m`, resultIndicesAndPaths);
+        }
+        catch (jsonErr) {
+            console.error('Error parsing JSON:', jsonErr);
+        }
+    });
+}

package/dist/src/import.js

@@ -0,0 +1,98 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = ttsImportFromCsv;
+const fs_1 = __importDefault(require("fs"));
+const csv_parser_1 = __importDefault(require("csv-parser"));
+const mustache_1 = __importDefault(require("mustache"));
+const mapColumns = {
+    'specificEpithet': 'specificEpithet',
+    'descriptionAuthorship': 'descriptionAuthorship',
+    'leaf.bipinnate.pinnae.numberOfPairs.rarelyMin': 'leafBipinnatePinnaeNumberOfPairsRarelyMin',
+    'leaf.bipinnate.pinnae.numberOfPairs.min': 'leafBipinnatePinnaeNumberOfPairsMin',
+    'leaf.bipinnate.pinnae.numberOfPairs.max': 'leafBipinnatePinnaeNumberOfPairsMax',
+    'leaf.bipinnate.pinnae.numberOfPairs.rarelyMax': 'leafBipinnatePinnaeNumberOfPairsRarelyMax',
+    'leaf.bipinnate.pinnae.numberOfPairs.value': 'leafBipinnatePinnaeNumberOfPairsValue',
+    'leaf.bipinnate.pinnae.leaflet.numberOfPairs.rarelyMin': 'leafBipinnatePinnaeLeafletNumberOfPairsRarelyMin',
+    'leaf.bipinnate.pinnae.leaflet.numberOfPairs.min': 'leafBipinnatePinnaeLeafletNumberOfPairsMin',
+    'leaf.bipinnate.pinnae.leaflet.numberOfPairs.max': 'leafBipinnatePinnaeLeafletNumberOfPairsMax',
+    'leaf.bipinnate.pinnae.leaflet.numberOfPairs.rarelyMax': 'leafBipinnatePinnaeLeafletNumberOfPairsRarelyMax',
+    'leaf.bipinnate.pinnae.leaflet.numberOfPairs.value': 'leafBipinnatePinnaeLeafletNumberOfPairsValue',
+    'inflorescence.type': 'inflorescenceType',
+    'inflorescence.shape': 'inflorescenceShape',
+    'flower.merism': 'flowerMerism',
+    'flower.numberWhorlsOfStamens': 'numberWhorlsOfStamens',
+    'flower.calyx.shape': 'flowerCalyxShape',
+    'flower.corolla.shape': 'flowerCorollaShape',
+    'androecium.filaments.colour': 'androeciumFilamentsColour',
+    'timestamp': 'timestamp'
+};
+let genusErrorShown = {};
+function generateDescription(taxon, genus) {
+    try {
+        const template = fs_1.default.readFileSync(`./taxon/${genus}/${genus}_template.txt`, 'utf-8');
+        const outputDir = 'output/';
+        const context = {};
+        for (const column in mapColumns) {
+            const templateColumn = mapColumns[column];
+            if (taxon[column]) {
+                context[templateColumn] = taxon[column];
+            }
+        }
+        if (taxon['inflorescence.capitate'] === 'yes') {
+            context['capitateInflorescence'] = true;
+        }
+        if (taxon['inflorescence.spicate'] === 'yes') {
+            context['spicateInflorescence'] = true;
+        }
+        let sanitizeSpecificEpithet = taxon['specificEpithet'].replace(/\s/g, '_');
+        sanitizeSpecificEpithet = sanitizeSpecificEpithet.replace(/-(\w)/, function (match, p1) {
+            return p1.toUpperCase();
+        });
+        context['specificEpithet'] = sanitizeSpecificEpithet;
+        let output = mustache_1.default.render(template, context);
+        const specificEpithet = taxon['specificEpithet'];
+        const fileName = `${outputDir}${genus}_${specificEpithet.replace(/\s/g, '_')}.ts`;
+        // timestamp
+        output = output.replace('date:', `date: ` + Math.floor(Date.now() / 1000));
+        output = output
+            .replace(/'\[/g, '[')
+            .replace(/\]'/g, ']')
+            .replace(/'/g, '\'');
+        if (output.trim() !== '') {
+            fs_1.default.writeFileSync(fileName, output);
+            console.log(`\x1b[1m\x1b[32m✔ New script file: \x1b[0m\x1b[1m\x1b[33m./${fileName}\x1b[0m`);
+        }
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            if (genus !== '' && !genusErrorShown[genus]) {
+                console.error(`\x1b[31m✖ A TTS project for genus \x1b[33m\x1b[3m${genus}\x1b[0m\x1b[31m has not been implemented yet.\x1b[0m`);
+                console.log('\x1b[36m   + ℹ️ To create a new TTS project, visit:\x1b[0m');
+                console.log('\x1b[33m     https://www.npmjs.com/package/typetaxonscript?activeTab=readme#creating-and-editing-a-genus-template.\x1b[0m');
+                genusErrorShown[genus] = true;
+            }
+        }
+        else {
+            console.error('An error occurred while reading the file:', error);
+        }
+    }
+}
+function ttsImportFromCsv(genus) {
+    if (genus === '') {
+        console.error('\x1b[31m✖ Argument `--genus` cannot be empty.\x1b[0m');
+        return;
+    }
+    fs_1.default.createReadStream('./input/importTaxa.csv')
+        .pipe((0, csv_parser_1.default)({ separator: ';' }))
+        .on('data', (taxon) => {
+        generateDescription(taxon, genus);
+    })
+        .on('end', () => {
+        if (!genusErrorShown[genus]) {
+            //console.log('\x1b[1m\x1b[32m✔ Process finished.\x1b[0m')
+        }
+    });
+}

package/dist/src/init.js

@@ -0,0 +1,141 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = ttsInit;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+function createInputCSVFiles() {
+    const inputDir = 'input';
+    if (!fs.existsSync(inputDir)) {
+        fs.mkdirSync(inputDir);
+        console.log('\x1b[36mℹ️ The', '\x1b[33m./input', '\x1b[36mdirectory has been created.\x1b[0m');
+        const taxaToExportContent = `Mimosa afranioi
+Mimosa arenosa var arenosa
+Mimosa aurivillus var calothamnos
+Mimosa bimucronata
+Mimosa blanchetii
+Mimosa caesalpiniifolia
+Mimosa campicola
+Mimosa cordistipula
+Mimosa cubatanensis
+Mimosa debilis var debilis
+Mimosa diplotricha var diplotricha
+Mimosa dolens var dolens
+Mimosa dryandroides var dryandroides
+Mimosa elliptica`;
+        const importTaxaContent = `"specificEpithet";"leaf.bipinnate.pinnae.numberOfPairs.rarelyMin";"leaf.bipinnate.pinnae.numberOfPairs.min";"leaf.bipinnate.pinnae.numberOfPairs.max";"leaf.bipinnate.pinnae.numberOfPairs.rarelyMax";"leaf.bipinnate.pinnae.numberOfPairs.value";"leaf.bipinnate.pinnae.leaflet.numberOfPairs.rarelyMin";"leaf.bipinnate.pinnae.leaflet.numberOfPairs.min";"leaf.bipinnate.pinnae.leaflet.numberOfPairs.max";"leaf.bipinnate.pinnae.leaflet.numberOfPairs.rarelyMax";"leaf.bipinnate.pinnae.leaflet.numberOfPairs.value";"inflorescence.spicate";"inflorescence.capitate";"flower.merism";"flower.calyx.shape";"flower.corolla.shape";"flower.numberWhorlsOfStamens";"androecium.filaments.colour";"descriptionAuthorship"
+"arenosa var arenosa";"";"4";"12";"";"";"";"12";"30";"";"";"yes";"";"['4-merous', '5-merous']";"campanulate";"turbinate";"diplostemonous";"withish";"June Doe"
+"artemisiana";"";"7";"12";"";"";"";"15";"29";"";"";"yes";"";"4-merous";"campanulate";"campanulate";"diplostemonous";"withish";"June Doe"
+"ceratonia var pseudo-obovata";"";"2";"4";"5";"";"";"2";"4";"5";"";"";"yes";"3-merous";"campanulate";"turbinate";"diplostemonous";"withish";"June Doe"`;
+        const taxaToExportPath = path.join(inputDir, 'taxaToExport.csv');
+        const importTaxaPath = path.join(inputDir, 'importTaxa.csv');
+        fs.writeFileSync(taxaToExportPath, taxaToExportContent);
+        fs.writeFileSync(importTaxaPath, importTaxaContent);
+        console.log('\x1b[36mℹ️ The', '\x1b[33m./input/importTaxa.csv', '\x1b[36mfile has been created.\x1b[0m');
+        console.log('\x1b[90m  + This file is needed to execute the `import` command.\x1b[0m');
+        console.log('\x1b[90m  + It is a simple headerless CSV with each taxon on a separate line/row.\x1b[0m');
+        console.log('\x1b[36mℹ️ The', '\x1b[33m./input/taxaToExport.csv', '\x1b[36mfile has been created.\x1b[0m');
+        console.log('\x1b[90m  + This file is needed to execute argument `--load csv` of `export` command.\x1b[0m');
+        console.log('\x1b[90m  + It is used to export a specific list of taxa instead of exporting all, which is the default setting.\x1b[0m');
+    }
+}
+function ttsInit() {
+    // Checking directories
+    fs.readdir('./', (err, dirs) => {
+        if (err) {
+            console.error('Error reading directories:', err);
+            return;
+        }
+        if (dirs.length === 0) {
+            console.error('\x1b[36mℹ️ The directory is empty. Please clone a TTS project first.\x1b[0m');
+            console.log('\x1b[36mℹ️ Please, visit:\x1b[0m');
+            console.log('\x1b[36m  TypeTaxonScript package:', '\x1b[33mhttps://www.npmjs.com/package/@lsbjordao/type-taxon-script.\x1b[0m');
+            console.log('\x1b[36m  TTS project (Mimosa):', '\x1b[33mhttps://github.com/lsbjordao/TTS-Mimosa.\x1b[0m');
+            return;
+        }
+        if (!dirs.includes('taxon') && !dirs.includes('character')) {
+            console.error('\x1b[36mℹ️ The directory does not contain a TTS project.\x1b[0m');
+            console.log('\x1b[36mℹ️ Please, visit:\x1b[0m');
+            console.log('\x1b[36m  TypeTaxonScript package:', '\x1b[33mhttps://www.npmjs.com/package/@lsbjordao/type-taxon-script.\x1b[0m');
+            console.log('\x1b[36m  TTS project (Mimosa):', '\x1b[33mhttps://github.com/lsbjordao/TTS-Mimosa.\x1b[0m');
+            return;
+        }
+        const requiredDirs = ['input', 'output', 'characters', 'taxon'];
+        const allRequiredDirsPresent = requiredDirs.every(dir => dirs.includes(dir));
+        if (allRequiredDirsPresent) {
+            console.error('\x1b[36mℹ️ The root directory is not clean. Look:\x1b[0m');
+            const listDirectoryTree = (dir, prefix = '') => {
+                const files = fs.readdirSync(dir);
+                files.forEach((file, index) => {
+                    const filePath = path.join(dir, file);
+                    const isDirectory = fs.statSync(filePath).isDirectory();
+                    const isLast = index === files.length - 1;
+                    console.log(`${prefix}${isLast ? '└──' : '├──'} ${file}`);
+                    if (isDirectory) {
+                        const nestedPrefix = `${prefix}${isLast ? '   ' : '│  '}`;
+                        listDirectoryTree(filePath, nestedPrefix);
+                    }
+                });
+            };
+            const excludedDirectories = ['node_modules', '.git', 'dist'];
+            const hasPreviousProject = (dir, prefix = '') => {
+                const files = fs.readdirSync(dir, { withFileTypes: true });
+                const directories = files
+                    .filter(dirent => dirent.isDirectory() && !excludedDirectories.includes(dirent.name))
+                    .map(dirent => dirent.name);
+                directories.forEach((directory, index) => {
+                    const directoryPath = path.join(dir, directory);
+                    const isLast = index === directories.length - 1;
+                    console.log(`${prefix}${isLast ? '└──' : '├──'} ${directory}`);
+                    const nestedPrefix = `${prefix}${isLast ? '   ' : '│  '}`;
+                    hasPreviousProject(directoryPath, nestedPrefix);
+                });
+            };
+            hasPreviousProject('./');
+            console.error('\x1b[36mℹ️ A previous project is already found.\x1b[0m');
+            return;
+        }
+        else {
+            createInputCSVFiles();
+            const outputDir = 'output';
+            if (!fs.existsSync(outputDir)) {
+                fs.mkdirSync(outputDir);
+                const gitKeepFile = `${outputDir}/.gitkeep`;
+                fs.writeFileSync(gitKeepFile, '');
+                console.log('\x1b[36mℹ️ The', '\x1b[33m./output', '\x1b[36mdirectory has been created.\x1b[0m');
+            }
+        }
+    });
+}

package/dist/src/new.js

@@ -0,0 +1,47 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = ttsNewDesc;
+const fs_1 = __importDefault(require("fs"));
+const mustache_1 = __importDefault(require("mustache"));
+function ttsNewDesc(genus, species) {
+    try {
+        if (species === '') {
+            console.error('\x1b[31m✖ Argument `--species` cannot be empty.\x1b[0m');
+            return;
+        }
+        if (genus === '') {
+            console.error('\x1b[31m✖ Argument `--genus` cannot be empty.\x1b[0m');
+            return;
+        }
+        const outputDir = 'output/';
+        const templatePath = `./taxon/${genus}/${genus}_template.txt`;
+        if (!fs_1.default.existsSync(templatePath)) {
+            console.error(`\x1b[31m✖ A TTS project for genus \x1b[33m\x1b[3m${genus}\x1b[0m\x1b[31m has not been implemented yet.\x1b[0m`);
+            console.log('\x1b[36m   + ℹ️ To create a new TTS project, visit:\x1b[0m');
+            console.log('\x1b[33m     https://www.npmjs.com/package/typetaxonscript?activeTab=readme#creating-and-editing-a-genus-template.\x1b[0m');
+            return;
+        }
+        const template = fs_1.default.readFileSync(templatePath, 'utf-8');
+        let sanitizeSpecificEpithet = species.replace(/\s/g, '_');
+        sanitizeSpecificEpithet = sanitizeSpecificEpithet.replace(/-(\w)/, function (match, p1) {
+            return p1.toUpperCase();
+        });
+        const context = {
+            specificEpithet: sanitizeSpecificEpithet
+        };
+        let output = mustache_1.default.render(template, context);
+        const fileName = `${outputDir}${genus}_${species.replace(/\s/g, '_')}.ts`;
+        // timestamp
+        output = output.replace('date:', `date: ` + Math.floor(Date.now() / 1000));
+        if (output.trim() !== '') {
+            fs_1.default.writeFileSync(fileName, output);
+            console.log(`\x1b[1m\x1b[32m✔ New script file: \x1b[0m\x1b[1m\x1b[33m./${fileName}\x1b[0m`);
+        }
+    }
+    catch (error) {
+        console.error('An error occurred:', error);
+    }
+}