@rdfx/resource 0.0.11 → 0.0.13

package/dist/PropertyPath.js

@@ -77,7 +77,11 @@ export var PropertyPath;
                 default:
                     return Left(new Error(`non-BlankNode/NamedNode property path object on path ${resource.identifier}: ${quad.object.termType} ${quad.object.value}`));
             }
-            const objectResource = new Resource(resource.dataset, quad.object);
+            const objectResource = new Resource({
+                dataFactory: resource.dataFactory,
+                dataset: resource.dataset,
+                identifier: quad.object,
+            });
             // Alternative path
             // sh:path: [ sh:alternativePath ( ex:father ex:mother  ) ]
             if (quad.predicate.equals(sh.alternativePath)) {
@@ -121,7 +125,7 @@ export var PropertyPath;
     function toResource(propertyPath, options) {
         const graph = options?.graph;
         const resourceSet = options?.resourceSet ??
-            new ResourceSet(datasetFactory.dataset(), { dataFactory: dataFactory });
+            new ResourceSet({ dataFactory, dataset: datasetFactory.dataset() });
         if (propertyPath.termType === "NamedNode") {
             return resourceSet.resource(propertyPath);
         }

package/dist/Resource.d.ts

@@ -3,7 +3,6 @@ import { Either } from "purify-ts";
 import type { Identifier as _Identifier, Identifier } from "./Identifier.js";
 import { ListStructureError as _ListStructureError } from "./ListStructureError.js";
 import { MistypedTermValueError as _MistypedTermValueError } from "./MistypedTermValueError.js";
-import type { Primitive } from "./Primitive.js";
 import type { PropertyPath } from "./PropertyPath.js";
 import type { Term } from "./Term.js";
 import { Value as _Value } from "./Value.js";
@@ -13,13 +12,13 @@ import { Values as _Values } from "./Values.js";
  * A Resource abstraction over subjects or objects in an RDF/JS dataset.
  */
 export declare class Resource<IdentifierT extends Resource.Identifier = Resource.Identifier> {
+    readonly dataFactory: DataFactory;
     readonly dataset: DatasetCore;
     readonly identifier: IdentifierT;
-    private readonly dataFactory;
-    private readonly graph?;
-    private readonly literalFactory;
-    constructor(dataset: DatasetCore, identifier: IdentifierT, options?: {
-        dataFactory?: DataFactory;
+    constructor({ dataFactory, dataset, identifier, }: {
+        dataFactory: DataFactory;
+        dataset: DatasetCore;
+        identifier: IdentifierT;
     });
     /**
      * Add zero or more values to this resource.
@@ -83,12 +82,9 @@ export declare class Resource<IdentifierT extends Resource.Identifier = Resource
         graph?: Graph;
         unique?: boolean;
     }): Resource.Values;
-    private addableObjectToTerm;
-    private addableObjectsToTerms;
-    private addableSubjectsToTerms;
 }
+type AddableObject = BlankNode | Literal | NamedNode;
 type AddableSubject = BlankNode | NamedNode;
-type AddableObject = BlankNode | Literal | NamedNode | Exclude<Primitive, Date>;
 type Graph = Exclude<Quad_Graph, Variable>;
 type InversePath = {
     readonly path: NamedNode;

package/dist/Resource.js

@@ -1,6 +1,4 @@
 import TermSet from "@rdfjs/term-set";
-import defaultDataFactory from "@rdfx/data-factory";
-import { LiteralFactory } from "@rdfx/literal";
 import { Either, Left } from "purify-ts";
 import { DatasetValues } from "./DatasetValues.js";
 import { ListStructureError as _ListStructureError } from "./ListStructureError.js";
@@ -13,24 +11,20 @@ import { rdf, rdfs } from "./vocabularies.js";
  * A Resource abstraction over subjects or objects in an RDF/JS dataset.
  */
 export class Resource {
-    constructor(dataset, identifier, options) {
+    constructor({ dataFactory, dataset, identifier, }) {
+        this.dataFactory = dataFactory;
         this.dataset = dataset;
         this.identifier = identifier;
-        this.dataFactory = options?.dataFactory ?? defaultDataFactory;
-        this.literalFactory = new LiteralFactory({ dataFactory: this.dataFactory });
     }
     add(propertyPath, value, graph) {
-        if (!graph) {
-            graph = this.graph;
-        }
         switch (propertyPath.termType) {
             case "InversePath":
-                for (const subject of this.addableSubjectsToTerms(value)) {
+                for (const subject of Array.isArray(value) ? value : [value]) {
                     this.dataset.add(this.dataFactory.quad(subject, propertyPath.path, this.identifier, graph));
                 }
                 break;
             case "NamedNode":
-                for (const object of this.addableObjectsToTerms(value)) {
+                for (const object of Array.isArray(value) ? value : [value]) {
                     this.dataset.add(this.dataFactory.quad(this.identifier, propertyPath, object, graph));
                 }
                 break;
@@ -46,12 +40,18 @@ export class Resource {
     addList(predicate, items, options) {
         const itemsArray = [...items];
         if (itemsArray.length === 0) {
-            return new Resource(this.dataset, rdf.nil, {
+            return new Resource({
                 dataFactory: this.dataFactory,
+                dataset: this.dataset,
+                identifier: rdf.nil,
             });
         }
         const mintSubListIdentifier = options?.mintSubListIdentifier ?? (() => this.dataFactory.blankNode());
-        const listResource = new Resource(this.dataset, mintSubListIdentifier(itemsArray[0], 0), { dataFactory: this.dataFactory });
+        const listResource = new Resource({
+            dataFactory: this.dataFactory,
+            dataset: this.dataset,
+            identifier: mintSubListIdentifier(itemsArray[0], 0),
+        });
         listResource.addListItems(itemsArray, {
             graph: options?.graph,
             mintSubListIdentifier,
@@ -64,14 +64,18 @@ export class Resource {
      */
     addListItems(items, options) {
         const addSubListResourceValues = options?.addSubListResourceValues ?? (() => { });
-        const graph = options?.graph ?? this.graph;
+        const graph = options?.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({
+                    dataset: this.dataset,
+                    dataFactory: this.dataFactory,
+                    identifier: mintSubListIdentifier(item, itemIndex),
+                });
                 addSubListResourceValues(newHead);
                 currentHead.add(rdf.rest, newHead.identifier, graph);
                 currentHead = newHead;
@@ -87,13 +91,10 @@ export class Resource {
         return this;
     }
     delete(propertyPath, value, graph) {
-        if (!graph) {
-            graph = this.graph;
-        }
         switch (propertyPath.termType) {
             case "InversePath": {
                 if (value) {
-                    for (const subject of this.addableSubjectsToTerms(value)) {
+                    for (const subject of Array.isArray(value) ? value : [value]) {
                         for (const quad of [
                             ...this.dataset.match(subject, propertyPath.path, this.identifier, graph),
                         ]) {
@@ -112,7 +113,7 @@ export class Resource {
             }
             case "NamedNode": {
                 if (value) {
-                    for (const object of this.addableObjectsToTerms(value)) {
+                    for (const object of Array.isArray(value) ? value : [value]) {
                         for (const quad of [
                             ...this.dataset.match(this.identifier, propertyPath, object, graph),
                         ]) {
@@ -136,7 +137,7 @@ export class Resource {
         return isInstanceOfRecursive({
             class_,
             dataset: this.dataset,
-            graph: options?.graph ?? this.graph,
+            graph: options?.graph,
             instance: this.identifier,
             visitedClasses: new TermSet(),
         });
@@ -173,7 +174,7 @@ export class Resource {
         return isSubClassOfRecursive({
             class_,
             dataset: this.dataset,
-            graph: options?.graph ?? this.graph,
+            graph: options?.graph,
             thisIdentifier: this.identifier,
             visitedClasses: new TermSet(),
         });
@@ -224,7 +225,7 @@ export class Resource {
                 values: [],
             }));
         }
-        const graph = options?.graph ?? this.graph;
+        const graph = options?.graph;
         const firstObjects = [
             ...new TermSet([...this.dataset.match(this.identifier, rdf.first, null, graph)].map((quad) => quad.object)),
         ];
@@ -291,8 +292,10 @@ export class Resource {
             focusResource: this,
             propertyPath: rdf.first,
             term: firstObject,
-        }).toValues()).chain((items) => new Resource(this.dataset, restObject, {
+        }).toValues()).chain((items) => new Resource({
             dataFactory: this.dataFactory,
+            dataset: this.dataset,
+            identifier: restObject,
         })
             .toList({ graph })
             .map((restItems) => items.concat(...restItems)));
@@ -310,37 +313,11 @@ export class Resource {
         return new DatasetValues({
             dataFactory: this.dataFactory,
             focusResource: this,
-            graph: options?.graph ?? this.graph ?? null,
+            graph: options?.graph ?? null,
             propertyPath,
             unique: !!options?.unique,
         });
     }
-    addableObjectToTerm(object) {
-        switch (typeof object) {
-            case "bigint":
-                return this.literalFactory.bigint(object);
-            case "boolean":
-                return this.literalFactory.boolean(object);
-            case "number":
-                return this.literalFactory.number(object);
-            case "string":
-                return this.literalFactory.string(object);
-            case "object":
-                return object;
-        }
-    }
-    addableObjectsToTerms(objects) {
-        if (Array.isArray(objects)) {
-            return objects.map((value) => this.addableObjectToTerm(value));
-        }
-        return [this.addableObjectToTerm(objects)];
-    }
-    addableSubjectsToTerms(subjects) {
-        if (Array.isArray(subjects)) {
-            return subjects;
-        }
-        return [subjects];
-    }
 }
 (function (Resource) {
     Resource.ListStructureError = _ListStructureError;

package/dist/ResourceSet.d.ts

@@ -4,12 +4,11 @@ import { Resource } from "./Resource.js";
  * A ResourceSet wraps an RDF/JS dataset with convenient resource factory methods.
  */
 export declare class ResourceSet {
-    readonly dataset: DatasetCore;
     private readonly dataFactory;
-    private readonly graph?;
-    constructor(dataset: DatasetCore, options?: {
-        dataFactory?: DataFactory;
-        graph?: Exclude<Quad_Graph, Variable>;
+    readonly dataset: DatasetCore;
+    constructor({ dataFactory, dataset, }: {
+        dataFactory: DataFactory;
+        dataset: DatasetCore;
     });
     instancesOf(class_: NamedNode, options?: {
         excludeSubclasses?: boolean;

package/dist/ResourceSet.js

@@ -1,15 +1,13 @@
 import TermSet from "@rdfjs/term-set";
-import defaultDataFactory from "@rdfx/data-factory";
 import { Resource } from "./Resource.js";
 import { rdf, rdfs } from "./vocabularies.js";
 /**
  * A ResourceSet wraps an RDF/JS dataset with convenient resource factory methods.
  */
 export class ResourceSet {
-    constructor(dataset, options) {
+    constructor({ dataFactory, dataset, }) {
+        this.dataFactory = dataFactory;
         this.dataset = dataset;
-        this.dataFactory = options?.dataFactory ?? defaultDataFactory;
-        this.graph = options?.graph;
     }
     *instancesOf(class_, options) {
         for (const identifier of this.instanceIdentifiers(class_, options)) {
@@ -23,15 +21,17 @@ export class ResourceSet {
         }
     }
     resource(identifier) {
-        return new Resource(this.dataset, identifier, {
+        return new Resource({
             dataFactory: this.dataFactory,
+            dataset: this.dataset,
+            identifier,
         });
     }
     *instanceIdentifiers(class_, options) {
         yield* instanceIdentifiersRecursive({
             class_,
             dataset: this.dataset,
-            graph: options?.graph ?? this.graph,
+            graph: options?.graph,
             visitedClasses: new TermSet(),
             yieldedInstanceIdentifiers: new TermSet(),
         });

package/dist/Value.js

@@ -105,8 +105,10 @@ export class Value {
             .chain((value) => this.constrainPrimitive(value, in_));
     }
     toResource(in_) {
-        return (in_ ? this.toIdentifier(in_) : this.toIdentifier()).map((identifier) => new Resource(this.focusResource.dataset, identifier, {
+        return (in_ ? this.toIdentifier(in_) : this.toIdentifier()).map((identifier) => new Resource({
             dataFactory: this.dataFactory,
+            dataset: this.focusResource.dataset,
+            identifier,
         }));
     }
     toString(in_) {

package/package.json

@@ -1,14 +1,14 @@
 {
   "dependencies": {
-    "@rdfx/data-factory": "0.0.11",
-    "@rdfx/literal": "0.0.11",
-    "@rdfx/string": "0.0.11",
+    "@rdfx/literal": "0.0.13",
+    "@rdfx/string": "0.0.13",
     "@rdfjs/term-set": "~2.0.3",
     "@rdfjs/types": "~2.0.1",
     "@types/rdfjs__term-set": "~2.0.9",
     "purify-ts": "~2.1.4"
   },
   "devDependencies": {
+    "@rdfx/data-factory": "0.0.13",
     "@rdfjs/dataset": "~2.0.2",
     "@tpluscode/rdf-ns-builders": "~4.3.0",
     "@types/rdfjs__dataset": "~2.0.7",
@@ -40,5 +40,5 @@
   },
   "type": "module",
   "types": "./dist/index.d.ts",
-  "version": "0.0.11"
+  "version": "0.0.13"
 }