@faubulous/mentor-rdf 2.1.9 → 2.2.1

package/dist/index.js

@@ -4692,7 +4692,7 @@ var ReasonerBase = class {
     this.store = store;
     this.sourceGraph = this.getGraphNode(sourceGraph);
     this.targetGraph = this.getGraphNode(targetGraph);
-    for (let quad5 of store.match(null, null, null, this.targetGraph)) {
+    for (const quad5 of Array.from(store.match(null, null, null, this.targetGraph))) {
       store.delete(quad5);
     }
     this.beforeInference();
@@ -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
@@ -9319,7 +9411,7 @@ var toRdflibTerm = (term) => {
 };
 
 // src/rdf/store.ts
-import { TurtleLexer, TurtleParser, TurtleReader, NQuadsLexer, NQuadsParser, NQuadsReader, createFileBlankNodeIdGenerator } from "@faubulous/mentor-rdf-parsers";
+import { TurtleLexer, TurtleParser, TurtleReader, TurtleQuadReader, QuadReaderError, NQuadsLexer, NQuadsParser, NQuadsReader, createFileBlankNodeIdGenerator } from "@faubulous/mentor-rdf-parsers";
 var TripleNotFoundError = class extends Error {
   /**
    * Create a new instance of the error.
@@ -9337,14 +9429,17 @@ var Store = class {
    */
   constructor(reasoner) {
     /**
-     * The adapted RDF.js triple store implementation.
-     * 
-     * Note: Please do not use this directly, but rather use the `_ds` property to access the dataset.
+     * The adapted RDF.js triple store implementation. Replaced by {@link clear}.
+     *
+     * Reads go through `_store.readQuads`, a live iterator over the indexes. The dataset
+     * view's `match` is never used for reading: rdf-stores implements it by copying every
+     * matching quad into a new store first, which costs hundreds of megabytes and
+     * seconds for a graph the size of a workspace vocabulary.
      */
     this._store = RdfStore2.createDefault();
     /**
-     * The RDF dataset containing the triples in the store, which should primarily be used
-     * for any operations so that the store can be swapped out with a different implementation.
+     * The RDF dataset view of {@link _store}, used for the mutations and membership
+     * checks of the `DatasetCore` interface.
      */
     this._ds = this._store.asDataset();
     /**
@@ -9437,13 +9532,29 @@ var Store = class {
   /**
    * Get the URIs of the graphs in the triple store.
    * @returns An array of graph URIs in no particular order.
+   * @note Every mutation of the store records the graph it touched, so the graphs are the
+   * recorded ones that still hold a triple. Matching all triples instead would copy the whole
+   * store, which takes seconds for a store holding a large workspace.
    */
   getGraphs() {
-    const result = /* @__PURE__ */ new Set();
-    for (const q of this._ds.match(null, null, null, null)) {
-      result.add(q.graph.value);
+    return Array.from(this._graphVersions.keys()).filter((graphUri) => this._hasTriples(graphUri));
+  }
+  /**
+   * Indicates if a graph holds at least one triple, without reading more than one.
+   * @param graph The graph term, or its URI with an empty string for the default graph.
+   */
+  _hasTriples(graph2) {
+    return !this._store.readQuads(null, null, null, this._getGraphTerm(graph2)).next().done;
+  }
+  /**
+   * Resolves a graph URI to its term; an empty string denotes the default graph.
+   * @param graph The graph term or URI.
+   */
+  _getGraphTerm(graph2) {
+    if (typeof graph2 !== "string") {
+      return graph2;
     }
-    return Array.from(result);
+    return graph2 === "" ? this.dataFactory.defaultGraph() : this.dataFactory.namedNode(graph2);
   }
   /**
    * Load a set of triples into the store.
@@ -9478,11 +9589,7 @@ var Store = class {
   _loadQuads(quads, graphUri, executeInference = true, clearGraph = true, onQuad) {
     const graph2 = this.dataFactory.namedNode(graphUri.replace("\\", "/"));
     if (clearGraph) {
-      this.deleteGraphs([graphUri]);
-      if (this.reasoner) {
-        const inferenceGraph = this.dataFactory.namedNode(this.reasoner.targetUriGenerator.getGraphUri(graphUri));
-        this.deleteGraphs([inferenceGraph.value]);
-      }
+      this.deleteGraphs([graphUri], true);
     }
     for (let q of quads) {
       this._ds.add(this.dataFactory.quad(q.subject, q.predicate, q.object, graph2));
@@ -9492,10 +9599,21 @@ var Store = class {
     }
     this._touchGraph(graph2.value);
     if (this.reasoner && executeInference) {
-      this.reasoner.expand(this._ds, graphUri);
-      this._touchGraph(this.reasoner.targetUriGenerator.getGraphUri(graphUri));
+      this._expand(graphUri);
     }
   }
+  /**
+   * Runs the reasoner over a graph. The reasoner is handed this store rather than the
+   * dataset view, so its reads are live iterators and its writes bump the graph versions.
+   * @param graphUri The URI of the source graph.
+   */
+  _expand(graphUri) {
+    if (!this.reasoner) {
+      return;
+    }
+    this.reasoner.expand(this, graphUri);
+    this._touchGraph(this.reasoner.targetUriGenerator.getGraphUri(graphUri));
+  }
   /**
    * Create an RDF store from Turtle, N3 or N-Triples data.
    * @param input Input string in Turtle, N3 or N-Triples format.
@@ -9507,11 +9625,29 @@ var Store = class {
    */
   loadTurtle(input, graphUri, executeInference = true, clearGraph = true, onQuad) {
     const tokens = new TurtleLexer(createFileBlankNodeIdGenerator(graphUri)).tokenize(input).tokens;
-    const cst = new TurtleParser().parse(tokens, false);
-    const quads = new TurtleReader().visit(cst);
+    const quads = this._readTurtleQuads(tokens);
     this._loadQuads(quads, graphUri, executeInference, clearGraph, onQuad);
     return this;
   }
+  /**
+   * Reads the quads of a Turtle token stream. A valid document is read without a syntax
+   * tree, which is the fast path. A document the quad reader rejects is parsed with error
+   * recovery and read from its syntax tree, so that a partially valid document yields the
+   * quads it did before.
+   * @param tokens The tokens of the document.
+   * @returns The quads of the document.
+   */
+  _readTurtleQuads(tokens) {
+    try {
+      return new TurtleQuadReader().read(tokens);
+    } catch (error) {
+      if (!(error instanceof QuadReaderError)) {
+        throw error;
+      }
+      const cst = new TurtleParser().parse(tokens, false);
+      return new TurtleReader().visit(cst);
+    }
+  }
   /**
    * Create an RDF store from N-Quads data.
    * @param input Input string in N-Quads format.
@@ -9572,7 +9708,7 @@ var Store = class {
       const targetGraph = targetGraphUri ? this.dataFactory.namedNode(targetGraphUri) : void 0;
       const store = graph();
       const g = targetGraph ? toRdflibTerm(targetGraph) : void 0;
-      for (const q of this._ds.match(null, null, null, sourceGraph)) {
+      for (const q of this._store.readQuads(null, null, null, sourceGraph)) {
         const s = toRdflibTerm(q.subject);
         const p = toRdflibTerm(q.predicate);
         const o = toRdflibTerm(q.object);
@@ -9594,40 +9730,46 @@ var Store = class {
    * @returns `true` if the store contains triples in the graph URI, `false` otherwise.
    */
   hasGraph(graphUri) {
-    const uri = typeof graphUri === "string" ? this.dataFactory.namedNode(graphUri) : graphUri;
-    for (const _ of this._ds.match(null, null, null, uri)) {
-      return true;
-    }
-    return false;
+    return this._hasTriples(graphUri);
   }
   /**
    * Apply inference to the given graph and store the triples in the associated inference graph.
    * @param graphUri A graph URI.
    */
   executeInference(graphUri) {
-    if (this.reasoner) {
-      this.reasoner.expand(this._ds, graphUri);
-      const uri = typeof graphUri === "string" ? graphUri : graphUri.value;
-      this._touchGraph(this.reasoner.targetUriGenerator.getGraphUri(uri));
-    }
+    this._expand(typeof graphUri === "string" ? graphUri : graphUri.value);
   }
   /**
    * Delete named graphs from the store.
-   * @param graphUris URIs of the graphs to be deleted.
-   */
-  deleteGraphs(graphUris) {
-    for (const graphUri of graphUris) {
-      const graph2 = this.dataFactory.namedNode(graphUri);
-      let deleted = false;
-      for (const quad5 of this._ds.match(null, null, null, graph2)) {
-        this._ds.delete(quad5);
-        deleted = true;
-      }
-      if (deleted) {
+   * @param graphUris URIs of the graphs to be deleted; an empty string denotes the default graph.
+   * @param includeInferred Whether to also delete the inference graph of each graph, as
+   * named by the reasoner's target URI generator. Ignored when the store has no reasoner.
+   */
+  deleteGraphs(graphUris, includeInferred = false) {
+    const uris = includeInferred && this.reasoner ? graphUris.flatMap((uri) => [uri, this.reasoner.targetUriGenerator.getGraphUri(uri)]) : graphUris;
+    for (const graphUri of uris) {
+      const quads = this._store.getQuads(null, null, null, this._getGraphTerm(graphUri));
+      for (const quad5 of quads) {
+        this._store.removeQuad(quad5);
+      }
+      if (quads.length > 0) {
         this._touchGraph(graphUri);
       }
     }
   }
+  /**
+   * Removes every quad from the store and releases the memory of the underlying store,
+   * including its term dictionary, which never shrinks when quads are deleted. The
+   * version counters keep increasing so that cached views and validators notice the change.
+   */
+  clear() {
+    this._store = RdfStore2.createDefault();
+    this._ds = this._store.asDataset();
+    for (const graphUri of this._graphVersions.keys()) {
+      this._touchGraph(graphUri);
+    }
+    this._version++;
+  }
   /**
    * Get the URIs of ordered list members in the store.
    * @param graphUris Optional graph URI or array of graph URIs to query.
@@ -9677,7 +9819,9 @@ var Store = class {
   /**
    * Returns a lazy, read-only dataset view of the quads matching the given pattern.
    * Implements the RDF/JS `DatasetCore.match` semantics: the result reflects the
-   * current contents of the store and does not copy any quads.
+   * current contents of the store and does not copy any quads. Because the view
+   * iterates the live indexes, do not add or delete quads while iterating it;
+   * take a snapshot with `Array.from(...)` first.
    * @param subject The optional subject.
    * @param predicate The optional predicate.
    * @param object The optional object.
@@ -9694,14 +9838,15 @@ var Store = class {
     });
   }
   /**
-   * Synchronously iterate the quads matching a single pattern.
+   * Synchronously iterate the quads matching a single pattern. The iterator is live:
+   * do not add or delete quads while iterating; take a snapshot with `Array.from(...)` first.
    * @param subject The optional subject.
    * @param predicate The optional predicate.
    * @param object The optional object.
    * @param graph The optional graph.
    */
   *matchQuads(subject, predicate, object, graph2) {
-    yield* this._ds.match(subject, predicate, object, graph2);
+    yield* this._store.readQuads(subject, predicate, object, graph2);
   }
   /**
    * Get an RDF/JS `Source` interface for the store that streams matching quads.
@@ -9715,6 +9860,8 @@ var Store = class {
   }
   /**
    * Query the store for triples matching the given pattern supporting multiple graphs.
+   * The iterator is live: do not add or delete quads while iterating; take a snapshot
+   * with `Array.from(...)` first.
    * @param graphUris Optional graph URI or array of graph URIs to query.
    * @param subject A subject URI or null to match any subject.
    * @param predicate A predicate URI or null to match any predicate.
@@ -9730,19 +9877,15 @@ var Store = class {
     if (graphUris !== void 0) {
       const graphs = Array.isArray(graphUris) ? graphUris : [graphUris];
       for (const graph2 of graphs.map((g) => this.dataFactory.namedNode(g))) {
-        for (const q of this._ds.match(s, p, o, graph2)) {
-          yield q;
-        }
+        yield* this._store.readQuads(s, p, o, graph2);
         if (includeInferred !== false && this.reasoner) {
           const inferenceGraphUri = this.reasoner.targetUriGenerator.getGraphUri(graph2.value);
           const inferenceGraph = this.dataFactory.namedNode(inferenceGraphUri);
-          for (let q of this._ds.match(s, p, o, inferenceGraph)) {
-            yield q;
-          }
+          yield* this._store.readQuads(s, p, o, inferenceGraph);
         }
       }
     } else {
-      yield* this._ds.match(s, p, o);
+      yield* this._store.readQuads(s, p, o, null);
     }
   }
   /**