@shaclmate/shacl-ast 2.0.13

package/NodeKind.d.ts

@@ -0,0 +1,9 @@
+/**
+ * TypeScript enum corresponding to sh:NodeKind, for simpler manipulation.
+ */
+export declare enum NodeKind {
+    BLANK_NODE = 1,
+    IRI = 2,
+    LITERAL = 3
+}
+//# sourceMappingURL=NodeKind.d.ts.map

package/NodeKind.js

@@ -0,0 +1,10 @@
+/**
+ * TypeScript enum corresponding to sh:NodeKind, for simpler manipulation.
+ */
+export var NodeKind;
+(function (NodeKind) {
+    NodeKind[NodeKind["BLANK_NODE"] = 1] = "BLANK_NODE";
+    NodeKind[NodeKind["IRI"] = 2] = "IRI";
+    NodeKind[NodeKind["LITERAL"] = 3] = "LITERAL";
+})(NodeKind || (NodeKind = {}));
+//# sourceMappingURL=NodeKind.js.map

package/NodeShape.d.ts

@@ -0,0 +1,17 @@
+import type { Maybe } from "purify-ts";
+import type { Resource } from "rdfjs-resource";
+import type { PropertyShape } from "./PropertyShape.js";
+import { Shape } from "./Shape.js";
+import type { ShapesGraph } from "./ShapesGraph.js";
+export declare class NodeShape extends Shape {
+    readonly constraints: NodeShape.Constraints;
+    constructor(resource: Resource, shapesGraph: ShapesGraph);
+    toString(): string;
+}
+export declare namespace NodeShape {
+    class Constraints extends Shape.Constraints {
+        get closed(): Maybe<boolean>;
+        get properties(): readonly PropertyShape[];
+    }
+}
+//# sourceMappingURL=NodeShape.d.ts.map

package/NodeShape.js

@@ -0,0 +1,30 @@
+import { sh } from "@tpluscode/rdf-ns-builders";
+import { Shape } from "./Shape.js";
+export class NodeShape extends Shape {
+    constructor(resource, shapesGraph) {
+        super(resource);
+        this.constraints = new NodeShape.Constraints(resource, shapesGraph);
+    }
+    toString() {
+        return `NodeShape(node=${this.resource.identifier.value})`;
+    }
+}
+(function (NodeShape) {
+    class Constraints extends Shape.Constraints {
+        get closed() {
+            return this.resource
+                .value(sh.closed)
+                .chain((value) => value.toBoolean())
+                .toMaybe();
+        }
+        get properties() {
+            return [...this.resource.values(sh.property)].flatMap((value) => value
+                .toIdentifier()
+                .toMaybe()
+                .chain((shapeNode) => this.shapesGraph.propertyShapeByNode(shapeNode))
+                .toList());
+        }
+    }
+    NodeShape.Constraints = Constraints;
+})(NodeShape || (NodeShape = {}));
+//# sourceMappingURL=NodeShape.js.map

package/PropertyGroup.d.ts

@@ -0,0 +1,9 @@
+import type { Literal } from "@rdfjs/types";
+import type { Maybe } from "purify-ts";
+import type { Resource } from "rdfjs-resource";
+export declare class PropertyGroup {
+    private readonly resource;
+    constructor(resource: Resource);
+    get label(): Maybe<Literal>;
+}
+//# sourceMappingURL=PropertyGroup.d.ts.map

package/PropertyGroup.js

@@ -0,0 +1,13 @@
+import { rdfs } from "@tpluscode/rdf-ns-builders";
+export class PropertyGroup {
+    constructor(resource) {
+        this.resource = resource;
+    }
+    get label() {
+        return this.resource
+            .value(rdfs.label)
+            .chain((value) => value.toLiteral())
+            .toMaybe();
+    }
+}
+//# sourceMappingURL=PropertyGroup.js.map

package/PropertyPath.d.ts

@@ -0,0 +1,36 @@
+import type { NamedNode } from "@rdfjs/types";
+import { Either } from "purify-ts";
+import { Resource } 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 fromResource(resource: Resource): Either<Error, PropertyPath>;
+}
+//# sourceMappingURL=PropertyPath.d.ts.map

package/PropertyPath.js

@@ -0,0 +1,91 @@
+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 fromResource(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 Error("non-identifier in property path list"));
+                    }
+                    const member = PropertyPath.fromResource(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 Error(`non-BlankNode/NamedNode property path object on path ${resource.identifier.value}: ${quad.object.termType} ${quad.object.value}`));
+            }
+            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.fromResource(objectResource).map((path) => ({
+                    kind: "InversePath",
+                    path,
+                }));
+            }
+            // One or more path
+            if (quad.predicate.equals(sh.oneOrMorePath)) {
+                return PropertyPath.fromResource(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.fromResource(objectResource).map((path) => ({
+                    kind: "ZeroOrMorePath",
+                    path,
+                }));
+            }
+            if (quad.predicate.equals(sh.zeroOrOnePath)) {
+                return PropertyPath.fromResource(objectResource).map((path) => ({
+                    kind: "ZeroOrOnePath",
+                    path,
+                }));
+            }
+        }
+        return Left(new Error(`unrecognized or ill-formed SHACL property path ${resource.identifier.value}`));
+    }
+    PropertyPath.fromResource = fromResource;
+})(PropertyPath || (PropertyPath = {}));
+//# sourceMappingURL=PropertyPath.js.map

package/PropertyShape.d.ts

@@ -0,0 +1,21 @@
+import type { BlankNode, Literal, NamedNode } from "@rdfjs/types";
+import type { Maybe } from "purify-ts";
+import type { Resource } from "rdfjs-resource";
+import type { PropertyGroup } from "./PropertyGroup.js";
+import { PropertyPath } from "./PropertyPath.js";
+import { Shape } from "./Shape.js";
+import type { ShapesGraph } from "./ShapesGraph.js";
+export declare class PropertyShape extends Shape {
+    private readonly shapesGraph;
+    readonly constraints: Shape.Constraints;
+    constructor(resource: Resource, shapesGraph: ShapesGraph);
+    get defaultValue(): Maybe<BlankNode | Literal | NamedNode>;
+    get editor(): Maybe<NamedNode>;
+    get group(): Maybe<PropertyGroup>;
+    get order(): Maybe<number>;
+    get path(): PropertyPath;
+    get singleLine(): Maybe<boolean>;
+    get viewer(): Maybe<NamedNode>;
+    toString(): string;
+}
+//# sourceMappingURL=PropertyShape.d.ts.map

package/PropertyShape.js

@@ -0,0 +1,63 @@
+import { dash, sh } from "@tpluscode/rdf-ns-builders";
+import { PropertyPath } from "./PropertyPath.js";
+import { Shape } from "./Shape.js";
+export class PropertyShape extends Shape {
+    constructor(resource, shapesGraph) {
+        super(resource);
+        this.shapesGraph = shapesGraph;
+        this.constraints = new PropertyShape.Constraints(resource, shapesGraph);
+    }
+    get defaultValue() {
+        return this.resource
+            .value(sh.defaultValue)
+            .map((value) => value.toTerm())
+            .toMaybe();
+    }
+    get editor() {
+        return this.resource
+            .value(dash.editor)
+            .chain((value) => value.toIri())
+            .toMaybe();
+    }
+    get group() {
+        return this.resource
+            .value(sh.group)
+            .chain((value) => value.toIri())
+            .toMaybe()
+            .chain((node) => this.shapesGraph.propertyGroupByNode(node));
+    }
+    get order() {
+        return this.resource
+            .value(sh.maxCount)
+            .chain((value) => value.toNumber())
+            .toMaybe();
+    }
+    get path() {
+        return this.resource
+            .value(sh.path)
+            .chain((value) => value.toResource())
+            .chain(PropertyPath.fromResource)
+            .unsafeCoerce();
+    }
+    get singleLine() {
+        return this.resource
+            .value(dash.singleLine)
+            .chain((value) => value.toBoolean())
+            .toMaybe();
+    }
+    get viewer() {
+        return this.resource
+            .value(dash.viewer)
+            .chain((value) => value.toIri())
+            .toMaybe();
+    }
+    toString() {
+        const keyValues = [`node=${this.resource.identifier.value}`];
+        const path = this.path;
+        if (path.kind === "PredicatePath") {
+            keyValues.push(`path=${path.iri.value}`);
+        }
+        return `PropertyShape(${keyValues.join(", ")})`;
+    }
+}
+//# sourceMappingURL=PropertyShape.js.map

package/README.md

@@ -0,0 +1,25 @@
+# shacl-ast
+
+Build an Abstract Syntax Tree (AST) of [Shapes Constraint Language (SHACL)](https://www.w3.org/TR/shacl/) shapes in an [RDF/JS Dataset](https://rdf.js.org/dataset-spec/).
+
+## Installation
+
+    npm i @shaclmate/shacl-ast
+
+## Usage
+
+```ts
+import { ShapesGraph } from "@shaclmate/shacl-ast";
+
+const shapesGraph = ShapesGraph.fromDataset(testShapesGraph);
+for (const nodeShape of shapesGraph.nodeShapes) {
+  console.info("Node shape: ", nodeShape.node.value);
+  for (const propertyShape of shapesGraph.propertyShapes) {
+    console.info(
+      "  Property shape: ",
+      propertyShape.node.value,
+      propertyShape.path.value,
+    );
+  }
+}
+```

package/Shape.d.ts

@@ -0,0 +1,47 @@
+import type { BlankNode, Literal, NamedNode } from "@rdfjs/types";
+import type { Maybe } from "purify-ts";
+import type { Resource } from "rdfjs-resource";
+import { NodeKind } from "./NodeKind.js";
+import type { NodeShape } from "./NodeShape.js";
+import type { ShapesGraph } from "./ShapesGraph.js";
+export declare abstract class Shape {
+    readonly resource: Resource;
+    abstract readonly constraints: Shape.Constraints;
+    readonly targets: Shape.Targets;
+    protected constructor(resource: Resource);
+    get description(): Maybe<Literal>;
+    get name(): Maybe<Literal>;
+}
+export declare namespace Shape {
+    class Constraints {
+        protected readonly resource: Resource;
+        protected readonly shapesGraph: ShapesGraph;
+        constructor(resource: Resource, shapesGraph: ShapesGraph);
+        get and(): readonly Shape[];
+        get classes(): readonly NamedNode[];
+        get datatype(): Maybe<NamedNode>;
+        get hasValue(): Maybe<BlankNode | Literal | NamedNode>;
+        get in_(): Maybe<readonly (BlankNode | Literal | NamedNode)[]>;
+        get maxCount(): Maybe<number>;
+        get maxExclusive(): Maybe<Literal>;
+        get maxInclusive(): Maybe<Literal>;
+        get minCount(): Maybe<number>;
+        get minExclusive(): Maybe<Literal>;
+        get minInclusive(): Maybe<Literal>;
+        get nodeKinds(): Set<NodeKind>;
+        get nodes(): readonly NodeShape[];
+        get not(): readonly Shape[];
+        get or(): readonly Shape[];
+        get xone(): readonly Shape[];
+        private listTakingLogicalConstraint;
+    }
+    class Targets {
+        protected readonly resource: Resource;
+        constructor(resource: Resource);
+        get targetClasses(): readonly NamedNode[];
+        get targetNodes(): readonly (Literal | NamedNode)[];
+        get targetObjectsOf(): readonly NamedNode[];
+        get targetSubjectsOf(): readonly NamedNode[];
+    }
+}
+//# sourceMappingURL=Shape.d.ts.map

package/Shape.js

@@ -0,0 +1,171 @@
+import { sh } from "@tpluscode/rdf-ns-builders";
+import { NodeKind } from "./NodeKind.js";
+export class Shape {
+    constructor(resource) {
+        this.resource = resource;
+        this.targets = new Shape.Targets(resource);
+    }
+    get description() {
+        return this.resource
+            .value(sh.description)
+            .chain((value) => value.toLiteral())
+            .toMaybe();
+    }
+    get name() {
+        return this.resource
+            .value(sh.name)
+            .chain((value) => value.toLiteral())
+            .toMaybe();
+    }
+}
+(function (Shape) {
+    class Constraints {
+        constructor(resource, shapesGraph) {
+            this.resource = resource;
+            this.shapesGraph = shapesGraph;
+        }
+        get and() {
+            return this.listTakingLogicalConstraint(sh.and);
+        }
+        get classes() {
+            return [...this.resource.values(sh.class)].flatMap((value) => value.toIri().toMaybe().toList());
+        }
+        get datatype() {
+            return this.resource
+                .value(sh.datatype)
+                .chain((value) => value.toIri())
+                .toMaybe();
+        }
+        get hasValue() {
+            return this.resource
+                .value(sh.hasValue)
+                .map((value) => value.toTerm())
+                .toMaybe();
+        }
+        get in_() {
+            return this.resource
+                .value(sh.in)
+                .chain((value) => value.toList())
+                .map((values) => values.map((value) => value.toTerm()))
+                .toMaybe();
+        }
+        get maxCount() {
+            return this.resource
+                .value(sh.maxCount)
+                .chain((value) => value.toNumber())
+                .toMaybe();
+        }
+        get maxExclusive() {
+            return this.resource
+                .value(sh.maxExclusive)
+                .chain((value) => value.toLiteral())
+                .toMaybe();
+        }
+        get maxInclusive() {
+            return this.resource
+                .value(sh.maxInclusive)
+                .chain((value) => value.toLiteral())
+                .toMaybe();
+        }
+        get minCount() {
+            return this.resource
+                .value(sh.minCount)
+                .chain((value) => value.toNumber())
+                .toMaybe();
+        }
+        get minExclusive() {
+            return this.resource
+                .value(sh.minExclusive)
+                .chain((value) => value.toLiteral())
+                .toMaybe();
+        }
+        get minInclusive() {
+            return this.resource
+                .value(sh.minInclusive)
+                .chain((value) => value.toLiteral())
+                .toMaybe();
+        }
+        get nodeKinds() {
+            const nodeKinds = new Set();
+            for (const nodeKindValue of this.resource.values(sh.nodeKind)) {
+                nodeKindValue.toIri().ifRight((nodeKindIri) => {
+                    if (nodeKindIri.equals(sh.BlankNode)) {
+                        nodeKinds.add(NodeKind.BLANK_NODE);
+                    }
+                    else if (nodeKindIri.equals(sh.BlankNodeOrIRI)) {
+                        nodeKinds.add(NodeKind.BLANK_NODE);
+                        nodeKinds.add(NodeKind.IRI);
+                    }
+                    else if (nodeKindIri.equals(sh.BlankNodeOrLiteral)) {
+                        nodeKinds.add(NodeKind.BLANK_NODE);
+                        nodeKinds.add(NodeKind.LITERAL);
+                    }
+                    else if (nodeKindIri.equals(sh.IRI)) {
+                        nodeKinds.add(NodeKind.IRI);
+                    }
+                    else if (nodeKindIri.equals(sh.IRIOrLiteral)) {
+                        nodeKinds.add(NodeKind.IRI);
+                        nodeKinds.add(NodeKind.LITERAL);
+                    }
+                    else if (nodeKindIri.equals(sh.Literal)) {
+                        nodeKinds.add(NodeKind.LITERAL);
+                    }
+                });
+            }
+            return nodeKinds;
+        }
+        get nodes() {
+            return [...this.resource.values(sh.node)].flatMap((value) => value
+                .toIdentifier()
+                .toMaybe()
+                .chain((shapeNode) => this.shapesGraph.nodeShapeByNode(shapeNode))
+                .toList());
+        }
+        get not() {
+            return [...this.resource.values(sh.not)].flatMap((value) => value
+                .toIdentifier()
+                .toMaybe()
+                .chain((shapeNode) => this.shapesGraph.shapeByNode(shapeNode))
+                .toList());
+        }
+        get or() {
+            return this.listTakingLogicalConstraint(sh.or);
+        }
+        get xone() {
+            return this.listTakingLogicalConstraint(sh.xone);
+        }
+        listTakingLogicalConstraint(predicate) {
+            return this.resource
+                .value(predicate)
+                .chain((value) => value.toList())
+                .map((values) => values.flatMap((value) => value
+                .toIdentifier()
+                .toMaybe()
+                .chain((shapeNode) => this.shapesGraph.shapeByNode(shapeNode))
+                .toList()))
+                .orDefault([]);
+        }
+    }
+    Shape.Constraints = Constraints;
+    class Targets {
+        constructor(resource) {
+            this.resource = resource;
+        }
+        get targetClasses() {
+            return [...this.resource.values(sh.targetClass)].flatMap((value) => value.toIri().toMaybe().toList());
+        }
+        get targetNodes() {
+            return [...this.resource.values(sh.targetNode)].flatMap((value) => value.toLiteral().toMaybe()
+                .altLazy(() => value.toIri().toMaybe())
+                .toList());
+        }
+        get targetObjectsOf() {
+            return [...this.resource.values(sh.targetObjectsOf)].flatMap((value) => value.toIri().toMaybe().toList());
+        }
+        get targetSubjectsOf() {
+            return [...this.resource.values(sh.targetSubjectsOf)].flatMap((value) => value.toIri().toMaybe().toList());
+        }
+    }
+    Shape.Targets = Targets;
+})(Shape || (Shape = {}));
+//# sourceMappingURL=Shape.js.map

package/ShapeParameters.d.ts

@@ -0,0 +1,7 @@
+import type { BlankNode, NamedNode } from "@rdfjs/types";
+import type { ShapesGraph } from "./ShapesGraph.js";
+export interface ShapeParameters {
+    node: BlankNode | NamedNode;
+    shapesGraph: ShapesGraph;
+}
+//# sourceMappingURL=ShapeParameters.d.ts.map

package/ShapeParameters.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ShapeParameters.js.map

package/ShapesGraph.d.ts

@@ -0,0 +1,26 @@
+import type { BlankNode, DatasetCore, DefaultGraph, NamedNode } from "@rdfjs/types";
+import { Maybe } from "purify-ts";
+import { NodeShape } from "./NodeShape.js";
+import { PropertyGroup } from "./PropertyGroup.js";
+import { PropertyShape } from "./PropertyShape.js";
+import type { Shape } from "./Shape.js";
+export declare class ShapesGraph {
+    readonly dataset: DatasetCore;
+    readonly node: BlankNode | DefaultGraph | NamedNode | null;
+    readonly nodeShapes: readonly NodeShape[];
+    readonly propertyGroups: readonly PropertyGroup[];
+    readonly propertyShapes: readonly PropertyShape[];
+    private readonly nodeShapesByNode;
+    private readonly propertyGroupsByNode;
+    private readonly propertyShapesByNode;
+    private constructor();
+    static fromDataset(dataset: DatasetCore): ShapesGraph;
+    nodeShapeByNode(nodeShapeNode: BlankNode | NamedNode): Maybe<NodeShape>;
+    propertyGroupByNode(propertyGroupNode: NamedNode): Maybe<PropertyGroup>;
+    propertyShapeByNode(propertyShapeNode: BlankNode | NamedNode): Maybe<PropertyShape>;
+    shapeByNode(node: BlankNode | NamedNode): Maybe<Shape>;
+    private readGraph;
+    private readPropertyGroups;
+    private readShapes;
+}
+//# sourceMappingURL=ShapesGraph.d.ts.map

package/ShapesGraph.js

@@ -0,0 +1,201 @@
+import TermMap from "@rdfjs/term-map";
+import TermSet from "@rdfjs/term-set";
+import { rdf, sh } from "@tpluscode/rdf-ns-builders";
+import { Maybe } from "purify-ts";
+import { Resource, ResourceSet } from "rdfjs-resource";
+import { NodeShape } from "./NodeShape.js";
+import { PropertyGroup } from "./PropertyGroup.js";
+import { PropertyShape } from "./PropertyShape.js";
+export class ShapesGraph {
+    constructor(dataset) {
+        this.dataset = dataset;
+        this.node = this.readGraph();
+        const { nodeShapes, nodeShapesByNode, propertyShapes, propertyShapesByNode, } = this.readShapes();
+        this.nodeShapes = nodeShapes;
+        this.nodeShapesByNode = nodeShapesByNode;
+        this.propertyShapes = propertyShapes;
+        this.propertyShapesByNode = propertyShapesByNode;
+        const { propertyGroups, propertyGroupsByNode } = this.readPropertyGroups();
+        this.propertyGroups = propertyGroups;
+        this.propertyGroupsByNode = propertyGroupsByNode;
+    }
+    static fromDataset(dataset) {
+        return new ShapesGraph(dataset);
+    }
+    nodeShapeByNode(nodeShapeNode) {
+        return Maybe.fromNullable(this.nodeShapesByNode.get(nodeShapeNode));
+    }
+    propertyGroupByNode(propertyGroupNode) {
+        return Maybe.fromNullable(this.propertyGroupsByNode.get(propertyGroupNode));
+    }
+    propertyShapeByNode(propertyShapeNode) {
+        return Maybe.fromNullable(this.propertyShapesByNode.get(propertyShapeNode));
+    }
+    shapeByNode(node) {
+        const nodeShape = this.nodeShapeByNode(node);
+        if (nodeShape.isJust()) {
+            return nodeShape;
+        }
+        return this.propertyShapeByNode(node);
+    }
+    readGraph() {
+        const graphs = new TermSet();
+        for (const quad of this.dataset) {
+            graphs.add(quad.graph);
+        }
+        if (graphs.size !== 1) {
+            return null;
+        }
+        const graph = [...graphs.values()][0];
+        switch (graph.termType) {
+            case "BlankNode":
+            case "DefaultGraph":
+            case "NamedNode":
+                return graph;
+            default:
+                throw new RangeError(`expected NamedNode or default graph, actual ${graph.termType}`);
+        }
+    }
+    readPropertyGroups() {
+        const propertyGroups = [];
+        const propertyGroupsByNode = new TermMap();
+        for (const quad of this.dataset.match(null, rdf.type, sh.PropertyGroup, this.node)) {
+            const subject = quad.subject;
+            if (subject.termType !== "NamedNode") {
+                continue;
+            }
+            if (propertyGroupsByNode.has(subject)) {
+                continue;
+            }
+            const propertyGroup = new PropertyGroup(new Resource({ dataset: this.dataset, identifier: subject }));
+            propertyGroups.push(propertyGroup);
+            propertyGroupsByNode.set(subject, propertyGroup);
+        }
+        return { propertyGroups, propertyGroupsByNode };
+    }
+    readShapes() {
+        const resourceSet = new ResourceSet({ dataset: this.dataset });
+        // Collect the shape identifiers in sets
+        const shapeNodeSet = new TermSet();
+        // Utility function for doing the collection
+        const addShapeNode = (shapeNode) => {
+            switch (shapeNode.termType) {
+                case "BlankNode":
+                case "NamedNode":
+                    shapeNodeSet.add(shapeNode);
+                    break;
+            }
+        };
+        // Test each shape condition
+        // https://www.w3.org/TR/shacl/#shapes
+        // Subject is a SHACL instance of sh:NodeShape or sh:PropertyShape
+        for (const rdfType of [sh.NodeShape, sh.PropertyShape]) {
+            for (const resource of resourceSet.instancesOf(rdfType, {
+                graph: this.node,
+            })) {
+                addShapeNode(resource.identifier);
+            }
+        }
+        // Subject of a triple with sh:targetClass, sh:targetNode, sh:targetObjectsOf, or sh:targetSubjectsOf predicate
+        for (const predicate of [
+            sh.targetClass,
+            sh.targetNode,
+            sh.targetObjectsOf,
+            sh.targetSubjectsOf,
+        ]) {
+            for (const quad of this.dataset.match(null, predicate, null, this.node)) {
+                addShapeNode(quad.subject);
+            }
+        }
+        // Subject of a triple that has a parameter as predicate
+        // https://www.w3.org/TR/shacl/#constraints
+        // https://www.w3.org/TR/shacl/#core-components
+        for (const predicate of [
+            sh.class,
+            sh.datatype,
+            sh.nodeKind,
+            sh.minCount,
+            sh.maxCount,
+            sh.minExclusive,
+            sh.minInclusive,
+            sh.maxExclusive,
+            sh.maxInclusive,
+            sh.minLength,
+            sh.maxLength,
+            sh.pattern,
+            sh.languageIn,
+            sh.uniqueLang,
+            sh.equals,
+            sh.disjoint,
+            sh.lessThan,
+            sh.lessThanOrEquals,
+            sh.not,
+            sh.and,
+            sh.or,
+            sh.xone,
+            sh.node,
+            sh.property,
+            sh.qualifiedValueShape,
+            sh.qualifiedMinCount,
+            sh.qualifiedMaxCount,
+            sh.closed,
+            sh.ignoredProperties,
+            sh.hasValue,
+            sh.in,
+        ]) {
+            for (const quad of this.dataset.match(null, predicate, null, this.node)) {
+                addShapeNode(quad.subject);
+            }
+        }
+        // Object of a shape-expecting, non-list-taking parameter such as sh:node
+        for (const predicate of [sh.node, sh.property]) {
+            for (const quad of this.dataset.match(null, predicate, null, this.node)) {
+                addShapeNode(quad.object);
+            }
+        }
+        // Member of a SHACL list that is a value of a shape-expecting and list-taking parameter such as sh:or
+        for (const predicate of [sh.and, sh["in"], sh.languageIn, sh.or, sh.xone]) {
+            for (const quad of this.dataset.match(null, predicate, null, this.node)) {
+                switch (quad.object.termType) {
+                    case "BlankNode":
+                    case "NamedNode":
+                        break;
+                    default:
+                        continue;
+                }
+                for (const value of resourceSet
+                    .resource(quad.object)
+                    .toList()
+                    .orDefault([])) {
+                    value.toIdentifier().ifRight(addShapeNode);
+                }
+            }
+        }
+        // Separate shapes into node and property shapes.
+        const nodeShapes = [];
+        const nodeShapesByNode = new TermMap();
+        const propertyShapes = [];
+        const propertyShapesByNode = new TermMap();
+        for (const shapeNode of shapeNodeSet) {
+            if (this.dataset.match(shapeNode, sh.path, null, this.node).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.
+                const propertyShape = new PropertyShape(resourceSet.resource(shapeNode), this);
+                propertyShapes.push(propertyShape);
+                propertyShapesByNode.set(shapeNode, propertyShape);
+            }
+            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.
+                const nodeShape = new NodeShape(resourceSet.resource(shapeNode), this);
+                nodeShapes.push(nodeShape);
+                nodeShapesByNode.set(shapeNode, nodeShape);
+            }
+        }
+        return {
+            nodeShapes,
+            nodeShapesByNode,
+            propertyShapes,
+            propertyShapesByNode,
+        };
+    }
+}
+//# sourceMappingURL=ShapesGraph.js.map

package/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./NodeKind.js";
+export * from "./NodeShape.js";
+export * from "./PropertyGroup.js";
+export * from "./PropertyPath.js";
+export * from "./PropertyShape.js";
+export * from "./Shape.js";
+export * from "./ShapesGraph.js";
+//# sourceMappingURL=index.d.ts.map

package/index.js

@@ -0,0 +1,8 @@
+export * from "./NodeKind.js";
+export * from "./NodeShape.js";
+export * from "./PropertyGroup.js";
+export * from "./PropertyPath.js";
+export * from "./PropertyShape.js";
+export * from "./Shape.js";
+export * from "./ShapesGraph.js";
+//# sourceMappingURL=index.js.map

package/package.json

@@ -0,0 +1,50 @@
+{
+  "dependencies": {
+    "@rdfjs/term-map": "^2.0.2",
+    "@rdfjs/term-set": "^2.0.3",
+    "@rdfjs/types": "^1.1.0",
+    "@tpluscode/rdf-ns-builders": "^4.3.0",
+    "@types/rdfjs__term-map": "^2.0.10",
+    "@types/rdfjs__term-set": "^2.0.9",
+    "purify-ts": "^2.1.0",
+    "rdfjs-resource": "1.0.12"
+  },
+  "devDependencies": {
+    "@types/n3": "^1.21.1",
+    "n3": "^1.21.3"
+  },
+  "files": [
+    "*.d.ts",
+    "*.js"
+  ],
+  "main": "index.js",
+  "license": "Apache-2.0",
+  "name": "@shaclmate/shacl-ast",
+  "scripts": {
+    "build": "tsc -b",
+    "check": "biome check",
+    "check:write": "biome check --write",
+    "check:write:unsafe": "biome check --write --unsafe",
+    "clean": "rimraf -g **/*.d.ts* **/*.js **/*.js.map tsconfig.tsbuildinfo",
+    "format": "biome format",
+    "format:write": "biome format --write",
+    "format:write:unsafe": "biome format --write --unsafe",
+    "rebuild": "run-s clean build",
+    "link-dependencies": "npm link purify-ts-helpers rdfjs-resource",
+    "lint": "biome lint",
+    "lint:write": "biome lint --write",
+    "lint:write:unsafe": "biome lint --write --unsafe",
+    "test": "biome check && vitest run",
+    "test:coverage": "biome check && vitest run --coverage",
+    "test:watch": "vitest watch",
+    "unlink": "npm unlink -g @shaclmate/shacl-ast",
+    "watch": "tsc -w --preserveWatchOutput"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/minorg/shaclmate"
+  },
+  "type": "module",
+  "types": "index.d.ts",
+  "version": "2.0.13"
+}