@faubulous/mentor-rdf 2.1.6 → 2.1.8

package/dist/index.js

@@ -3061,6 +3061,9 @@ var ConceptRepository = class extends ResourceRepository {
   /**
    * Get the concepts that are explicitly associated with a concept scheme, either via
    * `skos:inScheme` or via `skos:topConceptOf`.
+   *
+   * Note: Collections can be associated with a concept scheme via `skos:inScheme` as well. They
+   * are not returned, because `skos:Collection` is disjoint with `skos:Concept`.
    * @param graphUris URIs of the graphs to search for concepts.
    * @param schemeUri URI of a concept scheme.
    * @returns An iterator of URIs of the concepts of the concept scheme.
@@ -3068,18 +3071,13 @@ var ConceptRepository = class extends ResourceRepository {
   *getConceptsOfScheme(graphUris, schemeUri) {
     const yielded = /* @__PURE__ */ new Set();
     const o = dataFactory.namedNode(schemeUri);
-    for (let q of this.store.matchAll(graphUris, null, skos.inScheme, o)) {
-      const s = q.subject;
-      if (!yielded.has(s.value)) {
-        yielded.add(s.value);
-        yield s.value;
-      }
-    }
-    for (let q of this.store.matchAll(graphUris, null, skos.topConceptOf, o)) {
-      const s = q.subject;
-      if (!yielded.has(s.value)) {
-        yielded.add(s.value);
-        yield s.value;
+    for (let predicate of [skos.inScheme, skos.topConceptOf]) {
+      for (let q of this.store.matchAll(graphUris, null, predicate, o)) {
+        const s = q.subject.value;
+        if (!yielded.has(s) && !this.isCollection(graphUris, s)) {
+          yielded.add(s);
+          yield s;
+        }
       }
     }
   }
@@ -3231,6 +3229,102 @@ var ConceptRepository = class extends ResourceRepository {
     }
     return result;
   }
+  /**
+   * Get the concepts that are not displayed below any concept scheme, i.e. the concepts that are
+   * neither associated with a concept scheme nor reachable from the top concepts of one.
+   * @param graphUris URIs of the graphs to search for concepts.
+   * @param options Optional query options. `definedBy` and `notDefinedBy` filter the concepts by
+   * their definition source.
+   * @returns An iterator of URIs of the concepts outside of all concept schemes.
+   */
+  *getUnscopedConcepts(graphUris, options) {
+    const scopedConcepts = /* @__PURE__ */ new Set();
+    for (let scheme of this.getConceptSchemes(graphUris)) {
+      for (let c of this.getAllConceptsInScheme(graphUris, scheme)) {
+        scopedConcepts.add(c);
+      }
+    }
+    const yielded = /* @__PURE__ */ new Set();
+    for (let q of this.store.matchAll(graphUris, null, rdf.type, skos.Concept)) {
+      const s = q.subject;
+      if (yielded.has(s.value) || scopedConcepts.has(s.value)) {
+        continue;
+      }
+      yielded.add(s.value);
+      if (!this.skip(graphUris, s, options, { includeBlankNodes: true, includeReferenced: true })) {
+        yield s.value;
+      }
+    }
+  }
+  /**
+   * Get the root concepts of the concepts that are not displayed below any concept scheme, see
+   * {@link getUnscopedConcepts}. These are the concepts without a broader concept among them,
+   * plus one concept of every group of concepts that can only be reached through a cycle of
+   * broader concepts, so that every unscoped concept can be reached from one of the roots.
+   *
+   * Note: A concept that is its own broader concept is not excluded, as in {@link getTopConcepts}.
+   * @param graphUris URIs of the graphs to search for concepts.
+   * @param options Optional query options, see {@link getUnscopedConcepts}.
+   * @returns An iterator of URIs of the root concepts outside of all concept schemes.
+   */
+  *getUnscopedRootConcepts(graphUris, options) {
+    const concepts = new Set(this.getUnscopedConcepts(graphUris, options));
+    const narrowerConcepts = this._getNarrowerConceptIndex(graphUris);
+    const nested = this._getNestedConcepts(concepts, narrowerConcepts);
+    const reachable = /* @__PURE__ */ new Set();
+    for (let c of concepts) {
+      if (!nested.has(c)) {
+        this._markReachableConcepts(c, concepts, narrowerConcepts, reachable);
+        yield c;
+      }
+    }
+    for (let c of concepts) {
+      if (!reachable.has(c)) {
+        this._markReachableConcepts(c, concepts, narrowerConcepts, reachable);
+        yield c;
+      }
+    }
+  }
+  /**
+   * Get the concepts of a set that have a broader concept within the same set.
+   * @param concepts The set of concepts.
+   * @param narrowerConcepts The narrower concept index of the graphs, see {@link _getNarrowerConceptIndex}.
+   * @returns The concepts that are nested below another concept of the set.
+   */
+  _getNestedConcepts(concepts, narrowerConcepts) {
+    const result = /* @__PURE__ */ new Set();
+    for (let [broader, narrower] of narrowerConcepts) {
+      if (!concepts.has(broader)) {
+        continue;
+      }
+      for (let n of narrower) {
+        if (n !== broader && concepts.has(n)) {
+          result.add(n);
+        }
+      }
+    }
+    return result;
+  }
+  /**
+   * Mark a concept and the concepts of a set that can be reached from it via narrower concepts.
+   * @param conceptUri The concept to start from.
+   * @param concepts The set of concepts that can be marked.
+   * @param narrowerConcepts The narrower concept index of the graphs, see {@link _getNarrowerConceptIndex}.
+   * @param reachable The set of reachable concepts, which is extended in place.
+   */
+  _markReachableConcepts(conceptUri, concepts, narrowerConcepts, reachable) {
+    const stack = [conceptUri];
+    reachable.add(conceptUri);
+    while (stack.length) {
+      const current = stack.pop();
+      for (let n of narrowerConcepts.get(current) ?? []) {
+        if (concepts.has(n) && !reachable.has(n)) {
+          reachable.add(n);
+          stack.push(n);
+        }
+      }
+    }
+  }
   /**
    * Get the members of a collection. This includes both `skos:member` and `skos:memberList` properties.
    * @param graphUris URI of the graphs to search for collections.
@@ -4625,11 +4719,40 @@ var SkosReasoner = class extends ReasonerBase {
     this.concepts = /* @__PURE__ */ new Set();
     this.conceptSchemes = /* @__PURE__ */ new Set();
     this.collections = /* @__PURE__ */ new Set();
+    /**
+     * Subjects of `skos:inScheme` triples, keyed by their value. Whether they are concepts can only
+     * be decided once all triples of the graph were processed, see {@link afterInference}.
+     */
+    this._inSchemeSubjects = /* @__PURE__ */ new Map();
   }
   applyInference(quad5) {
     this.inferConceptAxioms(quad5);
     this.inferCollectionAxioms(quad5);
   }
+  /**
+   * Infers the subjects of `skos:inScheme` triples to be concepts, unless they are collections.
+   * `skos:inScheme` has no domain, and `skos:Collection` is disjoint with `skos:Concept`. The
+   * type of a collection may be processed after its `skos:inScheme` triple, so this is done after
+   * all triples of the graph were processed.
+   */
+  afterInference() {
+    super.afterInference();
+    for (let [id, subject] of this._inSchemeSubjects) {
+      if (!this.collections.has(id)) {
+        this.assertConcept(subject);
+      }
+    }
+  }
+  /**
+   * Clears the state that was collected for the graph, so it does not affect the next graph.
+   */
+  resetState() {
+    super.resetState();
+    this.concepts.clear();
+    this.conceptSchemes.clear();
+    this.collections.clear();
+    this._inSchemeSubjects.clear();
+  }
   assertConcept(subject) {
     this.store.add(quad(subject, rdf.type, skos.Concept, this.targetGraph));
     this.concepts.add(subject.value);
@@ -4658,7 +4781,7 @@ var SkosReasoner = class extends ReasonerBase {
         return;
       }
       case skos.inScheme.value: {
-        this.assertConcept(s);
+        this._inSchemeSubjects.set(s.value, s);
         this.assertConceptScheme(o);
         return;
       }
@@ -4745,6 +4868,7 @@ var RdfsReasoner = class extends SkosReasoner {
     }
   }
   resetState() {
+    super.resetState();
     this.ontologies.clear();
     this.classes.clear();
     this.properties.clear();