@shaclmate/shacl-ast 4.0.8 → 4.0.9

package/dist/Curie.d.ts

@@ -0,0 +1,21 @@
+import type { BlankNode, NamedNode } from "@rdfjs/types";
+/**
+ * A Compact URI (https://www.w3.org/TR/curie)
+ */
+export declare class Curie implements NamedNode {
+    #private;
+    readonly prefix: string;
+    readonly reference: string;
+    readonly termType = "NamedNode";
+    readonly value: string;
+    constructor({ hasUniqueReference, prefix, reference, value, }: {
+        hasUniqueReference?: () => boolean;
+        prefix: string;
+        reference: string;
+        value: string;
+    });
+    equals(other: BlankNode | NamedNode): boolean;
+    get hasUniqueReference(): boolean;
+    toString(): string;
+}
+//# sourceMappingURL=Curie.d.ts.map

package/dist/Curie.js

@@ -0,0 +1,29 @@
+/**
+ * A Compact URI (https://www.w3.org/TR/curie)
+ */
+export class Curie {
+    prefix;
+    #hasUniqueReference;
+    reference;
+    termType = "NamedNode";
+    value;
+    constructor({ hasUniqueReference, prefix, reference, value, }) {
+        this.#hasUniqueReference = hasUniqueReference ?? (() => false);
+        this.prefix = prefix;
+        this.reference = reference;
+        this.value = value;
+    }
+    equals(other) {
+        if (other.termType === "BlankNode") {
+            return false;
+        }
+        return this.value === other.value; // Allow a Curie to equal a NamedNode
+    }
+    get hasUniqueReference() {
+        return this.#hasUniqueReference();
+    }
+    toString() {
+        return `${this.prefix}:${this.reference}`;
+    }
+}
+//# sourceMappingURL=Curie.js.map

package/dist/CurieFactory.d.ts

@@ -0,0 +1,16 @@
+import type PrefixMap from "@rdfjs/prefix-map/PrefixMap.js";
+import type { NamedNode } from "@rdfjs/types";
+import { Maybe } from "purify-ts";
+import { Curie } from "./Curie.js";
+/**
+ * Factory for Compact URIs (CURIEs). Tracks whether the reference part of the CURIE is unique.
+ */
+export declare class CurieFactory {
+    private readonly prefixMap;
+    private readonly referenceCounts;
+    constructor({ prefixMap }: {
+        prefixMap: PrefixMap;
+    });
+    create(namedNode: NamedNode): Maybe<Curie>;
+}
+//# sourceMappingURL=CurieFactory.d.ts.map

package/dist/CurieFactory.js

@@ -0,0 +1,46 @@
+import { Maybe } from "purify-ts";
+import { invariant } from "ts-invariant";
+import { Curie } from "./Curie.js";
+/**
+ * Factory for Compact URIs (CURIEs). Tracks whether the reference part of the CURIE is unique.
+ */
+export class CurieFactory {
+    prefixMap;
+    referenceCounts = {};
+    constructor({ prefixMap }) {
+        this.prefixMap = prefixMap;
+    }
+    create(namedNode) {
+        return Maybe.fromNullable(this.prefixMap.shrink(namedNode)?.value).map((value) => {
+            const split = value.split(":", 2);
+            invariant(split.length === 2);
+            const prefix = split[0];
+            const reference = split[1];
+            if (this.referenceCounts[reference] === undefined) {
+                this.referenceCounts[reference] = {};
+            }
+            if (this.referenceCounts[reference][prefix] === undefined) {
+                this.referenceCounts[reference][prefix] = 1;
+            }
+            else {
+                this.referenceCounts[reference][prefix] += 1;
+            }
+            return new Curie({
+                hasUniqueReference: () => {
+                    const referenceCounts = this.referenceCounts[reference];
+                    if (Object.entries(referenceCounts).length === 1) {
+                        return true;
+                    }
+                    // logger.debug(
+                    //   `duplicate local part ${reference} in ${JSON.stringify(referenceCounts)}`,
+                    // );
+                    return false;
+                },
+                prefix: split[0],
+                reference: split[1],
+                value: namedNode.value,
+            });
+        });
+    }
+}
+//# sourceMappingURL=CurieFactory.js.map

package/dist/PropertyShape.js

@@ -37,7 +37,7 @@ export class PropertyShape extends Shape {
     toString() {
         return `PropertyShape(${[
             `identifier=${Resource.Identifier.toString(this.identifier)}`,
-            `path=${PropertyPath.$toString(this.path)}`,
+            `path=${PropertyPath.toString(this.path)}`,
         ].join(", ")})`;
     }
 }

package/dist/ShapesGraph.d.ts

@@ -1,7 +1,9 @@
+import PrefixMap from "@rdfjs/prefix-map/PrefixMap.js";
 import TermMap from "@rdfjs/term-map";
 import type { BlankNode, DatasetCore, NamedNode } from "@rdfjs/types";
 import { Either } from "purify-ts";
 import { Resource } from "rdfjs-resource";
+import { CurieFactory } from "./CurieFactory.js";
 import { NodeShape } from "./NodeShape.js";
 import { Ontology } from "./Ontology.js";
 import type { OntologyLike } from "./OntologyLike.js";
@@ -35,23 +37,28 @@ export declare namespace ShapesGraph {
         constructor(parameters?: {
             preferredLanguages?: readonly string[];
         });
-        createShapesGraph({ dataset, ignoreUndefinedShapes, }: {
+        createShapesGraph({ dataset, prefixMap, ignoreUndefinedShapes, }: {
             dataset: DatasetCore;
+            prefixMap?: PrefixMap;
             ignoreUndefinedShapes?: boolean;
         }): Either<Error, ShapesGraph<NodeShapeT, OntologyT, PropertyGroupT, PropertyShapeT, ShapeT>>;
         protected abstract createNodeShape(parameters: {
+            curieFactory: CurieFactory;
             resource: Resource;
             shapesGraph: ShapesGraph<NodeShapeT, OntologyT, PropertyGroupT, PropertyShapeT, ShapeT>;
         }): Either<Error, NodeShapeT>;
         protected abstract createOntology(parameters: {
+            curieFactory: CurieFactory;
             resource: Resource;
             shapesGraph: ShapesGraph<NodeShapeT, OntologyT, PropertyGroupT, PropertyShapeT, ShapeT>;
         }): Either<Error, OntologyT>;
         protected abstract createPropertyGroup(parameters: {
+            curieFactory: CurieFactory;
             resource: Resource;
             shapesGraph: ShapesGraph<NodeShapeT, OntologyT, PropertyGroupT, PropertyShapeT, ShapeT>;
         }): Either<Error, PropertyGroupT>;
         protected abstract createPropertyShape(parameters: {
+            curieFactory: CurieFactory;
             resource: Resource;
             shapesGraph: ShapesGraph<NodeShapeT, OntologyT, PropertyGroupT, PropertyShapeT, ShapeT>;
         }): Either<Error, PropertyShapeT>;
@@ -66,14 +73,17 @@ export declare namespace ShapesGraph {
             shapesGraph: DefaultShapesGraph;
         }): Either<Error, NodeShape<DefaultNodeShape, Ontology, PropertyGroup, DefaultPropertyShape, DefaultShape>>;
         protected createOntology({ resource, }: {
+            curieFactory: CurieFactory;
             resource: Resource;
             shapesGraph: DefaultShapesGraph;
         }): Either<Error, Ontology>;
         protected createPropertyGroup({ resource, }: {
+            curieFactory: CurieFactory;
             resource: Resource;
             shapesGraph: DefaultShapesGraph;
         }): Either<Error, PropertyGroup>;
-        protected createPropertyShape({ resource, shapesGraph, }: {
+        protected createPropertyShape({ curieFactory, resource, shapesGraph, }: {
+            curieFactory: CurieFactory;
             resource: Resource;
             shapesGraph: DefaultShapesGraph;
         }): Either<Error, DefaultPropertyShape>;

package/dist/ShapesGraph.js

@@ -4,12 +4,15 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
+import DataFactory from "@rdfjs/data-model";
+import PrefixMap from "@rdfjs/prefix-map/PrefixMap.js";
 import TermMap from "@rdfjs/term-map";
 import TermSet from "@rdfjs/term-set";
 import { owl, sh } from "@tpluscode/rdf-ns-builders";
 import { Either, Left } from "purify-ts";
 import { Resource, ResourceSet } from "rdfjs-resource";
 import { Memoize } from "typescript-memoize";
+import { CurieFactory } from "./CurieFactory.js";
 import * as generated from "./generated.js";
 import { NodeShape } from "./NodeShape.js";
 import { Ontology } from "./Ontology.js";
@@ -84,14 +87,26 @@ __decorate([
         constructor(parameters) {
             this.preferredLanguages = parameters?.preferredLanguages ?? ["en", ""];
         }
-        createShapesGraph({ dataset, ignoreUndefinedShapes, }) {
+        createShapesGraph({ dataset, prefixMap, ignoreUndefinedShapes, }) {
             function datasetHasMatch(subject, predicate, object, graph) {
                 for (const _ of dataset.match(subject, predicate, object, graph)) {
                     return true;
                 }
                 return false;
             }
+            const curieFactory = new CurieFactory({
+                prefixMap: prefixMap ?? new PrefixMap(undefined, { factory: DataFactory }),
+            });
             const resourceSet = new ResourceSet(dataset);
+            const curieResource = (identifier) => {
+                if (identifier.termType === "NamedNode") {
+                    const curie = curieFactory.create(identifier).extract();
+                    if (curie) {
+                        return resourceSet.resource(curie);
+                    }
+                }
+                return resourceSet.resource(identifier);
+            };
             const nodeShapesByIdentifier = new TermMap();
             const ontologiesByIdentifier = new TermMap();
             const propertyGroupsByIdentifier = new TermMap();
@@ -132,7 +147,8 @@ __decorate([
                         continue;
                     }
                     this.createOntology({
-                        resource: ontologyResource,
+                        curieFactory,
+                        resource: curieResource(ontologyResource.identifier),
                         shapesGraph,
                     }).ifRight((ontology) => ontologiesByIdentifier.set(ontologyResource.identifier, ontology));
                 }
@@ -145,7 +161,8 @@ __decorate([
                         continue;
                     }
                     this.createPropertyGroup({
-                        resource: propertyGroupResource,
+                        curieFactory,
+                        resource: curieResource(propertyGroupResource.identifier),
                         shapesGraph,
                     }).ifRight((propertyGroup) => propertyGroupsByIdentifier.set(propertyGroupResource.identifier, propertyGroup));
                 }
@@ -260,14 +277,16 @@ __decorate([
                     if (dataset.match(shapeNode, sh.path, null, graph).size > 0) {
                         // A property shape is a shape in the shapes graph that is the subject of a triple that has sh:path as its predicate. A shape has at most one value for sh:path. Each value of sh:path in a shape must be a well-formed SHACL property path. It is recommended, but not required, for a property shape to be declared as a SHACL instance of sh:PropertyShape. SHACL instances of sh:PropertyShape have one value for the property sh:path.
                         propertyShapesByIdentifier.set(shapeNode, this.createPropertyShape({
-                            resource: resourceSet.resource(shapeNode),
+                            curieFactory,
+                            resource: curieResource(shapeNode),
                             shapesGraph,
                         }).unsafeCoerce());
                     }
                     else {
                         // A node shape is a shape in the shapes graph that is not the subject of a triple with sh:path as its predicate. It is recommended, but not required, for a node shape to be declared as a SHACL instance of sh:NodeShape. SHACL instances of sh:NodeShape cannot have a value for the property sh:path.
                         nodeShapesByIdentifier.set(shapeNode, this.createNodeShape({
-                            resource: resourceSet.resource(shapeNode),
+                            curieFactory,
+                            resource: curieResource(shapeNode),
                             shapesGraph,
                         }).unsafeCoerce());
                     }
@@ -279,28 +298,33 @@ __decorate([
     ShapesGraph.Factory = Factory;
     class DefaultFactory extends Factory {
         createNodeShape({ resource, shapesGraph, }) {
-            return generated.NodeShape.$fromRdf(resource, {
+            return generated.NodeShape.$fromRdfResource(resource, {
                 ignoreRdfType: true,
                 preferredLanguages: this.preferredLanguages,
             }).map((generatedShape) => new NodeShape(generatedShape, shapesGraph));
         }
         createOntology({ resource, }) {
-            return generated.Ontology.$fromRdf(resource, {
+            return generated.Ontology.$fromRdfResource(resource, {
                 ignoreRdfType: true,
                 preferredLanguages: this.preferredLanguages,
             }).map((generatedOntology) => new Ontology(generatedOntology));
         }
         createPropertyGroup({ resource, }) {
-            return generated.PropertyGroup.$fromRdf(resource, {
+            return generated.PropertyGroup.$fromRdfResource(resource, {
                 ignoreRdfType: true,
                 preferredLanguages: this.preferredLanguages,
             }).map((propertyGroup) => new PropertyGroup(propertyGroup));
         }
-        createPropertyShape({ resource, shapesGraph, }) {
-            return generated.PropertyShape.$fromRdf(resource, {
+        createPropertyShape({ curieFactory, resource, shapesGraph, }) {
+            return generated.PropertyShape.$fromRdfResource(resource, {
                 ignoreRdfType: true,
                 preferredLanguages: this.preferredLanguages,
-            }).map((generatedShape) => new PropertyShape(generatedShape, shapesGraph));
+            }).map((generatedShape) => new PropertyShape({
+                ...generatedShape,
+                path: (generatedShape.path.termType === "NamedNode"
+                    ? curieFactory.create(generatedShape.path).extract()
+                    : undefined) ?? generatedShape.path,
+            }, shapesGraph));
         }
     }
     const defaultFactory = new DefaultFactory();