rdfjs-resource 2.0.5 → 2.0.6

package/dist/AbstractTermValue.d.ts

@@ -1,12 +1,14 @@
-import type { BlankNode, Literal, NamedNode } from "@rdfjs/types";
+import type { BlankNode, DataFactory, Literal, NamedNode, Quad_Graph, Variable } from "@rdfjs/types";
 import { Either } from "purify-ts";
 import { MistypedTermValueError } from "./MistypedTermValueError.js";
 import { Resource } from "./Resource.js";
 export declare abstract class AbstractTermValue<TermT extends BlankNode | Literal | NamedNode> {
+    protected readonly dataFactory: DataFactory;
     protected readonly focusResource: Resource;
     protected readonly predicate: NamedNode;
     protected readonly term: TermT;
-    constructor({ focusResource, predicate, term, }: {
+    constructor({ dataFactory, focusResource, predicate, term, }: {
+        dataFactory: DataFactory;
         focusResource: Resource;
         predicate: NamedNode;
         term: TermT;
@@ -23,7 +25,9 @@ export declare abstract class AbstractTermValue<TermT extends BlankNode | Litera
     /**
      * Try to convert the term to a named resource.
      */
-    toNamedResource(): Either<MistypedTermValueError, Resource<NamedNode>>;
+    toNamedResource(options?: {
+        graph?: Exclude<Quad_Graph, Variable>;
+    }): Either<MistypedTermValueError, Resource<NamedNode>>;
     toTerm(): TermT;
     protected newMistypedValueError(expectedValueType: string): MistypedTermValueError;
 }

package/dist/AbstractTermValue.js

@@ -2,7 +2,8 @@ import { Either, Left } from "purify-ts";
 import { MistypedTermValueError } from "./MistypedTermValueError.js";
 import { Resource } from "./Resource.js";
 export class AbstractTermValue {
-    constructor({ focusResource, predicate, term, }) {
+    constructor({ dataFactory, focusResource, predicate, term, }) {
+        this.dataFactory = dataFactory;
         this.focusResource = focusResource;
         this.predicate = predicate;
         this.term = term;
@@ -29,8 +30,11 @@ export class AbstractTermValue {
     /**
      * Try to convert the term to a named resource.
      */
-    toNamedResource() {
-        return this.toIri().map((identifier) => new Resource(this.focusResource.dataset, identifier));
+    toNamedResource(options) {
+        return this.toIri().map((identifier) => new Resource(this.focusResource.dataset, identifier, {
+            dataFactory: this.dataFactory,
+            graph: options?.graph,
+        }));
     }
     toTerm() {
         return this.term;

package/dist/DatasetObjectValues.js

@@ -22,6 +22,7 @@ export class DatasetObjectValues extends DatasetValues {
                     continue;
                 }
                 yield new TermValue({
+                    dataFactory: this.dataFactory,
                     focusResource: this.focusResource,
                     predicate: this.predicate,
                     term: nonUniqueTerm,
@@ -32,6 +33,7 @@ export class DatasetObjectValues extends DatasetValues {
         else {
             for (const nonUniqueTerm of this.nonUniqueTermIterator()) {
                 yield new TermValue({
+                    dataFactory: this.dataFactory,
                     focusResource: this.focusResource,
                     predicate: this.predicate,
                     term: nonUniqueTerm,
@@ -53,7 +55,7 @@ export class DatasetObjectValues extends DatasetValues {
         //     }
         //   }
         // } else {
-        for (const quad of this.focusResource.dataset.match(this.focusResource.identifier, this.predicate, null, null)) {
+        for (const quad of this.focusResource.dataset.match(this.focusResource.identifier, this.predicate, null, this.graph)) {
             switch (quad.object.termType) {
                 case "BlankNode":
                 case "Literal":

package/dist/DatasetSubjectValues.js

@@ -15,6 +15,7 @@ export class DatasetSubjectValues extends DatasetValues {
                     continue;
                 }
                 yield new IdentifierValue({
+                    dataFactory: this.dataFactory,
                     focusResource: this.focusResource,
                     predicate: this.predicate,
                     term: nonUniqueIdentifier,
@@ -25,6 +26,7 @@ export class DatasetSubjectValues extends DatasetValues {
         else {
             for (const nonUniqueIdentifier of this.nonUniqueIdentifierIterator()) {
                 yield new IdentifierValue({
+                    dataFactory: this.dataFactory,
                     focusResource: this.focusResource,
                     predicate: this.predicate,
                     term: nonUniqueIdentifier,
@@ -33,7 +35,7 @@ export class DatasetSubjectValues extends DatasetValues {
         }
     }
     *nonUniqueIdentifierIterator() {
-        for (const quad of this.focusResource.dataset.match(null, this.predicate, this.focusResource.identifier)) {
+        for (const quad of this.focusResource.dataset.match(null, this.predicate, this.focusResource.identifier, this.graph)) {
             switch (quad.subject.termType) {
                 case "BlankNode":
                 case "NamedNode":

package/dist/DatasetValues.d.ts

@@ -1,10 +1,14 @@
-import type { NamedNode } from "@rdfjs/types";
+import type { DataFactory, NamedNode, Quad_Graph, Variable } from "@rdfjs/types";
 import type { Resource } from "./Resource.js";
 import { Values } from "./Values.js";
 export declare abstract class DatasetValues<ValueT> extends Values<ValueT> {
+    protected readonly dataFactory: DataFactory;
+    protected readonly graph: Exclude<Quad_Graph, Variable> | null;
     protected readonly unique: boolean;
-    constructor({ focusResource, predicate, unique, }: {
+    constructor({ dataFactory, focusResource, graph, predicate, unique, }: {
+        dataFactory: DataFactory;
         focusResource: Resource;
+        graph: Exclude<Quad_Graph, Variable> | null;
         predicate: NamedNode;
         unique: boolean;
     });

package/dist/DatasetValues.js

@@ -1,7 +1,9 @@
 import { Values } from "./Values.js";
 export class DatasetValues extends Values {
-    constructor({ focusResource, predicate, unique, }) {
+    constructor({ dataFactory, focusResource, graph, predicate, unique, }) {
         super({ focusResource, predicate });
+        this.dataFactory = dataFactory;
+        this.graph = graph;
         this.unique = unique;
     }
     get length() {

package/dist/IdentifierValue.d.ts

@@ -1,3 +1,4 @@
+import type { Quad_Graph, Variable } from "@rdfjs/types";
 import { AbstractTermValue } from "./AbstractTermValue.js";
 import type { Identifier } from "./Identifier.js";
 import { Resource } from "./Resource.js";
@@ -6,6 +7,8 @@ import { Resource } from "./Resource.js";
  */
 export declare class IdentifierValue extends AbstractTermValue<Identifier> {
     toIdentifier(): Identifier;
-    toResource(): Resource;
+    toResource(options?: {
+        graph?: Exclude<Quad_Graph, Variable>;
+    }): Resource;
 }
 //# sourceMappingURL=IdentifierValue.d.ts.map

package/dist/IdentifierValue.js

@@ -7,8 +7,11 @@ export class IdentifierValue extends AbstractTermValue {
     toIdentifier() {
         return this.term;
     }
-    toResource() {
-        return new Resource(this.focusResource.dataset, this.term);
+    toResource(options) {
+        return new Resource(this.focusResource.dataset, this.term, {
+            dataFactory: this.dataFactory,
+            graph: options?.graph,
+        });
     }
 }
 //# sourceMappingURL=IdentifierValue.js.map

package/dist/Resource.d.ts

@@ -15,9 +15,11 @@ export declare class Resource<IdentifierT extends Resource.Identifier = Resource
     readonly dataset: DatasetCore;
     readonly identifier: IdentifierT;
     private readonly dataFactory;
+    private readonly graph?;
     private readonly literalFactory;
     constructor(dataset: DatasetCore, identifier: IdentifierT, options?: {
         dataFactory?: DataFactory;
+        graph?: Exclude<Quad_Graph, Variable>;
     });
     /**
      * Add zero or more values to this resource.
@@ -47,10 +49,12 @@ export declare class Resource<IdentifierT extends Resource.Identifier = Resource
     delete(predicate: NamedNode, object?: AddableValue | readonly AddableValue[], graph?: Exclude<Quad_Graph, Variable>): this;
     isInstanceOf(class_: NamedNode, options?: {
         excludeSubclasses?: boolean;
+        graph?: Exclude<Quad_Graph, Variable>;
         instanceOfPredicate?: NamedNode;
         subClassOfPredicate?: NamedNode;
     }): boolean;
     isSubClassOf(class_: NamedNode, options?: {
+        graph?: Exclude<Quad_Graph, Variable>;
         subClassOfPredicate?: NamedNode;
     }): boolean;
     /**
@@ -60,26 +64,34 @@ export declare class Resource<IdentifierT extends Resource.Identifier = Resource
     /**
      * Consider the resource itself as an RDF list.
      */
-    toList(): Either<Resource.ValueError, readonly Resource.TermValue[]>;
+    toList(options?: {
+        graph?: Exclude<Quad_Graph, Variable>;
+    }): Either<Resource.ValueError, readonly Resource.TermValue[]>;
     /**
      * Get the first matching value of dataset statements (this.identifier, predicate, value).
      */
-    value(predicate: NamedNode): Either<Resource.ValueError, Resource.TermValue>;
+    value(predicate: NamedNode, options?: {
+        graph?: Exclude<Quad_Graph, Variable>;
+    }): Either<Resource.ValueError, Resource.TermValue>;
     /**
      * Get the first matching subject of dataset statements (subject, predicate, this.identifier).
      */
-    valueOf(predicate: NamedNode): Either<Resource.ValueError, Resource.IdentifierValue>;
+    valueOf(predicate: NamedNode, options?: {
+        graph?: Exclude<Quad_Graph, Variable>;
+    }): Either<Resource.ValueError, Resource.IdentifierValue>;
     /**
      * Get all values of dataset statements (this.identifier, predicate, value).
      */
     values(predicate: NamedNode, options?: {
+        graph?: Exclude<Quad_Graph, Variable>;
         unique?: boolean;
     }): Resource.Values<Resource.TermValue>;
     /**
      * Get the subject of dataset statements (subject, predicate, this.identifier).
      */
     valuesOf(predicate: NamedNode, options?: {
-        unique: true;
+        graph?: Exclude<Quad_Graph, Variable>;
+        unique?: boolean;
     }): Resource.Values<Resource.IdentifierValue>;
     private addableValueToTerm;
     private addableValuesToTerms;

package/dist/Resource.js

@@ -20,6 +20,7 @@ export class Resource {
         this.dataset = dataset;
         this.identifier = identifier;
         this.dataFactory = options?.dataFactory ?? DefaultDataFactory;
+        this.graph = options?.graph;
         this.literalFactory = new LiteralFactory({ dataFactory: this.dataFactory });
     }
     /**
@@ -27,7 +28,7 @@ export class Resource {
      */
     add(predicate, object, graph) {
         for (const term of this.addableValuesToTerms(object)) {
-            this.dataset.add(this.dataFactory.quad(this.identifier, predicate, term, graph));
+            this.dataset.add(this.dataFactory.quad(this.identifier, predicate, term, graph ?? this.graph));
         }
         return this;
     }
@@ -38,16 +39,18 @@ export class Resource {
      * Returns the list resource.
      */
     addList(predicate, items, options) {
+        const graph = options?.graph ?? this.graph;
         const itemsArray = [...items];
         if (itemsArray.length === 0) {
             return new Resource(this.dataset, rdf.nil, {
                 dataFactory: this.dataFactory,
+                graph,
             });
         }
         const mintSubListIdentifier = options?.mintSubListIdentifier ?? (() => this.dataFactory.blankNode());
-        const listResource = new Resource(this.dataset, mintSubListIdentifier(itemsArray[0], 0), { dataFactory: this.dataFactory });
+        const listResource = new Resource(this.dataset, mintSubListIdentifier(itemsArray[0], 0), { dataFactory: this.dataFactory, graph });
         listResource.addListItems(itemsArray, { mintSubListIdentifier });
-        this.add(predicate, listResource.identifier);
+        this.add(predicate, listResource.identifier, graph);
         return listResource;
     }
     /**
@@ -55,14 +58,14 @@ export class Resource {
      */
     addListItems(items, options) {
         const addSubListResourceValues = options?.addSubListResourceValues ?? (() => { });
-        const graph = options?.graph;
+        const graph = options?.graph ?? this.graph;
         const mintSubListIdentifier = options?.mintSubListIdentifier ?? (() => this.dataFactory.blankNode());
         let currentHead = this;
         let itemIndex = 0;
         for (const item of items) {
             if (itemIndex > 0) {
                 // If currentHead !== this, then create a new head and point the current head's rdf:rest at it
-                const newHead = new Resource(this.dataset, mintSubListIdentifier(item, itemIndex), { dataFactory: this.dataFactory });
+                const newHead = new Resource(this.dataset, mintSubListIdentifier(item, itemIndex), { dataFactory: this.dataFactory, graph });
                 addSubListResourceValues(newHead);
                 currentHead.add(rdf.rest, newHead.identifier, graph);
                 currentHead = newHead;
@@ -86,7 +89,7 @@ export class Resource {
     delete(predicate, object, graph) {
         if (!object) {
             for (const quad of [
-                ...this.dataset.match(this.identifier, predicate, null, graph),
+                ...this.dataset.match(this.identifier, predicate, null, graph ?? this.graph),
             ]) {
                 this.dataset.delete(quad);
             }
@@ -94,7 +97,7 @@ export class Resource {
         else {
             for (const term of this.addableValuesToTerms(object)) {
                 for (const quad of [
-                    ...this.dataset.match(this.identifier, predicate, term, graph),
+                    ...this.dataset.match(this.identifier, predicate, term, graph ?? this.graph),
                 ]) {
                     this.dataset.delete(quad);
                 }
@@ -106,11 +109,12 @@ export class Resource {
         return isInstanceOfRecursive({
             class_,
             dataset: this.dataset,
+            graph: options?.graph ?? this.graph,
             instance: this.identifier,
             visitedClasses: new TermSet(),
         });
-        function isInstanceOfRecursive({ class_, dataset, instance, visitedClasses, }) {
-            for (const _ of dataset.match(instance, options?.instanceOfPredicate ?? rdf.type, class_)) {
+        function isInstanceOfRecursive({ class_, dataset, graph, instance, visitedClasses, }) {
+            for (const _ of dataset.match(instance, options?.instanceOfPredicate ?? rdf.type, class_, graph)) {
                 return true;
             }
             visitedClasses.add(class_);
@@ -118,7 +122,7 @@ export class Resource {
                 return false;
             }
             // Recurse into class's sub-classes that haven't been visited yet.
-            for (const quad of dataset.match(null, options?.subClassOfPredicate ?? rdfs.subClassOf, class_, null)) {
+            for (const quad of dataset.match(null, options?.subClassOfPredicate ?? rdfs.subClassOf, class_, graph)) {
                 if (quad.subject.termType !== "NamedNode") {
                     continue;
                 }
@@ -128,6 +132,7 @@ export class Resource {
                 if (isInstanceOfRecursive({
                     class_: quad.subject,
                     dataset,
+                    graph,
                     instance,
                     visitedClasses,
                 })) {
@@ -141,16 +146,17 @@ export class Resource {
         return isSubClassOfRecursive({
             class_,
             dataset: this.dataset,
+            graph: options?.graph ?? this.graph,
             thisIdentifier: this.identifier,
             visitedClasses: new TermSet(),
         });
-        function isSubClassOfRecursive({ class_, dataset, thisIdentifier, visitedClasses, }) {
-            for (const _ of dataset.match(thisIdentifier, options?.subClassOfPredicate ?? rdfs.subClassOf, class_)) {
+        function isSubClassOfRecursive({ class_, dataset, graph, thisIdentifier, visitedClasses, }) {
+            for (const _ of dataset.match(thisIdentifier, options?.subClassOfPredicate ?? rdfs.subClassOf, class_, graph)) {
                 return true;
             }
             visitedClasses.add(class_);
             // Recurse into class's sub-classes that haven't been visited yet.
-            for (const quad of dataset.match(null, options?.subClassOfPredicate ?? rdfs.subClassOf, class_, null)) {
+            for (const quad of dataset.match(null, options?.subClassOfPredicate ?? rdfs.subClassOf, class_, graph)) {
                 if (quad.subject.termType !== "NamedNode") {
                     continue;
                 }
@@ -160,6 +166,7 @@ export class Resource {
                 if (isSubClassOfRecursive({
                     class_: quad.subject,
                     dataset,
+                    graph,
                     thisIdentifier,
                     visitedClasses,
                 })) {
@@ -179,12 +186,13 @@ export class Resource {
     /**
      * Consider the resource itself as an RDF list.
      */
-    toList() {
+    toList(options) {
         if (this.identifier.equals(rdf.nil)) {
             return Either.of([]);
         }
+        const graph = options?.graph ?? this.graph;
         const firstObjects = [
-            ...new TermSet([...this.dataset.match(this.identifier, rdf.first, null)].map((quad) => quad.object)),
+            ...new TermSet([...this.dataset.match(this.identifier, rdf.first, null, graph)].map((quad) => quad.object)),
         ];
         if (firstObjects.length === 0) {
             return Left(new Resource.ListStructureError({
@@ -215,7 +223,7 @@ export class Resource {
                 }));
         }
         const restObjects = [
-            ...new TermSet([...this.dataset.match(this.identifier, rdf.rest, null)].map((quad) => quad.object)),
+            ...new TermSet([...this.dataset.match(this.identifier, rdf.rest, null, graph)].map((quad) => quad.object)),
         ];
         if (restObjects.length === 0) {
             return Left(new Resource.ListStructureError({
@@ -246,32 +254,38 @@ export class Resource {
         }
         return Either.of([
             new Resource.TermValue({
+                dataFactory: this.dataFactory,
                 focusResource: this,
                 predicate: rdf.first,
                 term: firstObject,
             }),
-        ]).chain((items) => new Resource(this.dataset, restObject)
-            .toList()
+        ]).chain((items) => new Resource(this.dataset, restObject, {
+            dataFactory: this.dataFactory,
+            graph,
+        })
+            .toList({ graph })
             .map((restItems) => items.concat(restItems)));
     }
     /**
      * Get the first matching value of dataset statements (this.identifier, predicate, value).
      */
-    value(predicate) {
-        return this.values(predicate).head();
+    value(predicate, options) {
+        return this.values(predicate, options).head();
     }
     /**
      * Get the first matching subject of dataset statements (subject, predicate, this.identifier).
      */
-    valueOf(predicate) {
-        return this.valuesOf(predicate).head();
+    valueOf(predicate, options) {
+        return this.valuesOf(predicate, options).head();
     }
     /**
      * Get all values of dataset statements (this.identifier, predicate, value).
      */
     values(predicate, options) {
         return new DatasetObjectValues({
+            dataFactory: this.dataFactory,
             focusResource: this,
+            graph: options?.graph ?? this.graph ?? null,
             predicate,
             unique: !!options?.unique,
         });
@@ -281,7 +295,9 @@ export class Resource {
      */
     valuesOf(predicate, options) {
         return new DatasetSubjectValues({
+            dataFactory: this.dataFactory,
             focusResource: this,
+            graph: options?.graph ?? this.graph ?? null,
             predicate,
             unique: !!options?.unique,
         });

package/dist/ResourceSet.d.ts

@@ -6,17 +6,21 @@ import { Resource } from "./Resource.js";
 export declare class ResourceSet {
     readonly dataset: DatasetCore;
     private readonly dataFactory;
+    private readonly graph?;
     constructor(dataset: DatasetCore, options?: {
         dataFactory?: DataFactory;
+        graph?: Exclude<Quad_Graph, Variable>;
     });
     instancesOf(class_: NamedNode, options?: {
         excludeSubclasses?: boolean;
-        graph?: Exclude<Quad_Graph, Variable> | null;
+        graph?: Exclude<Quad_Graph, Variable>;
         instanceOfPredicate?: NamedNode;
         subClassOfPredicate?: NamedNode;
     }): Generator<Resource>;
     namedInstancesOf(class_: NamedNode, options?: Parameters<ResourceSet["instancesOf"]>[1]): Generator<Resource<NamedNode>>;
-    resource<IdentifierT extends Resource.Identifier>(identifier: IdentifierT): Resource<IdentifierT>;
+    resource<IdentifierT extends Resource.Identifier>(identifier: IdentifierT, options?: {
+        graph?: Exclude<Quad_Graph, Variable>;
+    }): Resource<IdentifierT>;
     private instanceIdentifiers;
 }
 //# sourceMappingURL=ResourceSet.d.ts.map

package/dist/ResourceSet.js

@@ -9,6 +9,7 @@ export class ResourceSet {
     constructor(dataset, options) {
         this.dataset = dataset;
         this.dataFactory = options?.dataFactory ?? DefaultDataFactory;
+        this.graph = options?.graph;
     }
     *instancesOf(class_, options) {
         for (const identifier of this.instanceIdentifiers(class_, options)) {
@@ -18,24 +19,26 @@ export class ResourceSet {
     *namedInstancesOf(class_, options) {
         for (const identifier of this.instanceIdentifiers(class_, options)) {
             if (identifier.termType === "NamedNode")
-                yield this.resource(identifier);
+                yield this.resource(identifier, { graph: options?.graph });
         }
     }
-    resource(identifier) {
+    resource(identifier, options) {
         return new Resource(this.dataset, identifier, {
             dataFactory: this.dataFactory,
+            graph: options?.graph ?? this.graph,
         });
     }
     *instanceIdentifiers(class_, options) {
         yield* instanceIdentifiersRecursive({
             class_,
             dataset: this.dataset,
+            graph: options?.graph ?? this.graph,
             visitedClasses: new TermSet(),
             yieldedInstanceIdentifiers: new TermSet(),
         });
-        function* instanceIdentifiersRecursive({ class_, dataset, visitedClasses, yieldedInstanceIdentifiers, }) {
+        function* instanceIdentifiersRecursive({ class_, dataset, graph, visitedClasses, yieldedInstanceIdentifiers, }) {
             // Get instanceQuads of the class
-            for (const quad of dataset.match(null, options?.instanceOfPredicate ?? rdf.type, class_, options?.graph)) {
+            for (const quad of dataset.match(null, options?.instanceOfPredicate ?? rdf.type, class_, graph)) {
                 switch (quad.subject.termType) {
                     case "BlankNode":
                     case "NamedNode":
@@ -53,7 +56,7 @@ export class ResourceSet {
                 return;
             }
             // Recurse into class's sub-classes that haven't been visited yet.
-            for (const quad of dataset.match(null, options?.subClassOfPredicate ?? rdfs.subClassOf, class_, options?.graph)) {
+            for (const quad of dataset.match(null, options?.subClassOfPredicate ?? rdfs.subClassOf, class_, graph)) {
                 if (quad.subject.termType !== "NamedNode") {
                     continue;
                 }
@@ -63,6 +66,7 @@ export class ResourceSet {
                 yield* instanceIdentifiersRecursive({
                     class_: quad.subject,
                     dataset,
+                    graph,
                     visitedClasses,
                     yieldedInstanceIdentifiers,
                 });

package/dist/TermValue.d.ts

@@ -1,4 +1,4 @@
-import type { BlankNode, Literal, NamedNode } from "@rdfjs/types";
+import type { BlankNode, Literal, NamedNode, Quad_Graph, Variable } from "@rdfjs/types";
 import { Either } from "purify-ts";
 import { AbstractTermValue } from "./AbstractTermValue.js";
 import type { Identifier } from "./Identifier.js";
@@ -42,7 +42,9 @@ export declare class TermValue extends AbstractTermValue<BlankNode | Literal | N
     /**
      * Try to convert the term to an RDF list.
      */
-    toList(): Either<ValueError, readonly TermValue[]>;
+    toList(options?: {
+        graph?: Exclude<Quad_Graph, Variable>;
+    }): Either<ValueError, readonly TermValue[]>;
     /**
      * Try to convert the term to a Literal.
      */
@@ -58,7 +60,9 @@ export declare class TermValue extends AbstractTermValue<BlankNode | Literal | N
     /**
      * Try to convert the term to a resource (identified by a blank node or IRI).
      */
-    toResource(): Either<MistypedTermValueError, Resource>;
+    toResource(options?: {
+        graph?: Exclude<Quad_Graph, Variable>;
+    }): Either<MistypedTermValueError, Resource>;
     /**
      * Try to convert the term to a string literal.
      */

package/dist/TermValue.js

@@ -70,8 +70,8 @@ export class TermValue extends AbstractTermValue {
     /**
      * Try to convert the term to an RDF list.
      */
-    toList() {
-        return this.toResource().chain((resource) => resource.toList());
+    toList(options) {
+        return this.toResource({ graph: options?.graph }).chain((resource) => resource.toList({ graph: options?.graph }));
     }
     /**
      * Try to convert the term to a Literal.
@@ -100,8 +100,11 @@ export class TermValue extends AbstractTermValue {
     /**
      * Try to convert the term to a resource (identified by a blank node or IRI).
      */
-    toResource() {
-        return this.toIdentifier().map((identifier) => new Resource(this.focusResource.dataset, identifier));
+    toResource(options) {
+        return this.toIdentifier().map((identifier) => new Resource(this.focusResource.dataset, identifier, {
+            dataFactory: this.dataFactory,
+            graph: options?.graph,
+        }));
     }
     /**
      * Try to convert the term to a string literal.

package/package.json

@@ -10,12 +10,12 @@
   "description": "Resource abstraction over RDF/JS Datasets",
   "devDependencies": {
     "@biomejs/biome": "2.3.10",
+    "@rdfjs/dataset": "~2.0.2",
     "@tpluscode/rdf-ns-builders": "~4.3.0",
     "@tsconfig/strictest": "~2.0.8",
-    "@types/n3": "~1.26.1",
+    "@types/rdfjs__dataset": "~2.0.7",
     "@vitest/coverage-v8": "~4.0.18",
     "housemd": "0.1.3",
-    "n3": "~1.26.0",
     "rimraf": "~6.0.1",
     "typescript": "5.9.3",
     "vitest": "~4.0.18"
@@ -46,5 +46,5 @@
   },
   "type": "module",
   "types": "dist/index.d.ts",
-  "version": "2.0.5"
+  "version": "2.0.6"
 }