@shaclmate/compiler 4.0.14 → 4.0.15

package/dist/input/ShapesGraph.js

@@ -1,68 +1,66 @@
-import { ShapesGraph as _ShapesGraph, } from "@shaclmate/shacl-ast";
-import { owl, rdf, rdfs } from "@tpluscode/rdf-ns-builders";
-import { ancestorClassIris } from "./ancestorClassIris.js";
-import { descendantClassIris } from "./descendantClassIris.js";
+import { AbstractShapesGraph } from "@shaclmate/shacl-ast";
+import { Compiler } from "../Compiler.js";
+import { ShapesGraphToAstTransformer } from "../ShapesGraphToAstTransformer.js";
 import * as generated from "./generated.js";
-export var ShapesGraph;
+const typeFunctions = {
+    NodeShape: generated.NodeShape,
+    Ontology: generated.Ontology,
+    PropertyGroup: generated.PropertyGroup,
+    PropertyShape: generated.PropertyShape,
+};
+export class ShapesGraph extends AbstractShapesGraph {
+    typeFunctions = typeFunctions;
+    /**
+     * Compile the shapes graph using the given generator and return the generator's output.
+     */
+    compile(parameters) {
+        return new Compiler(parameters).compile(this);
+    }
+    static builder() {
+        return new ShapesGraph.Builder();
+    }
+    /**
+     * Transform the shapes graph to an AST.
+     */
+    toAst(options) {
+        return new ShapesGraphToAstTransformer({
+            ...options,
+            shapesGraph: this,
+        }).transform();
+    }
+}
 (function (ShapesGraph) {
-    class Factory extends _ShapesGraph.Factory {
-        createNodeShape({ resource, }) {
-            return generated.NodeShape.$fromRdfResource(resource, {
-                ignoreRdfType: true,
-                preferredLanguages: this.preferredLanguages,
-            }).map((generatedShape) => {
-                let isClass = resource.isInstanceOf(owl.Class) || resource.isInstanceOf(rdfs.Class);
-                const isList = resource.isSubClassOf(rdf.List);
-                if (isList) {
-                    isClass = true; // RDFS entailment: if A rdfs:subClassOf rdf:List then A is an rdfs:Class
-                }
-                const ancestorClassIris_ = ancestorClassIris(resource, Number.MAX_SAFE_INTEGER).filter((ancestorClassIri) => !ancestorClassIri.equals(rdf.List));
-                if (ancestorClassIris_.length > 0) {
-                    isClass = true; // RDFS entailment: if A rdfs:subClassOf B then both A and B are rdfs:Class's
-                }
-                const descendantClassIris_ = descendantClassIris(resource, Number.MAX_SAFE_INTEGER);
-                if (descendantClassIris_.length > 0) {
-                    isClass = true; // RDFS entailment, see above
-                }
-                return {
-                    ...generatedShape,
-                    ancestorClassIris: ancestorClassIris_,
-                    childClassIris: descendantClassIris(resource, 1),
-                    descendantClassIris: descendantClassIris_,
-                    isClass,
-                    isList,
-                    parentClassIris: ancestorClassIris(resource, 1).filter((ancestorClassIri) => !ancestorClassIri.equals(rdf.List)),
-                };
+    class Builder extends AbstractShapesGraph.AbstractBuilder {
+        typeFunctions = typeFunctions;
+        build() {
+            return new ShapesGraph({
+                nodeShapesByIdentifier: this.nodeShapesByIdentifier,
+                ontologiesByIdentifier: this.ontologiesByIdentifier,
+                propertyGroupsByIdentifier: this.propertyGroupsByIdentifier,
+                propertyShapesByIdentifier: this.propertyShapesByIdentifier,
             });
         }
-        createOntology({ resource, }) {
-            return generated.Ontology.$fromRdfResource(resource, {
-                ignoreRdfType: true,
-                preferredLanguages: this.preferredLanguages,
-            });
+        nodeShape(parameters) {
+            const nodeShape = generated.NodeShape.$create(parameters);
+            this.add(nodeShape);
+            return nodeShape;
         }
-        createPropertyGroup({ resource, }) {
-            return generated.PropertyGroup.$fromRdfResource(resource, {
-                ignoreRdfType: true,
-                preferredLanguages: this.preferredLanguages,
-            });
+        ontology(parameters) {
+            const ontology = generated.Ontology.$create(parameters);
+            this.add(ontology);
+            return ontology;
         }
-        createPropertyShape({ curieFactory, resource, }) {
-            return generated.PropertyShape.$fromRdfResource(resource, {
-                ignoreRdfType: true,
-                preferredLanguages: this.preferredLanguages,
-            }).map((generatedShape) => ({
-                ...generatedShape,
-                path: (generatedShape.path.termType === "NamedNode"
-                    ? curieFactory.create(generatedShape.path).extract()
-                    : undefined) ?? generatedShape.path,
-            }));
+        propertyGroup(parameters) {
+            const propertyGroup = generated.PropertyGroup.$create(parameters);
+            this.add(propertyGroup);
+            return propertyGroup;
+        }
+        propertyShape(parameters) {
+            const propertyShape = generated.PropertyShape.$create(parameters);
+            this.add(propertyShape);
+            return propertyShape;
         }
     }
-    const factory = new Factory();
-    function create(parameters) {
-        return factory.createShapesGraph(parameters);
-    }
-    ShapesGraph.create = create;
+    ShapesGraph.Builder = Builder;
 })(ShapesGraph || (ShapesGraph = {}));
 //# sourceMappingURL=ShapesGraph.js.map