@lsbjordao/type-taxon-script 1.1.5 → 1.1.7

package/dist/export.js

@@ -0,0 +1,238 @@
+"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 });
+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 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 ttsExport(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/';
+                            console.log(`\x1b[1m\x1b[32m✔ JSON database exported: \x1b[33m${filePath}${genus}DB.json\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/';
+                            console.log(`\x1b[1m\x1b[32m✔ JSON database exported: \x1b[33m${filePath}${genus}DB.json\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();
+                            }
+                        });
+                    });
+                });
+            }));
+        }
+    });
+}
+exports.default = ttsExport;

package/dist/exportSources.js

@@ -0,0 +1,63 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const lodash_1 = __importDefault(require("lodash"));
+function ttsExportSources(genus) {
+    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 filePath = `./output/${genus}DB.json`;
+    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 findObjectsWithSources = (obj, currentPath = []) => {
+                let objectsWithSources = [];
+                const findObjectsWithSourcesRecursively = (currentObj, path) => {
+                    if (lodash_1.default.isObject(currentObj)) {
+                        lodash_1.default.forOwn(currentObj, (value, key) => {
+                            if (key === 'sources' && Array.isArray(value) && value.length > 0) {
+                                value.forEach((source) => {
+                                    objectsWithSources.push({
+                                        index: path[0],
+                                        path: path.join('.'),
+                                        specificEpithet: lodash_1.default.get(jsonData[path[0]], 'specificEpithet'),
+                                        source: source
+                                    });
+                                });
+                            }
+                            if (lodash_1.default.isObject(value)) {
+                                findObjectsWithSourcesRecursively(value, [...path, key]);
+                            }
+                        });
+                    }
+                };
+                findObjectsWithSourcesRecursively(obj, currentPath);
+                objectsWithSources.forEach(item => {
+                    item.path = item.path.replace(new RegExp(`^${item.index}\\.|${item.index}$`), '');
+                });
+                return objectsWithSources;
+            };
+            const objectsWithSources = findObjectsWithSources(jsonData.map((item, index) => (Object.assign(Object.assign({}, item), { index }))));
+            const filePathOutput = `./output/${genus}SourcesDB.json`;
+            const jsonContent = JSON.stringify(objectsWithSources, null, 2);
+            fs_1.default.writeFileSync(filePathOutput, jsonContent, 'utf-8');
+            console.log(`\x1b[1m\x1b[32m✔ Database exported: \x1b[33m${filePathOutput}\x1b[0m\x1b[1m\x1b[32m\x1b[0m`);
+        }
+        catch (jsonErr) {
+            console.error('Error parsing JSON:', jsonErr);
+        }
+    });
+}
+exports.default = ttsExportSources;

package/dist/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 });
+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();
+                            }
+                        });
+                    });
+                });
+            }));
+        }
+    });
+}
+exports.default = ttsExportToCsv;

package/dist/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 });
+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);
+        }
+    });
+}
+exports.default = ttsfindProperty;

package/dist/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 });
+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')
+        }
+    });
+}
+exports.default = ttsImportFromCsv;

package/dist/init.js

@@ -0,0 +1,131 @@
+"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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+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');
+            }
+        }
+    });
+}
+exports.default = ttsInit;

package/dist/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 });
+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);
+    }
+}
+exports.default = ttsNewDesc;

package/dist/tts.js

@@ -0,0 +1,130 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const yargs_1 = __importDefault(require("yargs"));
+const init_1 = __importDefault(require("./init"));
+const new_1 = __importDefault(require("./new"));
+const import_1 = __importDefault(require("./import"));
+const export_1 = __importDefault(require("./export"));
+const exportSources_1 = __importDefault(require("./exportSources"));
+const exportToCsv_1 = __importDefault(require("./exportToCsv"));
+const findProperty_1 = __importDefault(require("./findProperty"));
+yargs_1.default.version();
+yargs_1.default.command({
+    command: 'init',
+    describe: 'Initiate a TTS project',
+    builder: {},
+    handler: () => (0, init_1.default)(),
+});
+yargs_1.default.command({
+    command: 'new',
+    describe: 'Create a new description entry',
+    builder: {
+        genus: {
+            describe: 'Genus name',
+            demandOption: true,
+            type: 'string',
+        },
+        species: {
+            describe: 'Specific epithet',
+            demandOption: true,
+            type: 'string',
+        },
+    },
+    handler: (argv) => {
+        (0, new_1.default)(argv.genus, argv.species);
+    },
+});
+yargs_1.default.command({
+    command: 'import',
+    describe: 'Import taxa and characters from CSV file',
+    builder: {
+        genus: {
+            describe: 'Genus name',
+            demandOption: true,
+            type: 'string',
+        },
+    },
+    handler: (argv) => {
+        (0, import_1.default)(argv.genus);
+    },
+});
+yargs_1.default.command({
+    command: 'export',
+    describe: 'Export a JSON database',
+    builder: {
+        genus: {
+            describe: 'Genus name',
+            demandOption: true,
+            type: 'string',
+        },
+        load: {
+            describe: 'Load a list of taxa to export from the csv file: "./input/taxaToExport.csv".',
+            demandOption: false,
+            type: 'string',
+            choices: ['all', 'csv'],
+            default: 'all'
+        }
+    },
+    handler: (argv) => {
+        (0, export_1.default)(argv.genus, argv.load);
+    },
+});
+yargs_1.default.command({
+    command: 'exportSources',
+    describe: 'Export sources database',
+    builder: {
+        genus: {
+            describe: 'Genus name',
+            demandOption: true,
+            type: 'string',
+        },
+    },
+    handler: (argv) => {
+        (0, exportSources_1.default)(argv.genus);
+    },
+});
+yargs_1.default.command({
+    command: 'exportToCsv',
+    describe: 'Export a CSV database',
+    builder: {
+        genus: {
+            describe: 'Genus name',
+            demandOption: true,
+            type: 'string',
+        },
+        load: {
+            describe: 'Load a list of taxa to export from the csv file: "./input/taxaToExport.csv".',
+            demandOption: false,
+            type: 'string',
+            choices: ['all', 'csv'],
+            default: 'all'
+        }
+    },
+    handler: (argv) => {
+        (0, exportToCsv_1.default)(argv.genus, argv.load);
+    },
+});
+yargs_1.default.command({
+    command: 'findProperty',
+    describe: 'Find a property',
+    builder: {
+        property: {
+            describe: 'Property path to find',
+            demandOption: true,
+            type: 'string',
+        },
+        genus: {
+            describe: 'Genus name',
+            demandOption: true,
+            type: 'string',
+        }
+    },
+    handler: (argv) => {
+        (0, findProperty_1.default)(argv.property, argv.genus);
+    },
+});
+yargs_1.default
+    .parse();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lsbjordao/type-taxon-script",
-  "version": "1.1.5",
+  "version": "1.1.7",
   "author": "Lucas Jordão <tucarj@gmail.com> & André Eppinghaus <andreeppinghaus@gmail.com> & Vicente Calfo <vicentecalfo@gmail.com>",
   "license": "ISC",
   "description": "TypeTaxonScript",
@@ -24,10 +24,10 @@
   },
   "main": "dist/tts.js",
   "files": [
-    "dist"
+    "dist", "bin"
   ],
   "scripts": {
-    "tts": "tsc ./src/tts.ts"
+    "build": "tsc"
   },
   "bin": {
     "tts": "./bin/tts"