@lsbjordao/type-taxon-script 1.1.18 → 1.1.19

package/dist/exportOntology.js

@@ -18,7 +18,7 @@ const child_process_1 = require("child_process");
 const fast_glob_1 = __importDefault(require("fast-glob"));
 const n3_1 = require("n3");
 const tscBin = require.resolve('typescript/bin/tsc');
-const { namedNode, literal, quad, blankNode } = n3_1.DataFactory;
+const { namedNode, literal, blankNode } = n3_1.DataFactory;
 const NS = {
     tts: 'https://tts.example.org/ontology/',
     inst: 'https://tts.example.org/instance/',
@@ -30,6 +30,7 @@ const NS = {
     dcterms: 'http://purl.org/dc/terms/',
     prov: 'http://www.w3.org/ns/prov#'
 };
+const ONTOLOGY_IRI = namedNode(NS.tts);
 function tts(local) {
     return namedNode(`${NS.tts}${encodeURIComponent(local)}`);
 }
@@ -54,9 +55,6 @@ function 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: {
@@ -114,6 +112,9 @@ function toPascalLike(input) {
         .replace(/[_\-\s]+([a-zA-Z0-9])/g, (_, c) => c.toUpperCase())
         .replace(/^[a-z]/, c => c.toUpperCase());
 }
+function capitalize(input) {
+    return input.charAt(0).toUpperCase() + input.slice(1);
+}
 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;
@@ -125,31 +126,78 @@ function primitiveToLiteral(value) {
         return literal(String(value), xsd('decimal'));
     return literal(String(value), xsd('boolean'));
 }
+function getLatestCharactersVersion() {
+    const baseDir = './characters';
+    if (!fs_1.default.existsSync(baseDir))
+        return null;
+    const versions = fs_1.default.readdirSync(baseDir)
+        .filter(d => /^v\d+$/.test(d))
+        .map(d => ({ dir: d, num: parseInt(d.slice(1), 10) }))
+        .sort((a, b) => b.num - a.num);
+    return versions.length > 0 ? versions[0].dir : null;
+}
+function shouldSkipClass(cls) {
+    return !cls.name || cls.name.startsWith('_');
+}
+function getRelationPredicateName(fieldName, relation) {
+    if (relation === null || relation === void 0 ? void 0 : relation.predicate)
+        return relation.predicate;
+    return `has${capitalize(fieldName)}`;
+}
+function getRelationAnchor(relation) {
+    // relationIri takes precedence — anchors directly to external ontology (e.g. RO)
+    if (relation === null || relation === void 0 ? void 0 : relation.relationIri) {
+        return namedNode(relation.relationIri);
+    }
+    // fallback to tts-local anchor based on relationType label
+    switch (relation === null || relation === void 0 ? void 0 : relation.relationType) {
+        case 'partOf':
+            return tts('partOf');
+        case 'hasComponent':
+            return tts('hasComponent');
+        case 'hasPart':
+        default:
+            return tts('hasPart');
+    }
+}
 function importModules(pattern) {
     var _a, _b;
     return __awaiter(this, void 0, void 0, function* () {
         const tsFiles = yield (0, fast_glob_1.default)(pattern, { absolute: true });
         if (tsFiles.length === 0)
             return [];
-        const tempDir = path_1.default.join(process.cwd(), 'temp');
+        const tempDir = path_1.default.join(process.cwd(), '.tts-temp-ontology');
         fs_1.default.mkdirSync(tempDir, { recursive: true });
         const tempTsConfigPath = path_1.default.join(tempDir, 'tsconfig.ontology.json');
         fs_1.default.writeFileSync(tempTsConfigPath, JSON.stringify({
-            compilerOptions: { target: 'ES2016', module: 'commonjs', esModuleInterop: true, skipLibCheck: true },
+            compilerOptions: {
+                target: 'ES2016',
+                module: 'commonjs',
+                esModuleInterop: true,
+                skipLibCheck: true,
+                outDir: tempDir,
+                rootDir: process.cwd()
+            },
             files: tsFiles
         }), 'utf-8');
         try {
-            (0, child_process_1.execSync)(`node "${tscBin}" -p "${tempTsConfigPath}"`);
+            (0, child_process_1.execSync)(`node "${tscBin}" -p "${tempTsConfigPath}"`, { stdio: 'pipe' });
         }
         catch (e) {
-            fs_1.default.unlinkSync(tempTsConfigPath);
+            cleanupTempDir(tempDir);
             throw new Error(((_a = e.stdout) === null || _a === void 0 ? void 0 : _a.toString()) || ((_b = e.stderr) === null || _b === void 0 ? void 0 : _b.toString()) || e.message);
         }
-        fs_1.default.unlinkSync(tempTsConfigPath);
+        finally {
+            try {
+                fs_1.default.unlinkSync(tempTsConfigPath);
+            }
+            catch (_c) { }
+        }
         const modules = [];
         const jsFiles = [];
         for (const file of tsFiles) {
-            const jsFile = file.replace(/\.ts$/, '.js');
+            const relative = path_1.default.relative(process.cwd(), file);
+            const jsFile = path_1.default.join(tempDir, relative.replace(/\.ts$/, '.js'));
             jsFiles.push(jsFile);
             modules.push({ file, mod: require(jsFile) });
         }
@@ -157,23 +205,25 @@ function importModules(pattern) {
             try {
                 fs_1.default.unlinkSync(jsFile);
             }
-            catch ( /* ignore */_c) { /* ignore */ }
-        }
-        try {
-            fs_1.default.rmdirSync(tempDir);
+            catch (_d) { }
         }
-        catch ( /* ignore if not empty */_d) { /* ignore if not empty */ }
+        cleanupTempDir(tempDir);
         return modules;
     });
 }
-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 cleanupTempDir(tempDir) {
+    try {
+        fs_1.default.rmSync(tempDir, { recursive: true, force: true });
+    }
+    catch (_a) { }
+}
+function getPredicateForField(object, fieldName) {
+    var _a;
+    const ctor = object.constructor;
+    const rel = (_a = ctor === null || ctor === void 0 ? void 0 : ctor.semanticRelations) === null || _a === void 0 ? void 0 : _a[fieldName];
+    if (rel === null || rel === void 0 ? void 0 : rel.predicate)
+        return tts(rel.predicate);
+    return tts(fieldName);
 }
 function serializeSourceLikeArray(writer, subject, values) {
     for (const v of values) {
@@ -214,7 +264,7 @@ function serializeObject(writer, subject, object, objectTypeName, objectId, visi
             serializeSourceLikeArray(writer, subject, value);
             continue;
         }
-        const predicate = tts(key);
+        const predicate = getPredicateForField(object, key);
         if (isPrimitive(value)) {
             writer.addQuad(subject, predicate, primitiveToLiteral(value));
             continue;
@@ -244,20 +294,23 @@ function serializeObject(writer, subject, object, objectTypeName, objectId, visi
         }
     }
 }
-function getLatestCharactersVersion() {
-    const baseDir = './characters';
-    if (!fs_1.default.existsSync(baseDir))
-        return null;
-    const versions = fs_1.default.readdirSync(baseDir)
-        .filter(d => /^v\d+$/.test(d))
-        .map(d => ({ dir: d, num: parseInt(d.slice(1), 10) }))
-        .sort((a, b) => b.num - a.num);
-    return versions.length > 0 ? versions[0].dir : null;
-}
 function buildOntologyTTL() {
-    var _a, _b, _c, _d, _e, _f, _g;
+    var _a, _b, _c, _d, _e, _f, _g, _h;
     return __awaiter(this, void 0, void 0, function* () {
         const writer = createWriter();
+        const seenClasses = new Set();
+        const seenDatatypeProperties = new Set();
+        const seenObjectProperties = new Set();
+        // Core generic relation properties (tts-local, subPropertyOf RO when relationIri is set per-class)
+        writer.addQuad(tts('hasPart'), rdf('type'), owl('ObjectProperty'));
+        writer.addQuad(tts('hasPart'), rdfs('label'), literal('has part', 'en'));
+        writer.addQuad(tts('hasPart'), rdfs('isDefinedBy'), ONTOLOGY_IRI);
+        writer.addQuad(tts('partOf'), rdf('type'), owl('ObjectProperty'));
+        writer.addQuad(tts('partOf'), rdfs('label'), literal('part of', 'en'));
+        writer.addQuad(tts('partOf'), rdfs('isDefinedBy'), ONTOLOGY_IRI);
+        writer.addQuad(tts('hasComponent'), rdf('type'), owl('ObjectProperty'));
+        writer.addQuad(tts('hasComponent'), rdfs('label'), literal('has component', 'en'));
+        writer.addQuad(tts('hasComponent'), rdfs('isDefinedBy'), ONTOLOGY_IRI);
         const version = getLatestCharactersVersion();
         if (!version) {
             console.error('\x1b[31m✖ No versioned directory found under ./characters/\x1b[0m');
@@ -269,22 +322,34 @@ function buildOntologyTTL() {
                 if (!isClassLike(exported))
                     continue;
                 const cls = exported;
+                if (shouldSkipClass(cls))
+                    continue;
+                if (seenClasses.has(cls.name))
+                    continue;
+                seenClasses.add(cls.name);
                 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));
+                writer.addQuad(classNode, rdf('type'), rdfs('Class'));
+                writer.addQuad(classNode, rdfs('isDefinedBy'), ONTOLOGY_IRI);
+                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, 'en'));
                 if ((_c = cls.semantic) === null || _c === void 0 ? void 0 : _c.definition) {
-                    writer.addQuad(classNode, rdfs('comment'), literal(cls.semantic.definition));
+                    writer.addQuad(classNode, rdfs('comment'), literal(cls.semantic.definition, 'en'));
                 }
                 addMappings(writer, classNode, (_d = cls.semantic) === null || _d === void 0 ? void 0 : _d.ontologyMappings);
+                // Datatype / object properties from semanticAttributes
                 const attrs = (_e = cls.semanticAttributes) !== null && _e !== void 0 ? _e : {};
                 for (const [attrName, meta] of Object.entries(attrs)) {
+                    if (seenDatatypeProperties.has(attrName))
+                        continue;
+                    seenDatatypeProperties.add(attrName);
                     const propNode = tts(attrName);
                     const kind = meta.kind === 'object' ? owl('ObjectProperty') : owl('DatatypeProperty');
                     writer.addQuad(propNode, rdf('type'), kind);
+                    writer.addQuad(propNode, rdfs('isDefinedBy'), ONTOLOGY_IRI);
                     writer.addQuad(propNode, rdfs('domain'), classNode);
-                    writer.addQuad(propNode, rdfs('label'), literal((_f = meta.label) !== null && _f !== void 0 ? _f : attrName));
+                    writer.addQuad(propNode, rdfs('label'), literal((_f = meta.label) !== null && _f !== void 0 ? _f : attrName, 'en'));
                     if (meta.definition) {
-                        writer.addQuad(propNode, rdfs('comment'), literal(meta.definition));
+                        writer.addQuad(propNode, rdfs('comment'), literal(meta.definition, 'en'));
                     }
                     const dt = normalizeDatatype(meta.datatype);
                     if (dt) {
@@ -300,6 +365,31 @@ function buildOntologyTTL() {
                         }
                     }
                 }
+                // Structural class relations from semanticRelations
+                const rels = (_h = cls.semanticRelations) !== null && _h !== void 0 ? _h : {};
+                for (const [fieldName, rel] of Object.entries(rels)) {
+                    const predicateName = getRelationPredicateName(fieldName, rel);
+                    const propNode = tts(predicateName);
+                    const targetNode = tts(rel.target);
+                    if (!seenObjectProperties.has(predicateName)) {
+                        seenObjectProperties.add(predicateName);
+                        writer.addQuad(propNode, rdf('type'), owl('ObjectProperty'));
+                        writer.addQuad(propNode, rdfs('isDefinedBy'), ONTOLOGY_IRI);
+                        writer.addQuad(propNode, rdfs('label'), literal(predicateName, 'en'));
+                        writer.addQuad(propNode, rdfs('domain'), classNode);
+                        writer.addQuad(propNode, rdfs('range'), targetNode);
+                        // subPropertyOf: points directly to RO IRI if provided,
+                        // otherwise falls back to tts-local anchor (hasPart / partOf / hasComponent)
+                        writer.addQuad(propNode, rdfs('subPropertyOf'), getRelationAnchor(rel));
+                        // relationType as human-readable label on the anchor node (only when both fields present)
+                        if (rel.relationType && rel.relationIri) {
+                            writer.addQuad(namedNode(rel.relationIri), rdfs('label'), literal(rel.relationType, 'en'));
+                        }
+                        addMappings(writer, propNode, rel.ontologyMappings);
+                    }
+                    // explicit schema-level relation triple between classes
+                    writer.addQuad(classNode, propNode, targetNode);
+                }
             }
         }
         return writerToString(writer);
@@ -351,8 +441,9 @@ function ttsExportOntology(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');
+        const version = getLatestCharactersVersion();
+        if (!version) {
+            console.error('\x1b[31m✖ No versioned directory (v1, v2, ...) found under ./characters/\x1b[0m');
             return;
         }
         if (!fs_1.default.existsSync(`./taxon/${genus}`)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lsbjordao/type-taxon-script",
-  "version": "1.1.18",
+  "version": "1.1.19",
   "author": "Lucas Jordão <tucarj@gmail.com> & André Eppinghaus <andreeppinghaus@gmail.com> & Vicente Calfo <vicentecalfo@gmail.com>",
   "license": "ISC",
   "description": "TypeTaxonScript",