@shaclmate/compiler 2.0.17 → 2.0.18

package/dist/input/PropertyPath.d.ts

@@ -0,0 +1,41 @@
+import type { NamedNode } from "@rdfjs/types";
+import type * as purify from "purify-ts";
+import type * as rdfjsResource from "rdfjs-resource";
+export interface AlternativePath {
+    readonly kind: "AlternativePath";
+    readonly members: readonly PropertyPath[];
+}
+export interface InversePath {
+    readonly kind: "InversePath";
+    readonly path: PropertyPath;
+}
+export interface OneOrMorePath {
+    readonly kind: "OneOrMorePath";
+    readonly path: PropertyPath;
+}
+export interface PredicatePath {
+    readonly iri: NamedNode;
+    readonly kind: "PredicatePath";
+}
+export interface SequencePath {
+    readonly kind: "SequencePath";
+    readonly members: readonly PropertyPath[];
+}
+export interface ZeroOrMorePath {
+    readonly kind: "ZeroOrMorePath";
+    readonly path: PropertyPath;
+}
+export interface ZeroOrOnePath {
+    readonly kind: "ZeroOrOnePath";
+    readonly path: PropertyPath;
+}
+export type PropertyPath = AlternativePath | InversePath | OneOrMorePath | PredicatePath | SequencePath | ZeroOrMorePath | ZeroOrOnePath;
+export declare namespace PropertyPath {
+    function fromRdf({ resource, }: {
+        [_index: string]: any;
+        ignoreRdfType?: boolean;
+        languageIn?: readonly string[];
+        resource: rdfjsResource.Resource;
+    }): purify.Either<rdfjsResource.Resource.ValueError, PropertyPath>;
+}
+//# sourceMappingURL=PropertyPath.d.ts.map

package/dist/input/PropertyPath.js

@@ -0,0 +1,105 @@
+import { rdf, sh } from "@tpluscode/rdf-ns-builders";
+import { Either, Left } from "purify-ts";
+import { Resource } from "rdfjs-resource";
+export var PropertyPath;
+(function (PropertyPath) {
+    function fromRdf({ resource, }) {
+        // Predicate path
+        // sh:path ex:parent
+        if (resource.identifier.termType === "NamedNode") {
+            return Either.of({ iri: resource.identifier, kind: "PredicatePath" });
+        }
+        // The other property path types are BlankNodes
+        const getPropertyPathList = (listResource) => {
+            return listResource.toList().chain((values) => {
+                const members = [];
+                for (const value of values) {
+                    const memberResource = value.toResource().toMaybe();
+                    if (memberResource.isNothing()) {
+                        return Left(new Resource.ValueError({
+                            focusResource: resource,
+                            message: "non-identifier in property path list",
+                            predicate: rdf.subject,
+                        }));
+                    }
+                    const member = PropertyPath.fromRdf({
+                        resource: memberResource.unsafeCoerce(),
+                    });
+                    if (member.isLeft()) {
+                        return member;
+                    }
+                    members.push(member.unsafeCoerce());
+                }
+                return Either.of(members);
+            });
+        };
+        for (const quad of resource.dataset.match(resource.identifier, null, null, null)) {
+            switch (quad.object.termType) {
+                case "BlankNode":
+                case "NamedNode":
+                    break;
+                default:
+                    return Left(new Resource.ValueError({
+                        focusResource: resource,
+                        message: `non-BlankNode/NamedNode property path object on path ${resource.identifier.value}: ${quad.object.termType} ${quad.object.value}`,
+                        predicate: quad.predicate,
+                    }));
+            }
+            const objectResource = new Resource({
+                dataset: resource.dataset,
+                identifier: quad.object,
+            });
+            // Alternative path
+            // sh:path: [ sh:alternativePath ( ex:father ex:mother  ) ]
+            if (quad.predicate.equals(sh.alternativePath)) {
+                return getPropertyPathList(objectResource).map((members) => ({
+                    kind: "AlternativePath",
+                    members,
+                }));
+            }
+            // Inverse path
+            // sh:path: [ sh:inversePath ex:parent ]
+            if (quad.predicate.equals(sh.inversePath)) {
+                return PropertyPath.fromRdf({ resource: objectResource }).map((path) => ({
+                    kind: "InversePath",
+                    path,
+                }));
+            }
+            // One or more path
+            if (quad.predicate.equals(sh.oneOrMorePath)) {
+                return PropertyPath.fromRdf({ resource: objectResource }).map((path) => ({
+                    kind: "OneOrMorePath",
+                    path,
+                }));
+            }
+            // Sequence path
+            // sh:path ( ex:parent ex:firstName )
+            if (quad.predicate.equals(rdf.first)) {
+                return getPropertyPathList(objectResource).map((members) => ({
+                    kind: "SequencePath",
+                    members,
+                }));
+            }
+            // Zero or more path
+            if (quad.predicate.equals(sh.zeroOrMorePath)) {
+                return PropertyPath.fromRdf({ resource: objectResource }).map((path) => ({
+                    kind: "ZeroOrMorePath",
+                    path,
+                }));
+            }
+            if (quad.predicate.equals(sh.zeroOrOnePath)) {
+                return PropertyPath.fromRdf({ resource: objectResource }).map((path) => ({
+                    kind: "ZeroOrOnePath",
+                    path,
+                }));
+            }
+        }
+        return Left(new Resource.ValueError({
+            focusResource: resource,
+            message: `unrecognized or ill-formed SHACL property path ${resource.identifier.value}`,
+            predicate: rdf.subject,
+        }));
+    }
+    PropertyPath.fromRdf = fromRdf;
+})(PropertyPath || (PropertyPath = {}));
+//# sourceMappingURL=PropertyPath.js.map

package/dist/input/generated.d.ts

@@ -1,7 +1,7 @@
 import type * as rdfjs from "@rdfjs/types";
-import { PropertyPath } from "@shaclmate/shacl-ast/PropertyPath.js";
 import * as purify from "purify-ts";
 import * as rdfjsResource from "rdfjs-resource";
+import { PropertyPath } from "./PropertyPath.js";
 type UnwrapR<T> = T extends purify.Either<any, infer R> ? R : never;
 export interface BaseShaclCoreShape {
     readonly and: readonly (readonly (rdfjs.BlankNode | rdfjs.NamedNode)[])[];

package/dist/input/generated.js

@@ -1,7 +1,7 @@
-import { PropertyPath } from "@shaclmate/shacl-ast/PropertyPath.js";
 import { DataFactory as dataFactory } from "n3";
 import * as purify from "purify-ts";
 import * as rdfjsResource from "rdfjs-resource";
+import { PropertyPath } from "./PropertyPath.js";
 export var BaseShaclCoreShape;
 (function (BaseShaclCoreShape) {
     function propertiesFromRdf({ ignoreRdfType: _ignoreRdfType, languageIn: _languageIn, resource: _resource, 

package/package.json

@@ -1,6 +1,6 @@
 {
   "dependencies": {
-    "@shaclmate/shacl-ast": "2.0.17",
+    "@shaclmate/shacl-ast": "2.0.18",
     "@rdfjs/prefix-map": "^0.1.2",
     "@rdfjs/term-map": "^2.0.2",
     "@rdfjs/term-set": "^2.0.3",
@@ -20,7 +20,7 @@
     "typescript-memoize": "^1.1.1"
   },
   "devDependencies": {
-    "@shaclmate/runtime": "2.0.17",
+    "@shaclmate/runtime": "2.0.18",
     "oxigraph": "^0.4.0"
   },
   "exports": {
@@ -77,5 +77,5 @@
     "url": "git+https://github.com/minorg/shaclmate"
   },
   "type": "module",
-  "version": "2.0.17"
+  "version": "2.0.18"
 }