@lsbjordao/type-taxon-script 1.1.8 → 1.1.9

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/exportOntology.js

@@ -0,0 +1,356 @@
+"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;
+};
+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 fast_glob_1 = __importDefault(require("fast-glob"));
+const n3_1 = require("n3");
+const { namedNode, literal, quad, blankNode } = n3_1.DataFactory;
+const NS = {
+    tts: 'https://tts.example.org/ontology/',
+    inst: 'https://tts.example.org/instance/',
+    rdf: 'http://www.w3.org/1999/02/22-rdf-syntax-ns#',
+    rdfs: 'http://www.w3.org/2000/01/rdf-schema#',
+    owl: 'http://www.w3.org/2002/07/owl#',
+    skos: 'http://www.w3.org/2004/02/skos/core#',
+    xsd: 'http://www.w3.org/2001/XMLSchema#',
+    dcterms: 'http://purl.org/dc/terms/',
+    prov: 'http://www.w3.org/ns/prov#'
+};
+function tts(local) {
+    return namedNode(`${NS.tts}${encodeURIComponent(local)}`);
+}
+function inst(local) {
+    return namedNode(`${NS.inst}${encodeURIComponent(local)}`);
+}
+function rdf(local) {
+    return namedNode(`${NS.rdf}${local}`);
+}
+function rdfs(local) {
+    return namedNode(`${NS.rdfs}${local}`);
+}
+function owl(local) {
+    return namedNode(`${NS.owl}${local}`);
+}
+function skos(local) {
+    return namedNode(`${NS.skos}${local}`);
+}
+function xsd(local) {
+    return namedNode(`${NS.xsd}${local}`);
+}
+function dcterms(local) {
+    return namedNode(`${NS.dcterms}${local}`);
+}
+function prov(local) {
+    return namedNode(`${NS.prov}${local}`);
+}
+function createWriter() {
+    return new n3_1.Writer({
+        prefixes: {
+            tts: NS.tts,
+            inst: NS.inst,
+            rdf: NS.rdf,
+            rdfs: NS.rdfs,
+            owl: NS.owl,
+            skos: NS.skos,
+            xsd: NS.xsd,
+            dcterms: NS.dcterms,
+            prov: NS.prov
+        }
+    });
+}
+function writerToString(writer) {
+    return new Promise((resolve, reject) => {
+        writer.end((err, result) => {
+            if (err)
+                reject(err);
+            else
+                resolve(result);
+        });
+    });
+}
+function isClassLike(value) {
+    return typeof value === 'function' && !!value.prototype;
+}
+function isPrimitive(value) {
+    return (typeof value === 'string' ||
+        typeof value === 'number' ||
+        typeof value === 'boolean');
+}
+function normalizeDatatype(datatype) {
+    if (!datatype)
+        return null;
+    if (datatype.startsWith('xsd:')) {
+        return namedNode(datatype.replace('xsd:', NS.xsd));
+    }
+    if (datatype.startsWith('http://') || datatype.startsWith('https://')) {
+        return namedNode(datatype);
+    }
+    return null;
+}
+function addMappings(writer, subject, mappings) {
+    if (!(mappings === null || mappings === void 0 ? void 0 : mappings.length))
+        return;
+    for (const m of mappings) {
+        writer.addQuad(subject, skos(m.relation), namedNode(m.iri));
+    }
+}
+function toPascalLike(input) {
+    return input
+        .replace(/\.ts$/, '')
+        .replace(/[_\-\s]+([a-zA-Z0-9])/g, (_, c) => c.toUpperCase())
+        .replace(/^[a-z]/, c => c.toUpperCase());
+}
+function localId(value, fallback) {
+    var _a, _b;
+    return (_b = (_a = value === null || value === void 0 ? void 0 : value._id) !== null && _a !== void 0 ? _a : value === null || value === void 0 ? void 0 : value.id) !== null && _b !== void 0 ? _b : fallback;
+}
+function primitiveToLiteral(value) {
+    if (typeof value === 'string')
+        return literal(value);
+    if (typeof value === 'number')
+        return literal(String(value), xsd('decimal'));
+    return literal(String(value), xsd('boolean'));
+}
+function importModules(pattern) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const files = yield (0, fast_glob_1.default)(pattern, { absolute: true });
+        const modules = [];
+        for (const file of files) {
+            const mod = yield Promise.resolve(`${toFileUrl(file)}`).then(s => __importStar(require(s)));
+            modules.push({ file, mod });
+        }
+        return modules;
+    });
+}
+function toFileUrl(filePath) {
+    return `file://${path_1.default.resolve(filePath)}`;
+}
+function inferRangeFromValue(value) {
+    if (typeof value === 'number')
+        return xsd('decimal');
+    if (typeof value === 'boolean')
+        return xsd('boolean');
+    if (typeof value === 'string')
+        return xsd('string');
+    return null;
+}
+function serializeSourceLikeArray(writer, subject, values) {
+    for (const v of values) {
+        if (typeof v === 'string') {
+            writer.addQuad(subject, dcterms('source'), literal(v));
+        }
+        else if (v && typeof v === 'object') {
+            const refNode = blankNode();
+            writer.addQuad(subject, dcterms('source'), refNode);
+            for (const [rk, rv] of Object.entries(v)) {
+                if (rv == null)
+                    continue;
+                if (typeof rv === 'string') {
+                    writer.addQuad(refNode, tts(rk), literal(rv));
+                }
+                else if (typeof rv === 'number') {
+                    writer.addQuad(refNode, tts(rk), literal(String(rv), xsd('decimal')));
+                }
+                else if (typeof rv === 'boolean') {
+                    writer.addQuad(refNode, tts(rk), literal(String(rv), xsd('boolean')));
+                }
+            }
+        }
+    }
+}
+function serializeObject(writer, subject, object, objectTypeName, objectId, visited) {
+    var _a, _b, _c, _d;
+    if (visited.has(object))
+        return;
+    visited.add(object);
+    writer.addQuad(subject, rdf('type'), tts(objectTypeName));
+    for (const [key, value] of Object.entries(object)) {
+        if (value == null)
+            continue;
+        if (key.startsWith('_'))
+            continue;
+        if (key === 'sources' && Array.isArray(value)) {
+            serializeSourceLikeArray(writer, subject, value);
+            continue;
+        }
+        const predicate = tts(key);
+        if (isPrimitive(value)) {
+            writer.addQuad(subject, predicate, primitiveToLiteral(value));
+            continue;
+        }
+        if (Array.isArray(value)) {
+            for (let i = 0; i < value.length; i++) {
+                const item = value[i];
+                if (item == null)
+                    continue;
+                if (isPrimitive(item)) {
+                    writer.addQuad(subject, predicate, primitiveToLiteral(item));
+                }
+                else if (typeof item === 'object') {
+                    const childId = localId(item, `${objectId}-${key}-${i + 1}`);
+                    const childNode = inst(childId);
+                    writer.addQuad(subject, predicate, childNode);
+                    serializeObject(writer, childNode, item, (_b = (_a = item.constructor) === null || _a === void 0 ? void 0 : _a.name) !== null && _b !== void 0 ? _b : toPascalLike(key), childId, visited);
+                }
+            }
+            continue;
+        }
+        if (typeof value === 'object') {
+            const childId = localId(value, `${objectId}-${key}`);
+            const childNode = inst(childId);
+            writer.addQuad(subject, predicate, childNode);
+            serializeObject(writer, childNode, value, (_d = (_c = value.constructor) === null || _c === void 0 ? void 0 : _c.name) !== null && _d !== void 0 ? _d : toPascalLike(key), childId, visited);
+        }
+    }
+}
+function buildOntologyTTL() {
+    var _a, _b, _c, _d, _e, _f, _g;
+    return __awaiter(this, void 0, void 0, function* () {
+        const writer = createWriter();
+        const modules = yield importModules('./characters/v1/**/*.ts');
+        for (const { mod } of modules) {
+            for (const exported of Object.values(mod)) {
+                if (!isClassLike(exported))
+                    continue;
+                const cls = exported;
+                const classNode = tts(cls.name);
+                writer.addQuad(classNode, rdf('type'), owl('Class'));
+                writer.addQuad(classNode, rdfs('label'), literal((_b = (_a = cls.semantic) === null || _a === void 0 ? void 0 : _a.label) !== null && _b !== void 0 ? _b : cls.name));
+                if ((_c = cls.semantic) === null || _c === void 0 ? void 0 : _c.definition) {
+                    writer.addQuad(classNode, rdfs('comment'), literal(cls.semantic.definition));
+                }
+                addMappings(writer, classNode, (_d = cls.semantic) === null || _d === void 0 ? void 0 : _d.ontologyMappings);
+                const attrs = (_e = cls.semanticAttributes) !== null && _e !== void 0 ? _e : {};
+                for (const [attrName, meta] of Object.entries(attrs)) {
+                    const propNode = tts(attrName);
+                    const kind = meta.kind === 'object' ? owl('ObjectProperty') : owl('DatatypeProperty');
+                    writer.addQuad(propNode, rdf('type'), kind);
+                    writer.addQuad(propNode, rdfs('domain'), classNode);
+                    writer.addQuad(propNode, rdfs('label'), literal((_f = meta.label) !== null && _f !== void 0 ? _f : attrName));
+                    if (meta.definition) {
+                        writer.addQuad(propNode, rdfs('comment'), literal(meta.definition));
+                    }
+                    const dt = normalizeDatatype(meta.datatype);
+                    if (dt) {
+                        writer.addQuad(propNode, rdfs('range'), dt);
+                    }
+                    if (meta.unit) {
+                        writer.addQuad(propNode, dcterms('format'), literal(meta.unit));
+                    }
+                    addMappings(writer, propNode, meta.ontologyMappings);
+                    if ((_g = meta.allowedValues) === null || _g === void 0 ? void 0 : _g.length) {
+                        for (const value of meta.allowedValues) {
+                            writer.addQuad(propNode, tts('allowedValue'), literal(value));
+                        }
+                    }
+                }
+            }
+        }
+        return writerToString(writer);
+    });
+}
+function buildInstancesTTL(genus) {
+    var _a, _b;
+    return __awaiter(this, void 0, void 0, function* () {
+        const writer = createWriter();
+        const modules = yield importModules(`./taxon/${genus}/**/*.ts`);
+        const visited = new WeakSet();
+        for (const { file, mod } of modules) {
+            const fileName = path_1.default.basename(file, '.ts');
+            for (const [exportName, exported] of Object.entries(mod)) {
+                if (!exported || typeof exported !== 'object')
+                    continue;
+                const subjectId = localId(exported, exportName || fileName);
+                const subjectNode = inst(subjectId);
+                serializeObject(writer, subjectNode, exported, (_b = (_a = exported.constructor) === null || _a === void 0 ? void 0 : _a.name) !== null && _b !== void 0 ? _b : toPascalLike(fileName), subjectId, visited);
+            }
+        }
+        return writerToString(writer);
+    });
+}
+function mergeTTL(ttls) {
+    const nonEmpty = ttls.filter(Boolean);
+    if (!nonEmpty.length)
+        return '';
+    const prefixLines = new Set();
+    const bodies = [];
+    for (const ttl of nonEmpty) {
+        const lines = ttl.split('\n');
+        const localBody = [];
+        for (const line of lines) {
+            if (line.startsWith('@prefix')) {
+                prefixLines.add(line);
+            }
+            else {
+                localBody.push(line);
+            }
+        }
+        bodies.push(localBody.join('\n').trim());
+    }
+    return `${Array.from(prefixLines).join('\n')}\n\n${bodies.join('\n\n')}\n`;
+}
+function ttsExportOntology(genus) {
+    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('./characters/v1')) {
+            console.error('\x1b[31m✖ Directory ./characters/v1 not found.\x1b[0m');
+            return;
+        }
+        if (!fs_1.default.existsSync(`./taxon/${genus}`)) {
+            console.error(`\x1b[31m✖ Directory ./taxon/${genus} not found.\x1b[0m`);
+            return;
+        }
+        fs_1.default.mkdirSync('./output', { recursive: true });
+        const ontologyTTL = yield buildOntologyTTL();
+        const instancesTTL = yield buildInstancesTTL(genus);
+        const semanticTTL = mergeTTL([ontologyTTL, instancesTTL]);
+        const ontologyPath = `./output/${genus}Ontology.ttl`;
+        const instancesPath = `./output/${genus}Instances.ttl`;
+        const semanticPath = `./output/${genus}Semantic.ttl`;
+        fs_1.default.writeFileSync(ontologyPath, ontologyTTL, 'utf8');
+        fs_1.default.writeFileSync(instancesPath, instancesTTL, 'utf8');
+        fs_1.default.writeFileSync(semanticPath, semanticTTL, 'utf8');
+        console.log(`\x1b[1m\x1b[32m✔ Ontology schema exported: \x1b[33m${ontologyPath}\x1b[0m`);
+        console.log(`\x1b[1m\x1b[32m✔ RDF instances exported: \x1b[33m${instancesPath}\x1b[0m`);
+        console.log(`\x1b[1m\x1b[32m✔ Combined semantic graph exported: \x1b[33m${semanticPath}\x1b[0m`);
+    });
+}
+exports.default = ttsExportOntology;

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;