rdfjs-resource 3.0.4 → 3.0.6

package/dist/PropertyPath.d.ts

@@ -32,6 +32,7 @@ interface ZeroOrOnePath {
  */
 export type PropertyPath = AlternativePath | InversePath | OneOrMorePath | PredicatePath | SequencePath | ZeroOrMorePath | ZeroOrOnePath;
 export declare namespace PropertyPath {
+    function equals(left: PropertyPath, right: PropertyPath): boolean;
     function $fromRdf(resource: Resource, options?: {
         [index: string]: unknown;
         graph?: Exclude<Quad_Graph, Variable>;

package/dist/PropertyPath.js

@@ -6,6 +6,34 @@ import { ResourceSet } from "./ResourceSet.js";
 import { sh } from "./vocabularies.js";
 export var PropertyPath;
 (function (PropertyPath) {
+    function equals(left, right) {
+        if (left.termType !== right.termType) {
+            return false;
+        }
+        switch (left.termType) {
+            case "AlternativePath":
+            case "SequencePath": {
+                const right_ = right;
+                if (left.members.length !== right_.members.length) {
+                    return false;
+                }
+                for (let memberI = 0; memberI < left.members.length; memberI++) {
+                    if (!PropertyPath.equals(left.members[memberI], right_.members[memberI])) {
+                        return false;
+                    }
+                }
+                return true;
+            }
+            case "NamedNode":
+                return left.equals(right);
+            case "InversePath":
+            case "OneOrMorePath":
+            case "ZeroOrMorePath":
+            case "ZeroOrOnePath":
+                return PropertyPath.equals(left.path, right.path);
+        }
+    }
+    PropertyPath.equals = equals;
     function $fromRdf(resource, options) {
         // Predicate path
         // sh:path ex:parent

package/dist/Resource.d.ts

@@ -1,4 +1,4 @@
-import type { DataFactory, DatasetCore, NamedNode, Quad_Graph, Variable } from "@rdfjs/types";
+import type { BlankNode, DataFactory, DatasetCore, Literal, NamedNode, Quad_Graph, Variable } from "@rdfjs/types";
 import { Either } from "purify-ts";
 import { Identifier as _Identifier, type Identifier } from "./Identifier.js";
 import { ListStructureError as _ListStructureError } from "./ListStructureError.js";
@@ -24,21 +24,22 @@ export declare class Resource<IdentifierT extends Resource.Identifier = Resource
     /**
      * Add zero or more values to this resource.
      */
-    add(predicate: NamedNode, object: AddableValue | readonly AddableValue[], graph?: Exclude<Quad_Graph, Variable>): this;
+    add(propertyPath: InversePath, value: AddableSubject | readonly AddableSubject[], graph?: Graph): this;
+    add(propertyPath: NamedNode, value: AddableObject | readonly AddableObject[], graph?: Graph): this;
     /**
      * Create a new list, add items to it, and attach it to this resource via predicate in a
      * (this, predicate, newList) statement.
      *
      * Returns the list resource.
      */
-    addList(predicate: NamedNode, items: Iterable<AddableValue>, options?: Parameters<Resource["addListItems"]>[1]): Resource;
+    addList(predicate: NamedNode, items: Iterable<AddableObject>, options?: Parameters<Resource["addListItems"]>[1]): Resource;
     /**
      * Add rdf:first and rdf:rest predicates to the current Resource.
      */
-    addListItems(items: Iterable<AddableValue>, options?: {
+    addListItems(items: Iterable<AddableObject>, options?: {
         addSubListResourceValues?: (subListResource: Resource) => void;
-        graph?: Exclude<Quad_Graph, Variable>;
-        mintSubListIdentifier?: (item: AddableValue, itemIndex: number) => Identifier;
+        graph?: Graph;
+        mintSubListIdentifier?: (item: AddableObject, itemIndex: number) => Identifier;
     }): this;
     /**
      * Delete zero or more values from this resource.
@@ -46,44 +47,53 @@ export declare class Resource<IdentifierT extends Resource.Identifier = Resource
      * If value is empty, delete all values of p
      * Else delete (p, arrayValue) for each value in the array.
      */
-    delete(predicate: NamedNode, object?: AddableValue | readonly AddableValue[], graph?: Exclude<Quad_Graph, Variable>): this;
+    delete(propertyPath: InversePath, value?: AddableSubject | readonly AddableSubject[], graph?: Graph): this;
+    delete(propertyPath: NamedNode, value?: AddableObject | readonly AddableObject[], graph?: Graph): this;
     isInstanceOf(class_: NamedNode, options?: {
         excludeSubclasses?: boolean;
-        graph?: Exclude<Quad_Graph, Variable>;
+        graph?: Graph;
         instanceOfPredicate?: NamedNode;
         subClassOfPredicate?: NamedNode;
     }): boolean;
     isSubClassOf(class_: NamedNode, options?: {
-        graph?: Exclude<Quad_Graph, Variable>;
+        graph?: Graph;
         subClassOfPredicate?: NamedNode;
     }): boolean;
     /**
      * Delete all existing values of p and then add the specified values.
      */
-    set(predicate: NamedNode, object: AddableValue | readonly AddableValue[], graph?: Exclude<Quad_Graph, Variable>): this;
+    set(propertyPath: InversePath, value: AddableSubject | readonly AddableSubject[], graph?: Graph): this;
+    set(propertyPath: NamedNode, value: AddableObject | readonly AddableObject[], graph?: Graph): this;
     /**
      * Consider the resource itself as an RDF list.
      */
     toList(options?: {
-        graph?: Exclude<Quad_Graph, Variable>;
+        graph?: Graph;
     }): Either<Resource.ValueError, Resource.Values>;
     /**
      * Get the first matching value for the property path.
      */
     value(propertyPath: PropertyPath, options?: {
-        graph?: Exclude<Quad_Graph, Variable>;
+        graph?: Graph;
     }): Either<Resource.ValueError, Resource.Value>;
     /**
      * Get all values for the property path.
      */
     values(propertyPath: PropertyPath, options?: {
-        graph?: Exclude<Quad_Graph, Variable>;
+        graph?: Graph;
         unique?: boolean;
     }): Resource.Values;
-    private addableValueToTerm;
-    private addableValuesToTerms;
+    private addableObjectToTerm;
+    private addableObjectsToTerms;
+    private addableSubjectsToTerms;
 }
-type AddableValue = Term | Exclude<Primitive, Date>;
+type AddableSubject = BlankNode | NamedNode;
+type AddableObject = BlankNode | Literal | NamedNode | Exclude<Primitive, Date>;
+type Graph = Exclude<Quad_Graph, Variable>;
+type InversePath = {
+    readonly path: NamedNode;
+    readonly termType: "InversePath";
+};
 export declare namespace Resource {
     const Identifier: typeof _Identifier;
     type Identifier = _Identifier;

package/dist/Resource.js

@@ -20,12 +20,21 @@ export class Resource {
         this.dataFactory = options?.dataFactory ?? DefaultDataFactory;
         this.literalFactory = new LiteralFactory({ dataFactory: this.dataFactory });
     }
-    /**
-     * Add zero or more values to this resource.
-     */
-    add(predicate, object, graph) {
-        for (const term of this.addableValuesToTerms(object)) {
-            this.dataset.add(this.dataFactory.quad(this.identifier, predicate, term, graph ?? this.graph));
+    add(propertyPath, value, graph) {
+        if (!graph) {
+            graph = this.graph;
+        }
+        switch (propertyPath.termType) {
+            case "InversePath":
+                for (const subject of this.addableSubjectsToTerms(value)) {
+                    this.dataset.add(this.dataFactory.quad(subject, propertyPath.path, this.identifier, graph));
+                }
+                break;
+            case "NamedNode":
+                for (const object of this.addableObjectsToTerms(value)) {
+                    this.dataset.add(this.dataFactory.quad(this.identifier, propertyPath, object, graph));
+                }
+                break;
         }
         return this;
     }
@@ -78,27 +87,48 @@ export class Resource {
         }
         return this;
     }
-    /**
-     * Delete zero or more values from this resource.
-     *
-     * If value is empty, delete all values of p
-     * Else delete (p, arrayValue) for each value in the array.
-     */
-    delete(predicate, object, graph) {
-        if (!object) {
-            for (const quad of [
-                ...this.dataset.match(this.identifier, predicate, null, graph ?? this.graph),
-            ]) {
-                this.dataset.delete(quad);
-            }
+    delete(propertyPath, value, graph) {
+        if (!graph) {
+            graph = this.graph;
         }
-        else {
-            for (const term of this.addableValuesToTerms(object)) {
-                for (const quad of [
-                    ...this.dataset.match(this.identifier, predicate, term, graph ?? this.graph),
-                ]) {
-                    this.dataset.delete(quad);
+        switch (propertyPath.termType) {
+            case "InversePath": {
+                if (value) {
+                    for (const subject of this.addableSubjectsToTerms(value)) {
+                        for (const quad of [
+                            ...this.dataset.match(subject, propertyPath.path, this.identifier, graph),
+                        ]) {
+                            this.dataset.delete(quad);
+                        }
+                    }
                 }
+                else {
+                    for (const quad of [
+                        ...this.dataset.match(null, propertyPath.path, this.identifier, graph),
+                    ]) {
+                        this.dataset.delete(quad);
+                    }
+                }
+                break;
+            }
+            case "NamedNode": {
+                if (value) {
+                    for (const object of this.addableObjectsToTerms(value)) {
+                        for (const quad of [
+                            ...this.dataset.match(this.identifier, propertyPath, object, graph),
+                        ]) {
+                            this.dataset.delete(quad);
+                        }
+                    }
+                }
+                else {
+                    for (const quad of [
+                        ...this.dataset.match(this.identifier, propertyPath, null, graph),
+                    ]) {
+                        this.dataset.delete(quad);
+                    }
+                }
+                break;
             }
         }
         return this;
@@ -174,12 +204,15 @@ export class Resource {
             return false;
         }
     }
-    /**
-     * Delete all existing values of p and then add the specified values.
-     */
-    set(predicate, object, graph) {
-        this.delete(predicate, undefined, graph);
-        return this.add(predicate, object, graph);
+    set(propertyPath, value, graph) {
+        switch (propertyPath.termType) {
+            case "InversePath":
+                this.delete(propertyPath, undefined, graph);
+                return this.add(propertyPath, value, graph);
+            case "NamedNode":
+                this.delete(propertyPath, undefined, graph);
+                return this.add(propertyPath, value, graph);
+        }
     }
     /**
      * Consider the resource itself as an RDF list.
@@ -283,25 +316,31 @@ export class Resource {
             unique: !!options?.unique,
         });
     }
-    addableValueToTerm(value) {
-        switch (typeof value) {
+    addableObjectToTerm(object) {
+        switch (typeof object) {
             case "bigint":
-                return this.literalFactory.bigint(value);
+                return this.literalFactory.bigint(object);
             case "boolean":
-                return this.literalFactory.boolean(value);
+                return this.literalFactory.boolean(object);
             case "number":
-                return this.literalFactory.number(value);
+                return this.literalFactory.number(object);
             case "string":
-                return this.literalFactory.string(value);
+                return this.literalFactory.string(object);
             case "object":
-                return value;
+                return object;
+        }
+    }
+    addableObjectsToTerms(objects) {
+        if (Array.isArray(objects)) {
+            return objects.map((value) => this.addableObjectToTerm(value));
         }
+        return [this.addableObjectToTerm(objects)];
     }
-    addableValuesToTerms(values) {
-        if (Array.isArray(values)) {
-            return values.map((value) => this.addableValueToTerm(value));
+    addableSubjectsToTerms(subjects) {
+        if (Array.isArray(subjects)) {
+            return subjects;
         }
-        return [this.addableValueToTerm(values)];
+        return [subjects];
     }
 }
 (function (Resource) {

package/package.json

@@ -47,5 +47,5 @@
   },
   "type": "module",
   "types": "dist/index.d.ts",
-  "version": "3.0.4"
+  "version": "3.0.6"
 }