npm - @skaterqiang/protege-js - Versions diffs - 0.1.0 - Mend

@skaterqiang/protege-js 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (92) hide show

package/CHANGELOG.md +65 -0
package/LICENSE +48 -0
package/README.md +287 -0
package/docs/API.md +654 -0
package/docs/design/OWL2-/347/274/272/345/217/243/345/210/206/346/236/220.md +140 -0
package/docs/owl2-rl/OWL2-RL-/350/247/204/345/210/231/347/273/206/345/210/231.md +168 -0
package/docs/owl2-rl/owl2-profiles-spec-zh.html +1914 -0
package/docs/owl2-rl/owl2-profiles-spec.html +1916 -0
package/docs/owl2-rl/rl_rules.json +392 -0
package/main.js +46 -0
package/package.json +76 -0
package/sample/README.md +74 -0
package/sample/case1-ecommerce-risk.js +170 -0
package/sample/case10-ecommerce-customer-service.js +454 -0
package/sample/case2-family-swrl.js +147 -0
package/sample/case3-pharma-safety.js +132 -0
package/sample/case4-knowledge-publishing.js +111 -0
package/sample/case5-obda-profiles.js +153 -0
package/sample/case6-medical-ontology.js +152 -0
package/sample/case7-manufacturing-ppr.js +155 -0
package/sample/case8-real-medical-bfo-ogms.js +353 -0
package/sample/case9-real-manufacturing-iao.js +360 -0
package/sample/ontologies/bfo.owl +1715 -0
package/sample/ontologies/iao.owl +8532 -0
package/sample/ontologies/ogms.owl +4320 -0
package/sample/ontologies/ro-core.owl +1010 -0
package/scripts/verify-api.js +53 -0
package/src/index.js +176 -0
package/src/inference/OWL2ProfileReasoners.js +67 -0
package/src/inference/OWL2RLReasoner.js +65 -0
package/src/inference/ReasonerQueries.js +111 -0
package/src/inference/SWRLReasoner.js +409 -0
package/src/inference/TripleStore.js +82 -0
package/src/inference/rdf.js +83 -0
package/src/inference/rules/owl2el.js +33 -0
package/src/inference/rules/owl2ql.js +29 -0
package/src/inference/rules/owl2rl.js +823 -0
package/src/io/FunctionalSyntaxParser.js +399 -0
package/src/io/FunctionalSyntaxWriter.js +180 -0
package/src/io/ManchesterSyntaxParser.js +398 -0
package/src/io/OWLXMLParser.js +356 -0
package/src/io/OntologyLoader.js +125 -0
package/src/io/RDFGraphToOntology.js +702 -0
package/src/io/RDFXMLParser.js +319 -0
package/src/io/RDFXMLWriter.js +196 -0
package/src/io/SWRLParser.js +150 -0
package/src/io/TurtleParser.js +363 -0
package/src/io/TurtleWriter.js +393 -0
package/src/model/IRI.js +62 -0
package/src/model/OWLAxiom.js +507 -0
package/src/model/OWLClassExpression.js +242 -0
package/src/model/OWLEntity.js +142 -0
package/src/model/OWLLiteral.js +30 -0
package/src/model/OWLModelManager.js +106 -0
package/src/model/OWLOntology.js +119 -0
package/src/model/SWRL.js +152 -0
package/src/model/event/OWLModelManagerEvent.js +33 -0
package/src/model/hierarchy/HierarchyProvider.js +214 -0
package/src/profiles/OWL2Profiles.js +185 -0
package/src/server/public/app.js +97 -0
package/src/server/public/index.html +49 -0
package/src/server/webServer.js +138 -0
package/src/validation/GlobalRestrictionsValidator.js +172 -0
package/test/core.test.js +111 -0
package/test/exports-map.test.js +165 -0
package/test/owl2/axioms.test.js +160 -0
package/test/owl2/classExpressions.test.js +99 -0
package/test/owl2/functional-syntax-writer.test.js +65 -0
package/test/owl2/functional.test.js +113 -0
package/test/owl2/global-restrictions.test.js +76 -0
package/test/owl2/longtail.test.js +74 -0
package/test/owl2/manchester-syntax.test.js +100 -0
package/test/owl2/ontology-loader-imports.test.js +62 -0
package/test/owl2/owlxml-parser.test.js +112 -0
package/test/owl2/profile-reasoners.test.js +108 -0
package/test/owl2/profiles.test.js +66 -0
package/test/owl2/rdf-graph-to-ontology.test.js +177 -0
package/test/owl2/rdfxml-punning.test.js +25 -0
package/test/owl2/rdfxml-writer.test.js +55 -0
package/test/owl2/rdfxml.test.js +91 -0
package/test/owl2/reasoner-queries.test.js +58 -0
package/test/owl2/sample-e2e.test.js +195 -0
package/test/owl2/swrl-parser.test.js +60 -0
package/test/owl2/swrl.test.js +131 -0
package/test/owl2/turtle-writer.test.js +84 -0
package/test/owl2/turtle.test.js +124 -0
package/test/owl2rl/cax.test.js +57 -0
package/test/owl2rl/cls.test.js +210 -0
package/test/owl2rl/dt.test.js +72 -0
package/test/owl2rl/eq.test.js +95 -0
package/test/owl2rl/prp.test.js +198 -0
package/test/owl2rl/scm.test.js +203 -0

package/src/server/public/index.html ADDED Viewed

@@ -0,0 +1,49 @@
+<!DOCTYPE html>
+<html lang="zh-CN">
+<head>
+  <meta charset="utf-8">
+  <title>Protégé JS</title>
+  <style>
+    * { box-sizing: border-box; }
+    body { margin: 0; font-family: -apple-system, 'SF Pro', 'PingFang SC', sans-serif; background: #1e1e1e; color: #ddd; }
+    header { padding: 10px 16px; background: #252526; border-bottom: 1px solid #333; display: flex; gap: 10px; align-items: center; }
+    header h1 { font-size: 15px; margin: 0; font-weight: 600; }
+    input[type=text] { flex: 1; max-width: 480px; padding: 6px 10px; border: 1px solid #3a3a3a; background: #1e1e1e; color: #ddd; border-radius: 6px; font-size: 13px; }
+    button { padding: 6px 14px; border: 1px solid #3a3a3a; background: #0e639c; color: #fff; border: none; border-radius: 6px; cursor: pointer; font-size: 13px; }
+    button.ghost { background: #3a3a3a; }
+    #stats { margin-left: auto; font-size: 12px; color: #999; }
+    main { display: flex; height: calc(100vh - 49px); }
+    nav { width: 200px; background: #252526; border-right: 1px solid #333; padding: 10px; }
+    nav .tab { padding: 8px 10px; border-radius: 6px; cursor: pointer; font-size: 13px; margin-bottom: 4px; }
+    nav .tab.active { background: #0e639c; color: #fff; }
+    #tree-wrap { flex: 1; overflow: auto; padding: 14px 18px; }
+    .node { margin: 2px 0; }
+    .node .row { display: flex; align-items: center; gap: 6px; padding: 2px 4px; border-radius: 4px; cursor: default; }
+    .node .row:hover { background: #2d2d30; }
+    .twisty { width: 14px; display: inline-block; text-align: center; color: #888; cursor: pointer; user-select: none; }
+    .children { margin-left: 20px; }
+    .collapsed > .children { display: none; }
+    .badge { font-size: 10px; color: #888; margin-left: 6px; }
+    #empty { color: #777; padding: 40px; text-align: center; }
+    #msg { font-size: 12px; color: #7cc7ff; }
+  </style>
+</head>
+<body>
+  <header>
+    <h1>Protégé <span style="color:#888">JS</span></h1>
+    <input type="text" id="filePath" placeholder="输入 .owl / .rdf 文件路径后加载…">
+    <button id="btn-load">加载本体</button>
+    <span id="msg"></span>
+    <span id="stats"></span>
+  </header>
+  <main>
+    <nav>
+      <div class="tab active" data-kind="class">Classes</div>
+      <div class="tab" data-kind="objectProperty">Object Properties</div>
+      <div class="tab" data-kind="dataProperty">Data Properties</div>
+    </nav>
+    <div id="tree-wrap"><div id="empty">尚未加载本体。请输入 OWL (RDF/XML) 文件路径并点击「加载本体」。</div></div>
+  </main>
+  <script src="/app.js"></script>
+</body>
+</html>

package/src/server/webServer.js ADDED Viewed

@@ -0,0 +1,138 @@
+'use strict';
+const http = require('http');
+const path = require('path');
+const fs = require('fs');
+const url = require('url');
+const { OWLModelManager } = require('../model/OWLModelManager');
+const {
+  AssertedClassHierarchyProvider,
+  OWLObjectPropertyHierarchyProvider,
+  OWLDataPropertyHierarchyProvider
+} = require('../model/hierarchy/HierarchyProvider');
+const { OntologyLoader } = require('../io/OntologyLoader');
+const PORT = process.env.PROTEGE_JS_PORT ? Number(process.env.PROTEGE_JS_PORT) : 8899;
+const manager = new OWLModelManager();
+const loader = new OntologyLoader();
+function sendJson(res, data, code = 200) {
+  const body = JSON.stringify(data);
+  res.writeHead(code, { 'content-type': 'application/json; charset=utf-8' });
+  res.end(body);
+}
+function sendFile(res, filePath) {
+  const ext = path.extname(filePath);
+  const mime = {
+    '.html': 'text/html; charset=utf-8',
+    '.js': 'application/javascript; charset=utf-8',
+    '.css': 'text/css; charset=utf-8'
+  }[ext] || 'text/plain; charset=utf-8';
+  fs.readFile(filePath, (err, data) => {
+    if (err) { res.writeHead(404); res.end('not found'); return; }
+    res.writeHead(200, { 'content-type': mime });
+    res.end(data);
+  });
+}
+function readBody(req) {
+  return new Promise((resolve) => {
+    let s = '';
+    req.on('data', d => (s += d));
+    req.on('end', () => {
+      try { resolve(JSON.parse(s || '{}')); } catch { resolve({}); }
+    });
+  });
+}
+function activeProviders() {
+  const ont = manager.getActiveOntology();
+  if (!ont) return null;
+  const classHp = new AssertedClassHierarchyProvider(ont);
+  classHp.rebuild();
+  const objHp = new OWLObjectPropertyHierarchyProvider(ont);
+  objHp.rebuild();
+  const dataHp = new OWLDataPropertyHierarchyProvider(ont);
+  dataHp.rebuild();
+  return { ont, classHp, objHp, dataHp };
+}
+async function handleApi(req, res, pathname) {
+  if (pathname === '/api/load' && req.method === 'POST') {
+    const body = await readBody(req);
+    if (!body.filePath) return sendJson(res, { error: 'filePath required' }, 400);
+    try {
+      const ont = loader.loadFromFile(body.filePath);
+      manager.addOntology(ont);
+      return sendJson(res, {
+        ok: true,
+        ontology: {
+          id: ont.getOntologyID().toString(),
+          axiomCount: ont.getAxiomCount(),
+          classes: ont.getClassesInSignature().length,
+          objectProperties: ont.getObjectPropertiesInSignature().length,
+          dataProperties: ont.getDataPropertiesInSignature().length,
+          individuals: ont.getIndividualsInSignature().length
+        }
+      });
+    } catch (e) {
+      return sendJson(res, { error: String(e.message || e) }, 500);
+    }
+  }
+  if (pathname === '/api/tree' && req.method === 'GET') {
+    const p = activeProviders();
+    if (!p) return sendJson(res, { error: 'no ontology loaded' }, 404);
+    const q = url.parse(req.url, true).query;
+    const kind = q.kind || 'class';
+    let tree;
+    if (kind === 'objectProperty') tree = p.objHp.toTree();
+    else if (kind === 'dataProperty') tree = p.dataHp.toTree();
+    else tree = p.classHp.toTree();
+    return sendJson(res, { ok: true, kind, tree });
+  }
+  if (pathname === '/api/stats' && req.method === 'GET') {
+    const ont = manager.getActiveOntology();
+    if (!ont) return sendJson(res, { loaded: false });
+    return sendJson(res, {
+      loaded: true,
+      id: ont.getOntologyID().toString(),
+      axiomCount: ont.getAxiomCount(),
+      classes: ont.getClassesInSignature().length,
+      objectProperties: ont.getObjectPropertiesInSignature().length,
+      dataProperties: ont.getDataPropertiesInSignature().length,
+      individuals: ont.getIndividualsInSignature().length
+    });
+  }
+  return sendJson(res, { error: 'unknown api' }, 404);
+}
+function createServer() {
+  const webRoot = path.join(__dirname, 'public');
+  return http.createServer(async (req, res) => {
+    const pathname = url.parse(req.url, true).pathname;
+    if (pathname.startsWith('/api/')) {
+      return handleApi(req, res, pathname);
+    }
+    let fp = pathname === '/' ? '/index.html' : pathname;
+    return sendFile(res, path.join(webRoot, fp));
+  });
+}
+function start(port = PORT) {
+  const server = createServer();
+  server.listen(port, () => {
+    console.log(`protege-js web UI listening on http://localhost:${port}/`);
+  });
+  return server;
+}
+if (require.main === module) {
+  start();
+}
+module.exports = { start, createServer, manager, PORT };

package/src/validation/GlobalRestrictionsValidator.js ADDED Viewed

@@ -0,0 +1,172 @@
+'use strict';
+// ---------------------------------------------------------------------------
+// validation/GlobalRestrictionsValidator — checks the OWL 2 global
+// restrictions on axioms (W3C §11.1 & §11.2):
+//
+//  1. Regularity of the property hierarchy / property chains:
+//     the property hierarchy induced by SubObjectPropertyOf and
+//     SubObjectPropertyOf(ObjectPropertyChain(...)) must be a strict partial
+//     order; a property may not be (in)directly a sub-property of a chain
+//     that contains itself in a "non-simple" way.
+//  2. Simple-property restrictions:
+//     Non-simple properties (super-properties of chains, or chain members
+//     that are non-simple) may not be used in:
+//       - FunctionalObjectProperty / InverseFunctionalObjectProperty
+//       - IrreflexiveObjectProperty / AsymmetricObjectProperty
+//       - ObjectHasSelf
+//       - ObjectMin/Max/ExactCardinality
+//       - DisjointObjectProperties
+//  3. owl:Nothing / owl:Thing misuse (nothing may be instance of owl:Nothing).
+//
+// Returns a list of violations:
+//   { rule, message, axiom? , iri? }
+// ---------------------------------------------------------------------------
+const { AxiomType: A } = require('../model/OWLAxiom');
+const { ClassExpressionType: T } = require('../model/OWLClassExpression');
+class GlobalRestrictionsValidator {
+  /**
+   * @param {OWLOntology} ont
+   */
+  validate(ont) {
+    this.violations = [];
+    this.ont = ont;
+    this._buildPropertyHierarchy();
+    this._checkSimplePropertyRestrictions();
+    this._checkNothingInstance();
+    return this.violations;
+  }
+  _v(rule, message, axiom = null, iri = null) {
+    this.violations.push({ rule, message, axiom, iri });
+  }
+  // --- property hierarchy ---------------------------------------------------
+  _buildPropertyHierarchy() {
+    // nonSimple: set of property IRIs that are "non-simple"
+    // A property is non-simple if:
+    //   - it is the super-property of a property chain axiom
+    //   - it is a super-property (transitively) of a non-simple property
+    this.nonSimple = new Set();
+    this.chainSupers = []; // [{superProperty, chain:[iri...]}]
+    for (const ax of this.ont.getAxiomsOfType(A.SUB_PROPERTY_CHAIN_OF)) {
+      const sup = ax.superProperty.getIRI().toString();
+      this.nonSimple.add(sup);
+      this.chainSupers.push({
+        superProperty: sup,
+        chain: ax.propertyChain.map(p => p.getIRI().toString())
+      });
+    }
+    // Propagate non-simplicity along subPropertyOf
+    let changed = true;
+    while (changed) {
+      changed = false;
+      for (const ax of this.ont.getAxiomsOfType(A.SUB_OBJECT_PROPERTY_OF)) {
+        const sub = ax.subProperty.getIRI().toString();
+        const sup = ax.superProperty.getIRI().toString();
+        if (this.nonSimple.has(sub) && !this.nonSimple.has(sup)) {
+          this.nonSimple.add(sup);
+          changed = true;
+        }
+        // A chain member that is non-simple makes the chain's super non-simple
+        // (OWL 2 §11.1: a property chain may not contain a non-simple property
+        // in the chain unless the super is also non-simple; we flag the more
+        // common violation: chain contains a non-simple property that is
+        // equal to or a super-property of the chain's own super → circularity)
+      }
+    }
+    // Regularity: a chain member must be a strict sub-property of the chain's
+    // super-property, and may not be the super-property itself.
+    for (const cs of this.chainSupers) {
+      for (const member of cs.chain) {
+        if (member === cs.superProperty) {
+          this._v('regularity',
+            `Property chain for ${cs.superProperty} contains itself as a member (non-regular)`, null, cs.superProperty);
+        }
+      }
+    }
+  }
+  _isNonSimple(iri) { return this.nonSimple.has(iri); }
+  // --- simple property restrictions -----------------------------------------
+  _checkSimplePropertyRestrictions() {
+    const checkProp = (ax, propIRI, axiomName) => {
+      if (this._isNonSimple(propIRI)) {
+        this._v('simple-property',
+          `${axiomName} uses non-simple property ${propIRI} (super of a property chain)`, ax, propIRI);
+      }
+    };
+    for (const ax of this.ont.getAxiomsOfType(A.FUNCTIONAL_OBJECT_PROPERTY)) {
+      checkProp(ax, ax.property.getIRI().toString(), 'FunctionalObjectProperty');
+    }
+    for (const ax of this.ont.getAxiomsOfType(A.INVERSE_FUNCTIONAL_OBJECT_PROPERTY)) {
+      checkProp(ax, ax.property.getIRI().toString(), 'InverseFunctionalObjectProperty');
+    }
+    for (const ax of this.ont.getAxiomsOfType(A.IRREFLEXIVE_OBJECT_PROPERTY)) {
+      checkProp(ax, ax.property.getIRI().toString(), 'IrreflexiveObjectProperty');
+    }
+    for (const ax of this.ont.getAxiomsOfType(A.ASYMMETRIC_OBJECT_PROPERTY)) {
+      checkProp(ax, ax.property.getIRI().toString(), 'AsymmetricObjectProperty');
+    }
+    for (const ax of this.ont.getAxiomsOfType(A.DISJOINT_OBJECT_PROPERTIES)) {
+      for (const p of ax.properties) {
+        checkProp(ax, p.getIRI().toString(), 'DisjointObjectProperties');
+      }
+    }
+    // Cardinality restrictions and hasSelf inside class expressions
+    for (const ax of this.ont.getAxioms()) {
+      this._walkExprAxiom(ax, ax.subClass);
+      this._walkExprAxiom(ax, ax.superClass);
+      if (Array.isArray(ax.classExpressions)) {
+        for (const ce of ax.classExpressions) this._walkExprAxiom(ax, ce);
+      }
+    }
+  }
+  _walkExprAxiom(ax, expr) {
+    if (!expr || !expr.type) return;
+    const self = this;
+    (function walk(e) {
+      if (!e || typeof e !== 'object') return;
+      if (e.type === T.OBJECT_HAS_SELF) {
+        const p = e.property.getIRI().toString();
+        if (self._isNonSimple(p)) {
+          self._v('simple-property', `ObjectHasSelf uses non-simple property ${p}`, ax, p);
+        }
+      }
+      if (e.type === T.OBJECT_MIN_CARDINALITY || e.type === T.OBJECT_MAX_CARDINALITY
+          || e.type === T.OBJECT_EXACT_CARDINALITY
+          || e.type === T.OBJECT_MIN_QUALIFIED_CARDINALITY
+          || e.type === T.OBJECT_MAX_QUALIFIED_CARDINALITY
+          || e.type === T.OBJECT_EXACT_QUALIFIED_CARDINALITY) {
+        const p = e.property.getIRI().toString();
+        if (self._isNonSimple(p)) {
+          self._v('simple-property', `Cardinality restriction uses non-simple property ${p}`, ax, p);
+        }
+      }
+      if (e.operand) walk(e.operand);
+      if (e.filler) walk(e.filler);
+      if (Array.isArray(e.operands)) for (const o of e.operands) walk(o);
+    })(expr);
+  }
+  // --- owl:Nothing -----------------------------------------------------------
+  _checkNothingInstance() {
+    for (const ax of this.ont.getAxiomsOfType(A.CLASS_ASSERTION)) {
+      const ce = ax.classExpression;
+      if (ce && ce.getIRI && ce.getIRI().toString() === 'http://www.w3.org/2002/07/owl#Nothing') {
+        this._v('owl:Nothing-instance',
+          'An individual is asserted to be an instance of owl:Nothing', ax);
+      }
+    }
+  }
+}
+module.exports = { GlobalRestrictionsValidator };

package/test/core.test.js ADDED Viewed

@@ -0,0 +1,111 @@
+'use strict';
+const { test } = require('node:test');
+const assert = require('node:assert');
+const { IRI } = require('../src/model/IRI');
+const { OWLClass, OWLObjectProperty, OWLNamedIndividual, OWL } = require('../src/model/OWLEntity');
+const { OWLSubClassOfAxiom, OWLDeclarationAxiom } = require('../src/model/OWLAxiom');
+const { OWLOntology, OWLOntologyID } = require('../src/model/OWLOntology');
+const { OWLModelManager } = require('../src/model/OWLModelManager');
+const { AssertedClassHierarchyProvider } = require('../src/model/hierarchy/HierarchyProvider');
+const { OntologyLoader } = require('../src/io/OntologyLoader');
+test('IRI fragment and namespace', () => {
+  const iri = IRI.create('http://example.org/ont#Person');
+  assert.strictEqual(iri.getFragment(), 'Person');
+  assert.strictEqual(iri.getNamespace(), 'http://example.org/ont#');
+  assert.strictEqual(iri.getShortForm(), 'Person');
+});
+test('OWLEntity equality by IRI and type', () => {
+  const a = new OWLClass('http://example.org#A');
+  const b = new OWLClass('http://example.org#A');
+  const c = new OWLObjectProperty('http://example.org#A');
+  assert.ok(a.equals(b));
+  assert.ok(!a.equals(c));
+});
+test('OWLOntology stores axioms and indexes signature', () => {
+  const ont = new OWLOntology(new OWLOntologyID('http://example.org/ont'));
+  const person = new OWLClass('http://example.org/ont#Person');
+  const agent = new OWLClass('http://example.org/ont#Agent');
+  ont.addAxiom(new OWLDeclarationAxiom(person));
+  ont.addAxiom(new OWLDeclarationAxiom(agent));
+  ont.addAxiom(new OWLSubClassOfAxiom(person, agent));
+  assert.strictEqual(ont.getAxiomCount(), 3);
+  assert.strictEqual(ont.getClassesInSignature().length, 2);
+  assert.strictEqual(ont.getSubClassAxiomsForSubClass(person).length, 1);
+});
+test('OWLModelManager fires active ontology change events', () => {
+  const mm = new OWLModelManager();
+  const events = [];
+  mm.addListener(e => events.push(e.getType()));
+  const ont = mm.createOntology('http://example.org/ont');
+  assert.strictEqual(mm.getActiveOntology(), ont);
+  assert.ok(events.includes('ACTIVE_ONTOLOGY_CHANGED'));
+});
+test('AssertedClassHierarchyProvider builds tree rooted at owl:Thing', () => {
+  const ont = new OWLOntology(new OWLOntologyID('http://example.org/ont'));
+  const thing = OWL.THING;
+  const agent = new OWLClass('http://example.org/ont#Agent');
+  const person = new OWLClass('http://example.org/ont#Person');
+  ont.addAxiom(new OWLDeclarationAxiom(agent));
+  ont.addAxiom(new OWLDeclarationAxiom(person));
+  ont.addAxiom(new OWLSubClassOfAxiom(person, agent));
+  const hp = new AssertedClassHierarchyProvider(ont);
+  hp.rebuild();
+  const roots = hp.getRoots();
+  assert.strictEqual(roots.length, 1);
+  assert.ok(roots[0].equals(thing));
+  const thingChildren = hp.getChildren(thing);
+  assert.strictEqual(thingChildren.length, 1);
+  assert.ok(thingChildren[0].equals(agent));
+  const agentChildren = hp.getChildren(agent);
+  assert.ok(agentChildren.some(c => c.equals(person)));
+  const tree = hp.toTree();
+  assert.strictEqual(tree[0].name, 'Thing');
+  assert.strictEqual(tree[0].children[0].name, 'Agent');
+  assert.strictEqual(tree[0].children[0].children[0].name, 'Person');
+});
+test('OntologyLoader parses RDF/XML into ontology with classes and subclasses', () => {
+  const xml = `<?xml version="1.0"?>
+  <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+           xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
+           xmlns:owl="http://www.w3.org/2002/07/owl#"
+           xml:base="http://example.org/ont">
+    <owl:Ontology rdf:about="http://example.org/ont"/>
+    <owl:Class rdf:about="http://example.org/ont#Agent">
+      <rdfs:label>Agent</rdfs:label>
+    </owl:Class>
+    <owl:Class rdf:about="http://example.org/ont#Person">
+      <rdfs:subClassOf rdf:resource="http://example.org/ont#Agent"/>
+      <rdfs:label>Person</rdfs:label>
+    </owl:Class>
+    <owl:ObjectProperty rdf:about="http://example.org/ont#knows">
+      <rdfs:domain rdf:resource="http://example.org/ont#Person"/>
+      <rdfs:range rdf:resource="http://example.org/ont#Person"/>
+    </owl:ObjectProperty>
+    <owl:NamedIndividual rdf:about="http://example.org/ont#alice">
+      <rdf:type rdf:resource="http://example.org/ont#Person"/>
+    </owl:NamedIndividual>
+  </rdf:RDF>`;
+  const loader = new OntologyLoader();
+  const ont = loader.loadFromString(xml);
+  assert.strictEqual(ont.getOntologyID().ontologyIRI, 'http://example.org/ont');
+  const classes = ont.getClassesInSignature().map(c => c.getShortForm()).sort();
+  assert.deepStrictEqual(classes, ['Agent', 'Person']);
+  assert.strictEqual(ont.getObjectPropertiesInSignature().length, 1);
+  const inds = ont.getIndividualsInSignature().map(i => i.getShortForm());
+  assert.deepStrictEqual(inds, ['alice']);
+  const hp = new AssertedClassHierarchyProvider(ont);
+  hp.rebuild();
+  const tree = hp.toTree();
+  assert.strictEqual(tree[0].children[0].name, 'Agent');
+  assert.strictEqual(tree[0].children[0].children[0].name, 'Person');
+});

package/test/exports-map.test.js ADDED Viewed

@@ -0,0 +1,165 @@
+'use strict';
+// ---------------------------------------------------------------------------
+// test/exports-map.test.js — guards the package.json "exports" map.
+//
+// WHY THIS TEST EXISTS
+// --------------------
+// Every other test in this suite `require`s sibling modules by *relative path*
+// (e.g. require('../src/model/IRI')). Relative requires bypass the "exports"
+// map entirely and fall back to legacy CommonJS resolution, which DOES append
+// `.js` for you. So the whole suite can pass while the published package is
+// broken for real consumers.
+//
+// That is exactly what happened: "exports" declared `"./src/*": "./src/*"`,
+// and Node's subpath *pattern* substitution performs no extension resolution.
+// `require('@skaterqiang/protege-js/src/model/IRI')` — the form documented in
+// 42 places across README.md and docs/API.md — threw MODULE_NOT_FOUND, while
+// only the explicit `.js` spelling worked.
+//
+// The fix is two sibling pattern keys:
+//     "./src/*.js": "./src/*.js",   // explicit-extension spelling
+//     "./src/*":    "./src/*.js",   // extensionless spelling
+// Node's best-match rule picks the most specific key by suffix length, so both
+// spellings resolve. (An *array* value does NOT work as a fallback chain: once
+// a pattern key matches, a failed resolution throws instead of trying the next
+// entry.)
+//
+// HOW THIS TEST STAYS HONEST
+// --------------------------
+// It resolves the package *by its own name* (Node self-reference, enabled by
+// having both "name" and "exports"), so it exercises the real exports map with
+// no packing or installing. And rather than hard-coding a list of deep-import
+// paths — which would drift from the docs — it *scrapes* README.md and
+// docs/API.md for every `require('<pkg>/...')` / `from '<pkg>/...'` specifier
+// and asserts each one resolves. If someone documents a new deep import, it is
+// covered automatically; if someone breaks "exports", the docs fail the build.
+// ---------------------------------------------------------------------------
+const { test } = require('node:test');
+const assert = require('node:assert');
+const fs = require('node:fs');
+const path = require('node:path');
+const { createRequire } = require('node:module');
+const require_ = createRequire(path.join(__dirname, 'noop.js'));
+const ROOT = path.join(__dirname, '..');
+const pkg = JSON.parse(fs.readFileSync(path.join(ROOT, 'package.json'), 'utf8'));
+const NAME = pkg.name;
+// Documents that advertise import specifiers to end users.
+const DOC_FILES = ['README.md', path.join('docs', 'API.md')];
+/**
+ * Pull every bare-package import specifier out of a markdown/JS-ish document.
+ * Matches require('pkg/...'), require("pkg/..."), from 'pkg/...' and the
+ * bare `require('pkg')` form. Deliberately ignores GitHub URLs, which contain
+ * the unscoped repo name and must stay unscoped.
+ */
+function scrapeSpecifiers(text) {
+  const out = new Set();
+  const re = new RegExp(
+    String.raw`(?:require\(|from\s+)\s*['"\`](${NAME.replace(/[/@]/g, (c) => '\\' + c)}(?:/[^'"\`]*)?)['"\`]`,
+    'g'
+  );
+  let m;
+  while ((m = re.exec(text)) !== null) out.add(m[1]);
+  return [...out];
+}
+test('package.json declares a scoped name and an exports map', () => {
+  assert.ok(NAME.startsWith('@'), `expected a scoped name, got ${NAME}`);
+  assert.ok(pkg.exports && typeof pkg.exports === 'object', 'exports map missing');
+  assert.strictEqual(pkg.exports['.'], './src/index.js', 'root export must point at src/index.js');
+});
+test('exports map covers both .js and extensionless deep-import spellings', () => {
+  // The extensionless key must map to a *.js target, otherwise Node performs no
+  // extension resolution and every documented deep import breaks.
+  assert.ok(pkg.exports['./src/*'], 'missing "./src/*" pattern key');
+  const target = pkg.exports['./src/*'];
+  const targets = Array.isArray(target) ? target : [target];
+  assert.ok(
+    targets.some((t) => t === './src/*.js'),
+    `"./src/*" must resolve to "./src/*.js", got ${JSON.stringify(target)}`
+  );
+  // And the explicit-extension spelling must still work.
+  assert.strictEqual(pkg.exports['./src/*.js'], './src/*.js', 'missing "./src/*.js" identity key');
+});
+test('flat import by package name resolves (self-reference)', () => {
+  const api = require_(NAME);
+  assert.ok(api && typeof api === 'object', 'root import returned nothing');
+  // A few load-bearing symbols, so a hollow index.js cannot pass.
+  for (const sym of ['OWL2RLReasoner', 'TripleStore', 'TurtleParser', 'IRI', 'checkRL']) {
+    assert.ok(sym in api, `root export missing ${sym}`);
+  }
+  assert.ok(api.model && api.io && api.inference && api.profiles, 'namespaced exports missing');
+});
+test('package.json subpath is exported', () => {
+  const meta = require_(`${NAME}/package.json`);
+  assert.strictEqual(meta.name, NAME);
+});
+test('every deep-import specifier documented in the docs actually resolves', () => {
+  const specifiers = new Set();
+  for (const rel of DOC_FILES) {
+    const abs = path.join(ROOT, rel);
+    assert.ok(fs.existsSync(abs), `doc not found: ${rel}`);
+    for (const s of scrapeSpecifiers(fs.readFileSync(abs, 'utf8'))) specifiers.add(s);
+  }
+  // Sanity: if the scraper silently matched nothing the test would be vacuous.
+  const deep = [...specifiers].filter((s) => s.includes('/'));
+  assert.ok(deep.length >= 20, `expected >=20 documented deep imports, scraped ${deep.length}`);
+  const failures = [];
+  for (const spec of [...specifiers].sort()) {
+    try {
+      const mod = require_(spec);
+      assert.ok(mod, `${spec} resolved to a falsy value`);
+    } catch (err) {
+      failures.push(`${spec} -> ${err.code || err.message}`);
+    }
+  }
+  assert.deepStrictEqual(failures, [], `unresolvable documented imports:\n  ${failures.join('\n  ')}`);
+});
+test('extensionless and .js spellings resolve to the same module', () => {
+  // The two pattern keys must not accidentally expose different files.
+  const probes = [
+    'src/model/IRI',
+    'src/inference/OWL2RLReasoner',
+    'src/inference/TripleStore',
+    'src/io/TurtleParser',
+    'src/profiles/OWL2Profiles'
+  ];
+  for (const p of probes) {
+    const a = require_(`${NAME}/${p}`);
+    const b = require_(`${NAME}/${p}.js`);
+    assert.strictEqual(a, b, `${p}: extensionless and .js spellings diverged`);
+    assert.ok(Object.keys(a).length > 0, `${p}: module exports nothing`);
+  }
+});
+test('a resolved deep import is functional, not just loadable', () => {
+  // Guard against an exports map that resolves to the wrong/empty file.
+  const { OWL2RLReasoner } = require_(`${NAME}/src/inference/OWL2RLReasoner`);
+  const { TripleStore } = require_(`${NAME}/src/inference/TripleStore`);
+  // Take the IRIs from the library itself. Hard-coding them here once produced a
+  // false failure: the RDF namespace is http://www.w3.org/1999/02/22-rdf-syntax-ns#
+  // and a single mistyped separator makes cax-sco silently not fire, because the
+  // rule matches on exact IRI equality. Deriving them removes that whole class of
+  // error — and it exercises one more deep import in the process.
+  const { NS } = require_(`${NAME}/src/inference/rdf`);
+  const TYPE = NS.RDF + 'type';
+  const SUBCLASSOF = NS.RDFS + 'subClassOf';
+  const r = new OWL2RLReasoner(new TripleStore());
+  r.store.add('ex:A', SUBCLASSOF, 'ex:B');
+  r.store.add('ex:x', TYPE, 'ex:A');
+  r.materialize();
+  assert.ok(r.entails('ex:x', TYPE, 'ex:B'), 'deep-imported reasoner failed to entail cax-sco');
+  assert.deepStrictEqual(r.inconsistencies, [], 'unexpected inconsistencies');
+});