@faubulous/mentor-rdf 2.2.0 → 2.2.1

package/dist/index.js

@@ -4842,6 +4842,18 @@ var RdfsReasoner = class extends SkosReasoner {
     this.classes = /* @__PURE__ */ new Set();
     this.properties = /* @__PURE__ */ new Set();
     this.individuals = /* @__PURE__ */ new Set();
+    /**
+     * The super properties of each property, as asserted with `rdfs:subPropertyOf`.
+     */
+    this._superProperties = /* @__PURE__ */ new Map();
+    /**
+     * The ranges asserted for each property.
+     */
+    this._ranges = /* @__PURE__ */ new Map();
+    /**
+     * The domains asserted for each property.
+     */
+    this._domains = /* @__PURE__ */ new Map();
   }
   isIgnoredNode(term) {
     switch (term.value) {
@@ -4866,6 +4878,47 @@ var RdfsReasoner = class extends SkosReasoner {
     for (let individual of individuals) {
       this.store.add(quad2(individual, rdf.type, owl.NamedIndividual, this.targetGraph));
     }
+    this._inferInheritedRangesAndDomains();
+  }
+  /**
+   * Infers the ranges and domains that properties inherit from their super properties
+   * (OWL 2 RL rules scm-rng2 and scm-dom2), following `rdfs:subPropertyOf` chains.
+   */
+  _inferInheritedRangesAndDomains() {
+    for (const { property, superProperties } of this._superProperties.values()) {
+      for (const superProperty of this._getAncestorProperties(property.value, superProperties)) {
+        for (const range of this._ranges.get(superProperty) ?? []) {
+          this.store.add(quad2(property, rdfs.range, range, this.targetGraph));
+        }
+        for (const domain of this._domains.get(superProperty) ?? []) {
+          this.store.add(quad2(property, rdfs.domain, domain, this.targetGraph));
+        }
+      }
+    }
+  }
+  /**
+   * Gets the transitive super properties of a property, nearest first. Cycles in the
+   * property hierarchy are followed only once.
+   * @param property The IRI or blank node id of a property.
+   * @param superProperties The direct super properties of the property.
+   * @returns The IRIs of all super properties, excluding the property itself.
+   */
+  _getAncestorProperties(property, superProperties) {
+    const result = [];
+    const visited = /* @__PURE__ */ new Set([property]);
+    const queue = [...superProperties];
+    while (queue.length > 0) {
+      const current = queue.shift();
+      if (visited.has(current)) {
+        continue;
+      }
+      visited.add(current);
+      result.push(current);
+      for (const next of this._superProperties.get(current)?.superProperties ?? []) {
+        queue.push(next);
+      }
+    }
+    return result;
   }
   resetState() {
     super.resetState();
@@ -4873,6 +4926,9 @@ var RdfsReasoner = class extends SkosReasoner {
     this.classes.clear();
     this.properties.clear();
     this.individuals.clear();
+    this._superProperties.clear();
+    this._ranges.clear();
+    this._domains.clear();
   }
   applyInference(quad5) {
     super.applyInference(quad5);
@@ -4966,13 +5022,49 @@ var RdfsReasoner = class extends SkosReasoner {
         }
         return;
       }
-      case rdfs.range.value:
+      case rdfs.subPropertyOf.value: {
+        this._addSuperProperty(s, o);
+        return;
+      }
+      case rdfs.range.value: {
+        this.assertProperty(s);
+        this._addToList(this._ranges, s.value, o);
+        return;
+      }
       case rdfs.domain.value: {
         this.assertProperty(s);
+        this._addToList(this._domains, s.value, o);
         return;
       }
     }
   }
+  /**
+   * Records that a property is a sub property of another property.
+   * @param property The sub property.
+   * @param superProperty The super property.
+   */
+  _addSuperProperty(property, superProperty) {
+    let entry = this._superProperties.get(property.value);
+    if (!entry) {
+      entry = { property, superProperties: /* @__PURE__ */ new Set() };
+      this._superProperties.set(property.value, entry);
+    }
+    entry.superProperties.add(superProperty.value);
+  }
+  /**
+   * Adds a value to the list stored under a key.
+   * @param map The map of lists.
+   * @param key The key of the list.
+   * @param value The value to add.
+   */
+  _addToList(map, key, value) {
+    const list = map.get(key);
+    if (list) {
+      list.push(value);
+    } else {
+      map.set(key, [value]);
+    }
+  }
 };
 
 // src/rdf/reasoners/shacl-reasoner.ts