@shaclmate/compiler 4.0.13 → 4.0.15

package/dist/input/ShapesGraph.d.ts

@@ -1,27 +1,44 @@
-import { ShapesGraph as _ShapesGraph, type CurieFactory } from "@shaclmate/shacl-ast";
+import { AbstractShapesGraph } from "@shaclmate/shacl-ast";
 import type { Either } from "purify-ts";
-import type { Resource } from "rdfjs-resource";
-import { NodeShape, Ontology, PropertyGroup, PropertyShape, type Shape } from "./index.js";
-export type ShapesGraph = _ShapesGraph<NodeShape, Ontology, PropertyGroup, PropertyShape, Shape>;
+import type { Ast } from "../ast/Ast.js";
+import type { TsFeature } from "../enums/TsFeature.js";
+import type { Generator } from "../generators/Generator.js";
+import * as generated from "./generated.js";
+export declare class ShapesGraph extends AbstractShapesGraph<generated.NodeShape, generated.Ontology, generated.PropertyGroup, generated.PropertyShape> {
+    protected readonly typeFunctions: {
+        readonly NodeShape: typeof generated.NodeShape;
+        readonly Ontology: typeof generated.Ontology;
+        readonly PropertyGroup: typeof generated.PropertyGroup;
+        readonly PropertyShape: typeof generated.PropertyShape;
+    };
+    /**
+     * Compile the shapes graph using the given generator and return the generator's output.
+     */
+    compile(parameters: {
+        generator: Generator;
+        tsFeaturesDefault?: ReadonlySet<TsFeature>;
+    }): Either<Error, string>;
+    static builder(): ShapesGraph.Builder;
+    /**
+     * Transform the shapes graph to an AST.
+     */
+    toAst(options?: {
+        tsFeaturesDefault?: ReadonlySet<TsFeature>;
+    }): Either<Error, Ast>;
+}
 export declare namespace ShapesGraph {
-    class Factory extends _ShapesGraph.Factory<NodeShape, Ontology, PropertyGroup, PropertyShape, Shape> {
-        protected createNodeShape({ resource, shapesGraph, }: {
-            resource: Resource;
-            shapesGraph: ShapesGraph;
-        }): Either<Error, NodeShape>;
-        protected createOntology({ resource, }: {
-            resource: Resource;
-        }): Either<Error, Ontology>;
-        protected createPropertyGroup({ resource, }: {
-            resource: Resource;
-        }): Either<Error, PropertyGroup>;
-        protected createPropertyShape({ curieFactory, resource, shapesGraph, }: {
-            curieFactory: CurieFactory;
-            resource: Resource;
-            shapesGraph: ShapesGraph;
-        }): Either<Error, PropertyShape>;
+    class Builder extends AbstractShapesGraph.AbstractBuilder<generated.NodeShape, generated.Ontology, generated.PropertyGroup, generated.PropertyShape> {
+        protected readonly typeFunctions: {
+            readonly NodeShape: typeof generated.NodeShape;
+            readonly Ontology: typeof generated.Ontology;
+            readonly PropertyGroup: typeof generated.PropertyGroup;
+            readonly PropertyShape: typeof generated.PropertyShape;
+        };
+        build(): ShapesGraph;
+        nodeShape(parameters?: Parameters<typeof generated.NodeShape.$create>[0]): generated.NodeShape;
+        ontology(parameters?: Parameters<typeof generated.Ontology.$create>[0]): generated.Ontology;
+        propertyGroup(parameters?: Parameters<typeof generated.PropertyGroup.$create>[0]): generated.PropertyGroup;
+        propertyShape(parameters: Parameters<typeof generated.PropertyShape.$create>[0]): generated.PropertyShape;
     }
-    export function create(parameters: Parameters<Factory["createShapesGraph"]>[0]): Either<Error, ShapesGraph>;
-    export {};
 }
 //# sourceMappingURL=ShapesGraph.d.ts.map

package/dist/input/ShapesGraph.js

@@ -1,70 +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";
-import { NodeShape, Ontology, PropertyGroup, PropertyShape, } from "./index.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, shapesGraph, }) {
-            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);
-                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 new NodeShape({
-                    ancestorClassIris: ancestorClassIris_,
-                    childClassIris: descendantClassIris(resource, 1),
-                    descendantClassIris: descendantClassIris_,
-                    generatedNodeShape: generatedShape,
-                    isClass,
-                    isList,
-                    parentClassIris: ancestorClassIris(resource, 1),
-                    shapesGraph,
-                });
+    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,
-            }).map((generatedOntology) => new Ontology(generatedOntology));
+        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,
-            }).map((generatedPropertyGroup) => new PropertyGroup(generatedPropertyGroup));
+        ontology(parameters) {
+            const ontology = generated.Ontology.$create(parameters);
+            this.add(ontology);
+            return ontology;
         }
-        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));
+        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