@shaclmate/compiler 3.0.4 → 4.0.0

package/dist/input/ShapesGraph.d.ts

@@ -1,9 +1,26 @@
-import type { DatasetCore } from "@rdfjs/types";
-import { RdfjsShapesGraph } from "@shaclmate/shacl-ast";
+import { ShapesGraph as _ShapesGraph } 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 declare class ShapesGraph extends RdfjsShapesGraph<NodeShape, Ontology, PropertyGroup, PropertyShape, Shape> {
-    constructor({ dataset }: {
-        dataset: DatasetCore;
-    });
+export type ShapesGraph = _ShapesGraph<NodeShape, Ontology, PropertyGroup, PropertyShape, Shape>;
+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({ resource, shapesGraph, }: {
+            resource: Resource;
+            shapesGraph: ShapesGraph;
+        }): Either<Error, PropertyShape>;
+    }
+    export function create(parameters: Parameters<Factory["createShapesGraph"]>[0]): Either<Error, ShapesGraph>;
+    export {};
 }
 //# sourceMappingURL=ShapesGraph.d.ts.map

package/dist/input/ShapesGraph.js

@@ -1,46 +1,65 @@
-import { RdfjsShapesGraph } from "@shaclmate/shacl-ast";
+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 * as generated from "./generated.js";
 import { NodeShape, Ontology, PropertyGroup, PropertyShape, } from "./index.js";
-export class ShapesGraph extends RdfjsShapesGraph {
-    constructor({ dataset }) {
-        super({
-            dataset,
-            factory: {
-                nodeShapeFromRdf({ resource, shapesGraph, }) {
-                    return generated.ShaclmateNodeShape.$fromRdf(resource, {
-                        ignoreRdfType: true,
-                    }).map((generatedShape) => new NodeShape({
-                        ancestorClassIris: ancestorClassIris(resource, Number.MAX_SAFE_INTEGER),
-                        childClassIris: descendantClassIris(resource, 1),
-                        descendantClassIris: descendantClassIris(resource, Number.MAX_SAFE_INTEGER),
-                        generatedShaclmateNodeShape: generatedShape,
-                        isClass: resource.isInstanceOf(owl.Class) ||
-                            resource.isInstanceOf(rdfs.Class),
-                        isList: resource.isSubClassOf(rdf.List),
-                        parentClassIris: ancestorClassIris(resource, 1),
-                        shapesGraph,
-                    }));
-                },
-                ontologyFromRdf({ resource, }) {
-                    return generated.ShaclmateOntology.$fromRdf(resource, {
-                        ignoreRdfType: true,
-                    }).map((generatedOntology) => new Ontology(generatedOntology));
-                },
-                propertyGroupFromRdf({ resource, }) {
-                    return generated.ShaclCorePropertyGroup.$fromRdf(resource, {
-                        ignoreRdfType: true,
-                    }).map((generatedPropertyGroup) => new PropertyGroup(generatedPropertyGroup));
-                },
-                propertyShapeFromRdf({ resource, shapesGraph, }) {
-                    return generated.ShaclmatePropertyShape.$fromRdf(resource, {
-                        ignoreRdfType: true,
-                    }).map((generatedShape) => new PropertyShape(generatedShape, shapesGraph));
-                },
-            },
-        });
+export var ShapesGraph;
+(function (ShapesGraph) {
+    class Factory extends _ShapesGraph.Factory {
+        createNodeShape({ resource, shapesGraph, }) {
+            return generated.ShaclmateNodeShape.$fromRdf(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_,
+                    generatedShaclmateNodeShape: generatedShape,
+                    isClass,
+                    isList,
+                    parentClassIris: ancestorClassIris(resource, 1),
+                    shapesGraph,
+                });
+            });
+        }
+        createOntology({ resource, }) {
+            return generated.ShaclmateOntology.$fromRdf(resource, {
+                ignoreRdfType: true,
+                preferredLanguages: this.preferredLanguages,
+            }).map((generatedOntology) => new Ontology(generatedOntology));
+        }
+        createPropertyGroup({ resource, }) {
+            return generated.ShaclCorePropertyGroup.$fromRdf(resource, {
+                ignoreRdfType: true,
+                preferredLanguages: this.preferredLanguages,
+            }).map((generatedPropertyGroup) => new PropertyGroup(generatedPropertyGroup));
+        }
+        createPropertyShape({ resource, shapesGraph, }) {
+            return generated.ShaclmatePropertyShape.$fromRdf(resource, {
+                ignoreRdfType: true,
+                preferredLanguages: this.preferredLanguages,
+            }).map((generatedShape) => new PropertyShape(generatedShape, shapesGraph));
+        }
     }
-}
+    const factory = new Factory();
+    function create(parameters) {
+        return factory.createShapesGraph(parameters);
+    }
+    ShapesGraph.create = create;
+})(ShapesGraph || (ShapesGraph = {}));
 //# sourceMappingURL=ShapesGraph.js.map

package/dist/input/ancestorClassIris.js

@@ -4,7 +4,10 @@ export function ancestorClassIris(classResource, maxDepth) {
     const ancestorClassIris = new TermSet();
     function ancestorClassIrisRecursive(classResource, depth) {
         for (const parentClassValue of classResource.values(rdfs.subClassOf)) {
-            parentClassValue.toNamedResource().ifRight((parentClassResource) => {
+            parentClassValue.toResource().ifRight((parentClassResource) => {
+                if (parentClassResource.identifier.termType !== "NamedNode") {
+                    return;
+                }
                 if (ancestorClassIris.has(parentClassResource.identifier)) {
                     return;
                 }

package/dist/input/descendantClassIris.js

@@ -3,8 +3,14 @@ import { rdfs } from "@tpluscode/rdf-ns-builders";
 export function descendantClassIris(classResource, maxDepth) {
     const descendantClassIris = new TermSet();
     function descendantClassIrisRecursive(classResource, depth) {
-        for (const childClassValue of classResource.valuesOf(rdfs.subClassOf)) {
-            childClassValue.toNamedResource().ifRight((childClassResource) => {
+        for (const childClassValue of classResource.values({
+            path: rdfs.subClassOf,
+            termType: "InversePath",
+        })) {
+            childClassValue.toResource().ifRight((childClassResource) => {
+                if (childClassResource.identifier.termType !== "NamedNode") {
+                    return;
+                }
                 if (descendantClassIris.has(childClassResource.identifier)) {
                     return;
                 }