rdfjs-resource 3.0.5 → 3.0.7

package/dist/MissingValueError.js

@@ -5,7 +5,7 @@ export class MissingValueError extends ValueError {
     constructor({ focusResource, propertyPath, }) {
         super({
             focusResource,
-            message: `${Identifier.toString(focusResource.identifier)} missing ${PropertyPath.$toString(propertyPath)}`,
+            message: `${Identifier.toString(focusResource.identifier)} missing ${PropertyPath.toString(propertyPath)}`,
             propertyPath,
         });
     }

package/dist/MistypedPrimitiveValueError.js

@@ -7,7 +7,7 @@ export class MistypedPrimitiveValueError extends MistypedValueError {
             actualValue,
             expectedValueType,
             focusResource,
-            message: `expected ${Identifier.toString(focusResource.identifier)} ${PropertyPath.$toString(propertyPath)} to be a ${expectedValueType}, was ${typeof actualValue}`,
+            message: `expected ${Identifier.toString(focusResource.identifier)} ${PropertyPath.toString(propertyPath)} to be a ${expectedValueType}, was ${typeof actualValue}`,
             propertyPath,
         });
     }

package/dist/MistypedTermValueError.js

@@ -7,7 +7,7 @@ export class MistypedTermValueError extends MistypedValueError {
             actualValue,
             expectedValueType,
             focusResource,
-            message: `expected ${Identifier.toString(focusResource.identifier)} ${PropertyPath.$toString(propertyPath)} to be a ${expectedValueType}, was ${actualValue.termType}`,
+            message: `expected ${Identifier.toString(focusResource.identifier)} ${PropertyPath.toString(propertyPath)} to be a ${expectedValueType}, was ${actualValue.termType}`,
             propertyPath,
         });
     }

package/dist/PropertyPath.d.ts

@@ -33,18 +33,14 @@ 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;
+    function fromResource(resource: Resource, options?: {
         graph?: Exclude<Quad_Graph, Variable>;
     }): Either<Error, PropertyPath>;
-    type $Filter = object;
-    function $filter(_filter: $Filter, _value: PropertyPath): boolean;
-    const $schema: Readonly<object>;
-    function $toString(propertyPath: PropertyPath): string;
-    function $toRdf(propertyPath: PropertyPath, options?: {
+    function toResource(propertyPath: PropertyPath, options?: {
         graph?: Exclude<Quad_Graph, Variable>;
         resourceSet?: ResourceSet;
     }): Resource;
+    function toString(propertyPath: PropertyPath): string;
 }
 export {};
 //# sourceMappingURL=PropertyPath.d.ts.map

package/dist/PropertyPath.js

@@ -34,7 +34,7 @@ export var PropertyPath;
         }
     }
     PropertyPath.equals = equals;
-    function $fromRdf(resource, options) {
+    function fromResource(resource, options) {
         // Predicate path
         // sh:path ex:parent
         if (resource.identifier.termType === "NamedNode") {
@@ -49,7 +49,7 @@ export var PropertyPath;
                     if (resource.isNothing()) {
                         return Left(new Error("non-identifier in property path list"));
                     }
-                    const member = PropertyPath.$fromRdf(resource.unsafeCoerce());
+                    const member = PropertyPath.fromResource(resource.unsafeCoerce(), options);
                     if (member.isLeft()) {
                         return member;
                     }
@@ -89,27 +89,27 @@ export var PropertyPath;
             // Inverse path
             // sh:path: [ sh:inversePath ex:parent ]
             if (quad.predicate.equals(sh.inversePath)) {
-                return PropertyPath.$fromRdf(objectResource).map((path) => ({
+                return PropertyPath.fromResource(objectResource, options).map((path) => ({
                     termType: "InversePath",
                     path,
                 }));
             }
             // One or more path
             if (quad.predicate.equals(sh.oneOrMorePath)) {
-                return PropertyPath.$fromRdf(objectResource).map((path) => ({
+                return PropertyPath.fromResource(objectResource, options).map((path) => ({
                     termType: "OneOrMorePath",
                     path,
                 }));
             }
             // Zero or more path
             if (quad.predicate.equals(sh.zeroOrMorePath)) {
-                return PropertyPath.$fromRdf(objectResource).map((path) => ({
+                return PropertyPath.fromResource(objectResource).map((path) => ({
                     termType: "ZeroOrMorePath",
                     path,
                 }));
             }
             if (quad.predicate.equals(sh.zeroOrOnePath)) {
-                return PropertyPath.$fromRdf(objectResource).map((path) => ({
+                return PropertyPath.fromResource(objectResource).map((path) => ({
                     termType: "ZeroOrOnePath",
                     path,
                 }));
@@ -117,28 +117,8 @@ export var PropertyPath;
         }
         return Left(new Error(`unrecognized or ill-formed SHACL property path ${Resource.Identifier.toString(resource.identifier)}`));
     }
-    PropertyPath.$fromRdf = $fromRdf;
-    function $filter(_filter, _value) {
-        return true;
-    }
-    PropertyPath.$filter = $filter;
-    PropertyPath.$schema = {};
-    function $toString(propertyPath) {
-        switch (propertyPath.termType) {
-            case "AlternativePath":
-            case "SequencePath":
-                return `${propertyPath.termType}([${propertyPath.members.map(PropertyPath.toString).join(", ")}])`;
-            case "InversePath":
-            case "OneOrMorePath":
-            case "ZeroOrMorePath":
-            case "ZeroOrOnePath":
-                return `${propertyPath.termType}(${PropertyPath.$toString(propertyPath.path)})`;
-            case "NamedNode":
-                return `PredicatePath(${propertyPath.value})`;
-        }
-    }
-    PropertyPath.$toString = $toString;
-    function $toRdf(propertyPath, options) {
+    PropertyPath.fromResource = fromResource;
+    function toResource(propertyPath, options) {
         const graph = options?.graph;
         const resourceSet = options?.resourceSet ??
             new ResourceSet(datasetFactory.dataset(), { dataFactory: dataFactory });
@@ -149,7 +129,7 @@ export var PropertyPath;
         switch (propertyPath.termType) {
             case "AlternativePath":
             case "SequencePath": {
-                const members = propertyPath.members.map((member) => PropertyPath.$toRdf(member, { graph, resourceSet }).identifier);
+                const members = propertyPath.members.map((member) => PropertyPath.toResource(member, { graph, resourceSet }).identifier);
                 if (propertyPath.termType === "AlternativePath") {
                     resource.addList(sh.alternativePath, members, { graph });
                 }
@@ -174,9 +154,26 @@ export var PropertyPath;
                 predicate = sh.zeroOrOnePath;
                 break;
         }
-        resource.add(predicate, PropertyPath.$toRdf(propertyPath.path, { graph, resourceSet }).identifier, graph);
+        resource.add(predicate, PropertyPath.toResource(propertyPath.path, { graph, resourceSet })
+            .identifier, graph);
         return resource;
     }
-    PropertyPath.$toRdf = $toRdf;
+    PropertyPath.toResource = toResource;
+    // biome-ignore lint/suspicious/noShadowRestrictedNames: intentional
+    function toString(propertyPath) {
+        switch (propertyPath.termType) {
+            case "AlternativePath":
+            case "SequencePath":
+                return `${propertyPath.termType}([${propertyPath.members.map(PropertyPath.toString).join(", ")}])`;
+            case "InversePath":
+            case "OneOrMorePath":
+            case "ZeroOrMorePath":
+            case "ZeroOrOnePath":
+                return `${propertyPath.termType}(${PropertyPath.toString(propertyPath.path)})`;
+            case "NamedNode":
+                return `PredicatePath(${propertyPath.value})`;
+        }
+    }
+    PropertyPath.toString = toString;
 })(PropertyPath || (PropertyPath = {}));
 //# sourceMappingURL=PropertyPath.js.map

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.5"
+  "version": "3.0.7"
 }