rdfjs-resource 3.0.6 → 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/package.json

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