@shaclmate/shacl-ast 4.0.13 → 4.0.14

package/dist/NodeKind.d.ts

@@ -1,8 +1,10 @@
+import type { NamedNode } from "@rdfjs/types";
 /**
  * TypeScript enum corresponding to sh:NodeKind, for simpler manipulation.
  */
 export type NodeKind = "BlankNode" | "IRI" | "Literal";
 export declare namespace NodeKind {
+    function fromIri(iri: NamedNode<"http://www.w3.org/ns/shacl#BlankNode" | "http://www.w3.org/ns/shacl#BlankNodeOrIRI" | "http://www.w3.org/ns/shacl#BlankNodeOrLiteral" | "http://www.w3.org/ns/shacl#IRI" | "http://www.w3.org/ns/shacl#IRIOrLiteral" | "http://www.w3.org/ns/shacl#Literal">): ReadonlySet<NodeKind>;
     function fromTermType(termType: "BlankNode" | "Literal" | "NamedNode"): NodeKind;
     function toTermType(nodeKind: NodeKind): "BlankNode" | "Literal" | "NamedNode";
 }

package/dist/NodeKind.js

@@ -1,5 +1,36 @@
 export var NodeKind;
 (function (NodeKind) {
+    function fromIri(iri) {
+        const nodeKinds = new Set();
+        switch (iri.value) {
+            case "http://www.w3.org/ns/shacl#BlankNode":
+                nodeKinds.add("BlankNode");
+                break;
+            case "http://www.w3.org/ns/shacl#BlankNodeOrIRI":
+                nodeKinds.add("BlankNode");
+                nodeKinds.add("IRI");
+                break;
+            case "http://www.w3.org/ns/shacl#BlankNodeOrLiteral":
+                nodeKinds.add("BlankNode");
+                nodeKinds.add("Literal");
+                break;
+            case "http://www.w3.org/ns/shacl#IRI":
+                nodeKinds.add("IRI");
+                break;
+            case "http://www.w3.org/ns/shacl#IRIOrLiteral":
+                nodeKinds.add("IRI");
+                nodeKinds.add("Literal");
+                break;
+            case "http://www.w3.org/ns/shacl#Literal":
+                nodeKinds.add("Literal");
+                break;
+            default:
+                iri.value;
+                throw new RangeError(iri.value);
+        }
+        return nodeKinds;
+    }
+    NodeKind.fromIri = fromIri;
     function fromTermType(termType) {
         return termType === "NamedNode" ? "IRI" : termType;
     }

package/dist/ShapesGraph.d.ts

@@ -4,13 +4,8 @@ import type { BlankNode, DatasetCore, NamedNode } from "@rdfjs/types";
 import { Either } from "purify-ts";
 import { Resource } from "rdfjs-resource";
 import { CurieFactory } from "./CurieFactory.js";
-import { NodeShape } from "./NodeShape.js";
-import { Ontology } from "./Ontology.js";
-import type { OntologyLike } from "./OntologyLike.js";
-import { PropertyGroup } from "./PropertyGroup.js";
-import { PropertyShape } from "./PropertyShape.js";
-import type { Shape } from "./Shape.js";
-export declare class ShapesGraph<NodeShapeT extends ShapeT, OntologyT extends OntologyLike, PropertyGroupT, PropertyShapeT extends ShapeT, ShapeT> {
+import * as generated from "./generated.js";
+export declare class ShapesGraph<NodeShapeT extends ShapeT, OntologyT extends generated.Ontology, PropertyGroupT extends generated.PropertyGroup, PropertyShapeT extends ShapeT, ShapeT extends generated.Shape> {
     private readonly nodeShapesByIdentifier;
     private readonly ontologiesByIdentifier;
     private readonly propertyGroupsByIdentifier;
@@ -22,17 +17,17 @@ export declare class ShapesGraph<NodeShapeT extends ShapeT, OntologyT extends On
         propertyShapesByIdentifier: TermMap<BlankNode | NamedNode, PropertyShapeT>;
     });
     get nodeShapes(): readonly NodeShapeT[];
-    nodeShapeByIdentifier(identifier: BlankNode | NamedNode): Either<Error, NodeShapeT>;
     get ontologies(): readonly OntologyT[];
-    ontologyByIdentifier(identifier: BlankNode | NamedNode): Either<Error, OntologyT>;
-    propertyGroupByIdentifier(identifier: BlankNode | NamedNode): Either<Error, PropertyGroupT>;
     get propertyGroups(): readonly PropertyGroupT[];
-    propertyShapeByIdentifier(identifier: BlankNode | NamedNode): Either<Error, PropertyShapeT>;
     get propertyShapes(): readonly PropertyShapeT[];
-    shapeByIdentifier(identifier: BlankNode | NamedNode): Either<Error, ShapeT>;
+    nodeShape(identifier: BlankNode | NamedNode): Either<Error, NodeShapeT>;
+    ontology(identifier: BlankNode | NamedNode): Either<Error, OntologyT>;
+    propertyGroup(identifier: BlankNode | NamedNode): Either<Error, PropertyGroupT>;
+    propertyShape(identifier: BlankNode | NamedNode): Either<Error, PropertyShapeT>;
+    shape(identifier: BlankNode | NamedNode): Either<Error, ShapeT>;
 }
 export declare namespace ShapesGraph {
-    export abstract class Factory<NodeShapeT extends ShapeT, OntologyT extends OntologyLike, PropertyGroupT, PropertyShapeT extends ShapeT, ShapeT> {
+    export abstract class Factory<NodeShapeT extends generated.NodeShape & ShapeT, OntologyT extends generated.Ontology, PropertyGroupT extends generated.PropertyGroup, PropertyShapeT extends generated.PropertyShape & ShapeT, ShapeT extends generated.Shape> {
         protected preferredLanguages: readonly string[];
         constructor(parameters?: {
             preferredLanguages?: readonly string[];
@@ -63,30 +58,21 @@ export declare namespace ShapesGraph {
             shapesGraph: ShapesGraph<NodeShapeT, OntologyT, PropertyGroupT, PropertyShapeT, ShapeT>;
         }): Either<Error, PropertyShapeT>;
     }
-    type DefaultNodeShape = NodeShape<any, Ontology, PropertyGroup, DefaultPropertyShape, DefaultShape>;
-    type DefaultPropertyShape = PropertyShape<DefaultNodeShape, Ontology, PropertyGroup, any, DefaultShape>;
-    type DefaultShape = Shape<DefaultNodeShape, Ontology, PropertyGroup, DefaultPropertyShape, any>;
-    type DefaultShapesGraph = ShapesGraph<DefaultNodeShape, Ontology, PropertyGroup, DefaultPropertyShape, DefaultShape>;
-    class DefaultFactory extends Factory<DefaultNodeShape, Ontology, PropertyGroup, DefaultPropertyShape, DefaultShape> {
-        protected createNodeShape({ resource, shapesGraph, }: {
+    type DefaultShapesGraph = ShapesGraph<generated.NodeShape, generated.Ontology, generated.PropertyGroup, generated.PropertyShape, generated.Shape>;
+    class DefaultFactory extends Factory<generated.NodeShape, generated.Ontology, generated.PropertyGroup, generated.PropertyShape, generated.Shape> {
+        protected createNodeShape({ resource }: {
             resource: Resource;
-            shapesGraph: DefaultShapesGraph;
-        }): Either<Error, NodeShape<DefaultNodeShape, Ontology, PropertyGroup, DefaultPropertyShape, DefaultShape>>;
+        }): Either<Error, generated.NodeShape>;
         protected createOntology({ resource, }: {
-            curieFactory: CurieFactory;
             resource: Resource;
-            shapesGraph: DefaultShapesGraph;
-        }): Either<Error, Ontology>;
+        }): Either<Error, generated.Ontology>;
         protected createPropertyGroup({ resource, }: {
-            curieFactory: CurieFactory;
             resource: Resource;
-            shapesGraph: DefaultShapesGraph;
-        }): Either<Error, PropertyGroup>;
-        protected createPropertyShape({ curieFactory, resource, shapesGraph, }: {
+        }): Either<Error, generated.PropertyGroup>;
+        protected createPropertyShape({ curieFactory, resource, }: {
             curieFactory: CurieFactory;
             resource: Resource;
-            shapesGraph: DefaultShapesGraph;
-        }): Either<Error, DefaultPropertyShape>;
+        }): Either<Error, generated.PropertyShape>;
     }
     export function create(parameters: Parameters<DefaultFactory["createShapesGraph"]>[0]): Either<Error, DefaultShapesGraph>;
     export {};

package/dist/ShapesGraph.js

@@ -14,10 +14,6 @@ import { Resource, ResourceSet } from "rdfjs-resource";
 import { Memoize } from "typescript-memoize";
 import { CurieFactory } from "./CurieFactory.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;
@@ -32,41 +28,41 @@ export class ShapesGraph {
     get nodeShapes() {
         return [...this.nodeShapesByIdentifier.values()];
     }
-    nodeShapeByIdentifier(identifier) {
+    get ontologies() {
+        return [...this.ontologiesByIdentifier.values()];
+    }
+    get propertyGroups() {
+        return [...this.propertyGroupsByIdentifier.values()];
+    }
+    get propertyShapes() {
+        return [...this.propertyShapesByIdentifier.values()];
+    }
+    nodeShape(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) {
+    ontology(identifier) {
         const ontology = this.ontologiesByIdentifier.get(identifier);
         return ontology
             ? Either.of(ontology)
             : Left(new Error(`no such ontology ${Resource.Identifier.toString(identifier)}`));
     }
-    propertyGroupByIdentifier(identifier) {
+    propertyGroup(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) {
+    propertyShape(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));
+    shape(identifier) {
+        return this.nodeShape(identifier).alt(this.propertyShape(identifier));
     }
 }
 __decorate([
@@ -297,34 +293,34 @@ __decorate([
     }
     ShapesGraph.Factory = Factory;
     class DefaultFactory extends Factory {
-        createNodeShape({ resource, shapesGraph, }) {
+        createNodeShape({ resource }) {
             return generated.NodeShape.$fromRdfResource(resource, {
                 ignoreRdfType: true,
                 preferredLanguages: this.preferredLanguages,
-            }).map((generatedShape) => new NodeShape(generatedShape, shapesGraph));
+            });
         }
         createOntology({ resource, }) {
             return generated.Ontology.$fromRdfResource(resource, {
                 ignoreRdfType: true,
                 preferredLanguages: this.preferredLanguages,
-            }).map((generatedOntology) => new Ontology(generatedOntology));
+            });
         }
         createPropertyGroup({ resource, }) {
             return generated.PropertyGroup.$fromRdfResource(resource, {
                 ignoreRdfType: true,
                 preferredLanguages: this.preferredLanguages,
-            }).map((propertyGroup) => new PropertyGroup(propertyGroup));
+            });
         }
-        createPropertyShape({ curieFactory, resource, shapesGraph, }) {
+        createPropertyShape({ curieFactory, resource, }) {
             return generated.PropertyShape.$fromRdfResource(resource, {
                 ignoreRdfType: true,
                 preferredLanguages: this.preferredLanguages,
-            }).map((generatedShape) => new PropertyShape({
+            }).map((generatedShape) => ({
                 ...generatedShape,
                 path: (generatedShape.path.termType === "NamedNode"
                     ? curieFactory.create(generatedShape.path).extract()
                     : undefined) ?? generatedShape.path,
-            }, shapesGraph));
+            }));
         }
     }
     const defaultFactory = new DefaultFactory();