@shaclmate/shacl-ast 4.0.13 → 4.0.15

package/dist/ShapesGraph.js

@@ -1,336 +1,49 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    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 { AbstractShapesGraph } from "./AbstractShapesGraph.js";
 import * as generated from "./generated.js";
-import { NodeShape } from "./NodeShape.js";
-import { Ontology } from "./Ontology.js";
-import { PropertyGroup } from "./PropertyGroup.js";
-import { PropertyShape } from "./PropertyShape.js";
-export class ShapesGraph {
-    nodeShapesByIdentifier;
-    ontologiesByIdentifier;
-    propertyGroupsByIdentifier;
-    propertyShapesByIdentifier;
-    constructor(parameters) {
-        this.nodeShapesByIdentifier = parameters.nodeShapesByIdentifier;
-        this.ontologiesByIdentifier = parameters.ontologiesByIdentifier;
-        this.propertyGroupsByIdentifier = parameters.propertyGroupsByIdentifier;
-        this.propertyShapesByIdentifier = parameters.propertyShapesByIdentifier;
-    }
-    get nodeShapes() {
-        return [...this.nodeShapesByIdentifier.values()];
-    }
-    nodeShapeByIdentifier(identifier) {
-        const nodeShape = this.nodeShapesByIdentifier.get(identifier);
-        return nodeShape
-            ? Either.of(nodeShape)
-            : Left(new Error(`no such node shape ${Resource.Identifier.toString(identifier)}`));
-    }
-    get ontologies() {
-        return [...this.ontologiesByIdentifier.values()];
-    }
-    ontologyByIdentifier(identifier) {
-        const ontology = this.ontologiesByIdentifier.get(identifier);
-        return ontology
-            ? Either.of(ontology)
-            : Left(new Error(`no such ontology ${Resource.Identifier.toString(identifier)}`));
-    }
-    propertyGroupByIdentifier(identifier) {
-        const propertyGroup = this.propertyGroupsByIdentifier.get(identifier);
-        return propertyGroup
-            ? Either.of(propertyGroup)
-            : Left(new Error(`no such property group ${Resource.Identifier.toString(identifier)}`));
-    }
-    get propertyGroups() {
-        return [...this.propertyGroupsByIdentifier.values()];
-    }
-    propertyShapeByIdentifier(identifier) {
-        const propertyShape = this.propertyShapesByIdentifier.get(identifier);
-        return propertyShape
-            ? Either.of(propertyShape)
-            : Left(new Error(`no such property shape ${Resource.Identifier.toString(identifier)}`));
-    }
-    get propertyShapes() {
-        return [...this.propertyShapesByIdentifier.values()];
-    }
-    shapeByIdentifier(identifier) {
-        return this.nodeShapeByIdentifier(identifier).alt(this.propertyShapeByIdentifier(identifier));
+const typeFunctions = {
+    NodeShape: generated.NodeShape,
+    Ontology: generated.Ontology,
+    PropertyGroup: generated.PropertyGroup,
+    PropertyShape: generated.PropertyShape,
+};
+export class ShapesGraph extends AbstractShapesGraph {
+    typeFunctions = typeFunctions;
+    static builder() {
+        return new ShapesGraph.Builder();
     }
 }
-__decorate([
-    Memoize()
-], ShapesGraph.prototype, "nodeShapes", null);
-__decorate([
-    Memoize()
-], ShapesGraph.prototype, "ontologies", null);
-__decorate([
-    Memoize()
-], ShapesGraph.prototype, "propertyGroups", null);
-__decorate([
-    Memoize()
-], ShapesGraph.prototype, "propertyShapes", null);
 (function (ShapesGraph) {
-    class Factory {
-        preferredLanguages;
-        constructor(parameters) {
-            this.preferredLanguages = parameters?.preferredLanguages ?? ["en", ""];
-        }
-        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();
-            const propertyShapesByIdentifier = new TermMap();
-            // Have to instantiate ShapesGraph here so the shapes have references to it
-            // Pass in the mutable TermMap's and then mutate them
-            const shapesGraph = new ShapesGraph({
-                nodeShapesByIdentifier,
-                ontologiesByIdentifier,
-                propertyGroupsByIdentifier,
-                propertyShapesByIdentifier,
-            });
-            return Either.encase(() => {
-                function readGraph() {
-                    const graphs = new TermSet();
-                    for (const quad of dataset) {
-                        graphs.add(quad.graph);
-                    }
-                    if (graphs.size !== 1) {
-                        return undefined;
-                    }
-                    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}`);
-                    }
-                }
-                const graph = readGraph();
-                // Read ontologies
-                for (const ontologyResource of resourceSet.instancesOf(owl.Ontology, {
-                    graph,
-                })) {
-                    if (ontologiesByIdentifier.has(ontologyResource.identifier)) {
-                        continue;
-                    }
-                    this.createOntology({
-                        curieFactory,
-                        resource: curieResource(ontologyResource.identifier),
-                        shapesGraph,
-                    }).ifRight((ontology) => ontologiesByIdentifier.set(ontologyResource.identifier, ontology));
-                }
-                // Read property groups
-                for (const propertyGroupResource of resourceSet.instancesOf(sh.PropertyGroup, { graph })) {
-                    if (propertyGroupResource.identifier.termType !== "NamedNode") {
-                        continue;
-                    }
-                    if (propertyGroupsByIdentifier.has(propertyGroupResource.identifier)) {
-                        continue;
-                    }
-                    this.createPropertyGroup({
-                        curieFactory,
-                        resource: curieResource(propertyGroupResource.identifier),
-                        shapesGraph,
-                    }).ifRight((propertyGroup) => propertyGroupsByIdentifier.set(propertyGroupResource.identifier, propertyGroup));
-                }
-                // Read shapes
-                // Collect the shape identifiers in sets
-                const shapeNodeSet = new TermSet();
-                // Utility function for adding to the shapeNodeSet
-                function addShapeNode(shapeNode) {
-                    switch (shapeNode.termType) {
-                        case "BlankNode":
-                        case "NamedNode":
-                            shapeNodeSet.add(shapeNode);
-                            return true;
-                        default:
-                            throw new RangeError(`unexpected shape node identifier term type: ${shapeNode.termType}`);
-                    }
-                }
-                // 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,
-                    })) {
-                        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 dataset.match(null, predicate, null, graph)) {
-                        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 dataset.match(null, predicate, null, graph)) {
-                        addShapeNode(quad.subject);
-                    }
-                }
-                // Object of a shape-expecting, non-list-taking parameter such as sh:node
-                for (const predicate of [sh.node, sh.not, sh.property]) {
-                    for (const quad of dataset.match(null, predicate, null, graph)) {
-                        addShapeNode(quad.object);
-                        if (!ignoreUndefinedShapes && !datasetHasMatch(quad.object)) {
-                            throw new Error(`undefined shape: ${Resource.Identifier.toString(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.or, sh.xone]) {
-                    for (const quad of dataset.match(null, predicate, null, graph)) {
-                        switch (quad.object.termType) {
-                            case "BlankNode":
-                            case "NamedNode":
-                                break;
-                            default:
-                                throw new RangeError(`expected list term to be a blank or named node, not ${quad.object.termType}`);
-                        }
-                        for (const value of resourceSet
-                            .resource(quad.object)
-                            .toList()
-                            .unsafeCoerce()) {
-                            const identifier = value.toIdentifier().unsafeCoerce();
-                            addShapeNode(identifier);
-                            if (!ignoreUndefinedShapes && !datasetHasMatch(identifier)) {
-                                throw new Error(`undefined shape: ${Resource.Identifier.toString(identifier)}`);
-                            }
-                        }
-                    }
-                }
-                // Separate shapes into node and property shapes.
-                for (const shapeNode of shapeNodeSet) {
-                    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({
-                            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({
-                            curieFactory,
-                            resource: curieResource(shapeNode),
-                            shapesGraph,
-                        }).unsafeCoerce());
-                    }
-                }
-                return shapesGraph;
+    class Builder extends AbstractShapesGraph.AbstractBuilder {
+        typeFunctions = typeFunctions;
+        build() {
+            return new ShapesGraph({
+                nodeShapesByIdentifier: this.nodeShapesByIdentifier,
+                ontologiesByIdentifier: this.ontologiesByIdentifier,
+                propertyGroupsByIdentifier: this.propertyGroupsByIdentifier,
+                propertyShapesByIdentifier: this.propertyShapesByIdentifier,
             });
         }
-    }
-    ShapesGraph.Factory = Factory;
-    class DefaultFactory extends Factory {
-        createNodeShape({ resource, shapesGraph, }) {
-            return generated.NodeShape.$fromRdfResource(resource, {
-                ignoreRdfType: true,
-                preferredLanguages: this.preferredLanguages,
-            }).map((generatedShape) => new NodeShape(generatedShape, shapesGraph));
+        nodeShape(parameters) {
+            const nodeShape = generated.NodeShape.$create(parameters);
+            this.add(nodeShape);
+            return nodeShape;
         }
-        createOntology({ resource, }) {
-            return generated.Ontology.$fromRdfResource(resource, {
-                ignoreRdfType: true,
-                preferredLanguages: this.preferredLanguages,
-            }).map((generatedOntology) => new Ontology(generatedOntology));
+        ontology(parameters) {
+            const ontology = generated.Ontology.$create(parameters);
+            this.add(ontology);
+            return ontology;
         }
-        createPropertyGroup({ resource, }) {
-            return generated.PropertyGroup.$fromRdfResource(resource, {
-                ignoreRdfType: true,
-                preferredLanguages: this.preferredLanguages,
-            }).map((propertyGroup) => new PropertyGroup(propertyGroup));
+        propertyGroup(parameters) {
+            const propertyGroup = generated.PropertyGroup.$create(parameters);
+            this.add(propertyGroup);
+            return propertyGroup;
         }
-        createPropertyShape({ curieFactory, resource, shapesGraph, }) {
-            return generated.PropertyShape.$fromRdfResource(resource, {
-                ignoreRdfType: true,
-                preferredLanguages: this.preferredLanguages,
-            }).map((generatedShape) => new PropertyShape({
-                ...generatedShape,
-                path: (generatedShape.path.termType === "NamedNode"
-                    ? curieFactory.create(generatedShape.path).extract()
-                    : undefined) ?? generatedShape.path,
-            }, shapesGraph));
+        propertyShape(parameters) {
+            const propertyShape = generated.PropertyShape.$create(parameters);
+            this.add(propertyShape);
+            return propertyShape;
         }
     }
-    const defaultFactory = new DefaultFactory();
-    function create(parameters) {
-        return defaultFactory.createShapesGraph(parameters);
-    }
-    ShapesGraph.create = create;
+    ShapesGraph.Builder = Builder;
 })(ShapesGraph || (ShapesGraph = {}));
 //# sourceMappingURL=ShapesGraph.js.map