@shaclmate/shacl-ast 2.0.13 → 2.0.14

package/Factory.d.ts

@@ -0,0 +1,23 @@
+import type { Either } from "purify-ts";
+import type { Resource } from "rdfjs-resource";
+import type { OntologyLike } from "./OntologyLike.js";
+import type { ShapesGraph } from "./ShapesGraph.js";
+export interface Factory<NodeShapeT extends ShapeT, OntologyT extends OntologyLike, PropertyGroupT, PropertyShapeT extends ShapeT, ShapeT> {
+    nodeShapeFromRdf(parameters: {
+        resource: Resource;
+        shapesGraph: ShapesGraph<NodeShapeT, OntologyT, PropertyGroupT, PropertyShapeT, ShapeT>;
+    }): Either<Error, NodeShapeT>;
+    ontologyFromRdf(parameters: {
+        resource: Resource;
+        shapesGraph: ShapesGraph<NodeShapeT, OntologyT, PropertyGroupT, PropertyShapeT, ShapeT>;
+    }): Either<Error, OntologyT>;
+    propertyGroupFromRdf(parameters: {
+        resource: Resource;
+        shapesGraph: ShapesGraph<NodeShapeT, OntologyT, PropertyGroupT, PropertyShapeT, ShapeT>;
+    }): Either<Error, PropertyGroupT>;
+    propertyShapeFromRdf(parameters: {
+        resource: Resource;
+        shapesGraph: ShapesGraph<NodeShapeT, OntologyT, PropertyGroupT, PropertyShapeT, ShapeT>;
+    }): Either<Error, PropertyShapeT>;
+}
+//# sourceMappingURL=Factory.d.ts.map

package/Factory.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Factory.js.map

package/NodeKind.d.ts

@@ -1,9 +1,6 @@
+import type { BlankNode, Literal, NamedNode } from "@rdfjs/types";
 /**
  * TypeScript enum corresponding to sh:NodeKind, for simpler manipulation.
  */
-export declare enum NodeKind {
-    BLANK_NODE = 1,
-    IRI = 2,
-    LITERAL = 3
-}
+export type NodeKind = (BlankNode | NamedNode | Literal)["termType"];
 //# sourceMappingURL=NodeKind.d.ts.map

package/NodeKind.js

@@ -1,10 +1,2 @@
-/**
- * TypeScript enum corresponding to sh:NodeKind, for simpler manipulation.
- */
-export var NodeKind;
-(function (NodeKind) {
-    NodeKind[NodeKind["BLANK_NODE"] = 1] = "BLANK_NODE";
-    NodeKind[NodeKind["IRI"] = 2] = "IRI";
-    NodeKind[NodeKind["LITERAL"] = 3] = "LITERAL";
-})(NodeKind || (NodeKind = {}));
+export {};
 //# sourceMappingURL=NodeKind.js.map

package/NodeShape.d.ts

@@ -1,17 +1,19 @@
 import type { Maybe } from "purify-ts";
-import type { Resource } from "rdfjs-resource";
-import type { PropertyShape } from "./PropertyShape.js";
+import type { OntologyLike } from "./OntologyLike.js";
 import { Shape } from "./Shape.js";
 import type { ShapesGraph } from "./ShapesGraph.js";
-export declare class NodeShape extends Shape {
-    readonly constraints: NodeShape.Constraints;
-    constructor(resource: Resource, shapesGraph: ShapesGraph);
+import type * as generated from "./generated.js";
+export declare class NodeShape<NodeShapeT extends ShapeT, OntologyT extends OntologyLike, PropertyGroupT, PropertyShapeT extends ShapeT, ShapeT> extends Shape<NodeShapeT, OntologyT, PropertyGroupT, PropertyShapeT, ShapeT> {
+    readonly constraints: NodeShape.Constraints<NodeShapeT, OntologyT, PropertyGroupT, PropertyShapeT, ShapeT>;
+    constructor(generatedShaclCoreNodeShape: Omit<generated.ShaclCoreNodeShape, "type">, shapesGraph: ShapesGraph<NodeShapeT, OntologyT, PropertyGroupT, PropertyShapeT, ShapeT>);
     toString(): string;
 }
 export declare namespace NodeShape {
-    class Constraints extends Shape.Constraints {
+    class Constraints<NodeShapeT extends ShapeT, OntologyT extends OntologyLike, PropertyGroupT, PropertyShapeT extends ShapeT, ShapeT> extends Shape.Constraints<NodeShapeT, OntologyT, PropertyGroupT, PropertyShapeT, ShapeT> {
+        private readonly generatedShaclCoreNodeShape;
+        constructor(generatedShaclCoreNodeShape: Omit<generated.ShaclCoreNodeShape, "type">, shapesGraph: ShapesGraph<NodeShapeT, OntologyT, PropertyGroupT, PropertyShapeT, ShapeT>);
         get closed(): Maybe<boolean>;
-        get properties(): readonly PropertyShape[];
+        get properties(): readonly PropertyShapeT[];
     }
 }
 //# sourceMappingURL=NodeShape.d.ts.map

package/NodeShape.js

@@ -1,28 +1,24 @@
-import { sh } from "@tpluscode/rdf-ns-builders";
 import { Shape } from "./Shape.js";
 export class NodeShape extends Shape {
-    constructor(resource, shapesGraph) {
-        super(resource);
-        this.constraints = new NodeShape.Constraints(resource, shapesGraph);
+    constructor(generatedShaclCoreNodeShape, shapesGraph) {
+        super(generatedShaclCoreNodeShape, shapesGraph);
+        this.constraints = new NodeShape.Constraints(generatedShaclCoreNodeShape, shapesGraph);
     }
     toString() {
-        return `NodeShape(node=${this.resource.identifier.value})`;
+        return `NodeShape(node=${this.identifier.value})`;
     }
 }
 (function (NodeShape) {
     class Constraints extends Shape.Constraints {
+        constructor(generatedShaclCoreNodeShape, shapesGraph) {
+            super(generatedShaclCoreNodeShape, shapesGraph);
+            this.generatedShaclCoreNodeShape = generatedShaclCoreNodeShape;
+        }
         get closed() {
-            return this.resource
-                .value(sh.closed)
-                .chain((value) => value.toBoolean())
-                .toMaybe();
+            return this.generatedShaclCoreNodeShape.closed;
         }
         get properties() {
-            return [...this.resource.values(sh.property)].flatMap((value) => value
-                .toIdentifier()
-                .toMaybe()
-                .chain((shapeNode) => this.shapesGraph.propertyShapeByNode(shapeNode))
-                .toList());
+            return this.generatedShaclCoreNodeShape.properties.flatMap((identifier) => this.shapesGraph.propertyShapeByIdentifier(identifier).toList());
         }
     }
     NodeShape.Constraints = Constraints;

package/Ontology.d.ts

@@ -0,0 +1,10 @@
+import type { BlankNode, NamedNode } from "@rdfjs/types";
+import type { OntologyLike } from "./OntologyLike.js";
+import type * as generated from "./generated.js";
+export declare class Ontology implements OntologyLike {
+    private readonly generatedOntology;
+    constructor(generatedOntology: Omit<generated.OwlOntology, "type">);
+    get identifier(): BlankNode | NamedNode;
+    toString(): string;
+}
+//# sourceMappingURL=Ontology.d.ts.map

package/Ontology.js

@@ -0,0 +1,12 @@
+export class Ontology {
+    constructor(generatedOntology) {
+        this.generatedOntology = generatedOntology;
+    }
+    get identifier() {
+        return this.generatedOntology.identifier;
+    }
+    toString() {
+        return `Ontology(node=${this.identifier.value})`;
+    }
+}
+//# sourceMappingURL=Ontology.js.map

package/OntologyLike.d.ts

@@ -0,0 +1,8 @@
+import type { BlankNode, NamedNode } from "@rdfjs/types";
+/**
+ * Minimal interface for objects satisfying OntologyT.
+ */
+export interface OntologyLike {
+    readonly identifier: BlankNode | NamedNode;
+}
+//# sourceMappingURL=OntologyLike.d.ts.map

package/OntologyLike.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=OntologyLike.js.map

package/PropertyGroup.d.ts

@@ -1,9 +1,10 @@
-import type { Literal } from "@rdfjs/types";
-import type { Maybe } from "purify-ts";
-import type { Resource } from "rdfjs-resource";
+import type { BlankNode, Literal, NamedNode } from "@rdfjs/types";
+import type * as generated from "./generated.js";
 export declare class PropertyGroup {
-    private readonly resource;
-    constructor(resource: Resource);
-    get label(): Maybe<Literal>;
+    private readonly delegate;
+    constructor(delegate: generated.ShaclCorePropertyGroup);
+    get comments(): readonly Literal[];
+    get identifier(): BlankNode | NamedNode;
+    get labels(): readonly Literal[];
 }
 //# sourceMappingURL=PropertyGroup.d.ts.map

package/PropertyGroup.js

@@ -1,13 +1,15 @@
-import { rdfs } from "@tpluscode/rdf-ns-builders";
 export class PropertyGroup {
-    constructor(resource) {
-        this.resource = resource;
-    }
-    get label() {
-        return this.resource
-            .value(rdfs.label)
-            .chain((value) => value.toLiteral())
-            .toMaybe();
+    constructor(delegate) {
+        this.delegate = delegate;
+    }
+    get comments() {
+        return this.delegate.comments;
+    }
+    get identifier() {
+        return this.delegate.identifier;
+    }
+    get labels() {
+        return this.delegate.labels;
     }
 }
 //# sourceMappingURL=PropertyGroup.js.map

package/PropertyPath.d.ts

@@ -1,6 +1,6 @@
 import type { NamedNode } from "@rdfjs/types";
-import { Either } from "purify-ts";
-import { Resource } from "rdfjs-resource";
+import type * as purify from "purify-ts";
+import type * as rdfjsResource from "rdfjs-resource";
 export interface AlternativePath {
     readonly kind: "AlternativePath";
     readonly members: readonly PropertyPath[];
@@ -31,6 +31,11 @@ export interface ZeroOrOnePath {
 }
 export type PropertyPath = AlternativePath | InversePath | OneOrMorePath | PredicatePath | SequencePath | ZeroOrMorePath | ZeroOrOnePath;
 export declare namespace PropertyPath {
-    function fromResource(resource: Resource): Either<Error, PropertyPath>;
+    function fromRdf({ resource, }: {
+        [_index: string]: any;
+        ignoreRdfType?: boolean;
+        languageIn?: readonly string[];
+        resource: rdfjsResource.Resource;
+    }): purify.Either<rdfjsResource.Resource.ValueError, PropertyPath>;
 }
 //# sourceMappingURL=PropertyPath.d.ts.map

package/PropertyPath.js

@@ -3,7 +3,7 @@ import { Either, Left } from "purify-ts";
 import { Resource } from "rdfjs-resource";
 export var PropertyPath;
 (function (PropertyPath) {
-    function fromResource(resource) {
+    function fromRdf({ resource, }) {
         // Predicate path
         // sh:path ex:parent
         if (resource.identifier.termType === "NamedNode") {
@@ -16,9 +16,15 @@ export var PropertyPath;
                 for (const value of values) {
                     const memberResource = value.toResource().toMaybe();
                     if (memberResource.isNothing()) {
-                        return Left(new Error("non-identifier in property path list"));
+                        return Left(new Resource.ValueError({
+                            focusResource: resource,
+                            message: "non-identifier in property path list",
+                            predicate: rdf.subject,
+                        }));
                     }
-                    const member = PropertyPath.fromResource(memberResource.unsafeCoerce());
+                    const member = PropertyPath.fromRdf({
+                        resource: memberResource.unsafeCoerce(),
+                    });
                     if (member.isLeft()) {
                         return member;
                     }
@@ -33,7 +39,11 @@ export var PropertyPath;
                 case "NamedNode":
                     break;
                 default:
-                    return Left(new Error(`non-BlankNode/NamedNode property path object on path ${resource.identifier.value}: ${quad.object.termType} ${quad.object.value}`));
+                    return Left(new Resource.ValueError({
+                        focusResource: resource,
+                        message: `non-BlankNode/NamedNode property path object on path ${resource.identifier.value}: ${quad.object.termType} ${quad.object.value}`,
+                        predicate: quad.predicate,
+                    }));
             }
             const objectResource = new Resource({
                 dataset: resource.dataset,
@@ -50,14 +60,14 @@ export var PropertyPath;
             // Inverse path
             // sh:path: [ sh:inversePath ex:parent ]
             if (quad.predicate.equals(sh.inversePath)) {
-                return PropertyPath.fromResource(objectResource).map((path) => ({
+                return PropertyPath.fromRdf({ resource: objectResource }).map((path) => ({
                     kind: "InversePath",
                     path,
                 }));
             }
             // One or more path
             if (quad.predicate.equals(sh.oneOrMorePath)) {
-                return PropertyPath.fromResource(objectResource).map((path) => ({
+                return PropertyPath.fromRdf({ resource: objectResource }).map((path) => ({
                     kind: "OneOrMorePath",
                     path,
                 }));
@@ -72,20 +82,24 @@ export var PropertyPath;
             }
             // Zero or more path
             if (quad.predicate.equals(sh.zeroOrMorePath)) {
-                return PropertyPath.fromResource(objectResource).map((path) => ({
+                return PropertyPath.fromRdf({ resource: objectResource }).map((path) => ({
                     kind: "ZeroOrMorePath",
                     path,
                 }));
             }
             if (quad.predicate.equals(sh.zeroOrOnePath)) {
-                return PropertyPath.fromResource(objectResource).map((path) => ({
+                return PropertyPath.fromRdf({ resource: objectResource }).map((path) => ({
                     kind: "ZeroOrOnePath",
                     path,
                 }));
             }
         }
-        return Left(new Error(`unrecognized or ill-formed SHACL property path ${resource.identifier.value}`));
+        return Left(new Resource.ValueError({
+            focusResource: resource,
+            message: `unrecognized or ill-formed SHACL property path ${resource.identifier.value}`,
+            predicate: rdf.subject,
+        }));
     }
-    PropertyPath.fromResource = fromResource;
+    PropertyPath.fromRdf = fromRdf;
 })(PropertyPath || (PropertyPath = {}));
 //# sourceMappingURL=PropertyPath.js.map

package/PropertyShape.d.ts

@@ -1,21 +1,20 @@
 import type { BlankNode, Literal, NamedNode } from "@rdfjs/types";
 import type { Maybe } from "purify-ts";
-import type { Resource } from "rdfjs-resource";
-import type { PropertyGroup } from "./PropertyGroup.js";
-import { PropertyPath } from "./PropertyPath.js";
+import type { OntologyLike } from "./OntologyLike.js";
+import type { PropertyPath } from "./PropertyPath.js";
 import { Shape } from "./Shape.js";
 import type { ShapesGraph } from "./ShapesGraph.js";
-export declare class PropertyShape extends Shape {
-    private readonly shapesGraph;
-    readonly constraints: Shape.Constraints;
-    constructor(resource: Resource, shapesGraph: ShapesGraph);
+import type * as generated from "./generated.js";
+export declare class PropertyShape<NodeShapeT extends ShapeT, OntologyT extends OntologyLike, PropertyGroupT, PropertyShapeT extends ShapeT, ShapeT> extends Shape<NodeShapeT, OntologyT, PropertyGroupT, PropertyShapeT, ShapeT> {
+    private readonly generatedShaclCorePropertyShape;
+    readonly constraints: Shape.Constraints<NodeShapeT, OntologyT, PropertyGroupT, PropertyShapeT, ShapeT>;
+    constructor(generatedShaclCorePropertyShape: Omit<generated.ShaclCorePropertyShape, "type">, shapesGraph: ShapesGraph<NodeShapeT, OntologyT, PropertyGroupT, PropertyShapeT, ShapeT>);
     get defaultValue(): Maybe<BlankNode | Literal | NamedNode>;
-    get editor(): Maybe<NamedNode>;
-    get group(): Maybe<PropertyGroup>;
+    get descriptions(): readonly Literal[];
+    get groups(): readonly PropertyGroupT[];
+    get names(): readonly Literal[];
     get order(): Maybe<number>;
     get path(): PropertyPath;
-    get singleLine(): Maybe<boolean>;
-    get viewer(): Maybe<NamedNode>;
     toString(): string;
 }
 //# sourceMappingURL=PropertyShape.d.ts.map

package/PropertyShape.js

@@ -1,58 +1,30 @@
-import { dash, sh } from "@tpluscode/rdf-ns-builders";
-import { PropertyPath } from "./PropertyPath.js";
 import { Shape } from "./Shape.js";
 export class PropertyShape extends Shape {
-    constructor(resource, shapesGraph) {
-        super(resource);
-        this.shapesGraph = shapesGraph;
-        this.constraints = new PropertyShape.Constraints(resource, shapesGraph);
+    constructor(generatedShaclCorePropertyShape, shapesGraph) {
+        super(generatedShaclCorePropertyShape, shapesGraph);
+        this.generatedShaclCorePropertyShape = generatedShaclCorePropertyShape;
+        this.constraints = new Shape.Constraints(generatedShaclCorePropertyShape, shapesGraph);
     }
     get defaultValue() {
-        return this.resource
-            .value(sh.defaultValue)
-            .map((value) => value.toTerm())
-            .toMaybe();
-    }
-    get editor() {
-        return this.resource
-            .value(dash.editor)
-            .chain((value) => value.toIri())
-            .toMaybe();
-    }
-    get group() {
-        return this.resource
-            .value(sh.group)
-            .chain((value) => value.toIri())
-            .toMaybe()
-            .chain((node) => this.shapesGraph.propertyGroupByNode(node));
+        return this.generatedShaclCorePropertyShape.defaultValue;
+    }
+    get descriptions() {
+        return this.generatedShaclCorePropertyShape.descriptions;
+    }
+    get groups() {
+        return this.generatedShaclCorePropertyShape.groups.flatMap((identifier) => this.shapesGraph.propertyGroupByIdentifier(identifier).toList());
+    }
+    get names() {
+        return this.generatedShaclCorePropertyShape.names;
     }
     get order() {
-        return this.resource
-            .value(sh.maxCount)
-            .chain((value) => value.toNumber())
-            .toMaybe();
+        return this.generatedShaclCorePropertyShape.order;
     }
     get path() {
-        return this.resource
-            .value(sh.path)
-            .chain((value) => value.toResource())
-            .chain(PropertyPath.fromResource)
-            .unsafeCoerce();
-    }
-    get singleLine() {
-        return this.resource
-            .value(dash.singleLine)
-            .chain((value) => value.toBoolean())
-            .toMaybe();
-    }
-    get viewer() {
-        return this.resource
-            .value(dash.viewer)
-            .chain((value) => value.toIri())
-            .toMaybe();
+        return this.generatedShaclCorePropertyShape.path;
     }
     toString() {
-        const keyValues = [`node=${this.resource.identifier.value}`];
+        const keyValues = [`node=${this.identifier.value}`];
         const path = this.path;
         if (path.kind === "PredicatePath") {
             keyValues.push(`path=${path.iri.value}`);

package/RdfjsShapesGraph.d.ts

@@ -0,0 +1,31 @@
+import type { BlankNode, DatasetCore, DefaultGraph, NamedNode } from "@rdfjs/types";
+import { Maybe } from "purify-ts";
+import type { Factory } from "./Factory.js";
+import type { OntologyLike } from "./OntologyLike.js";
+export declare class RdfjsShapesGraph<NodeShapeT extends ShapeT, OntologyT extends OntologyLike, PropertyGroupT, PropertyShapeT extends ShapeT, ShapeT> {
+    readonly dataset: DatasetCore;
+    readonly node: BlankNode | DefaultGraph | NamedNode | null;
+    readonly nodeShapes: readonly NodeShapeT[];
+    readonly ontologies: readonly OntologyT[];
+    readonly propertyGroups: readonly PropertyGroupT[];
+    readonly propertyShapes: readonly PropertyShapeT[];
+    private readonly nodeShapesByIdentifier;
+    private readonly ontologiesByIdentifier;
+    private readonly propertyGroupsByIdentifier;
+    private readonly propertyShapesByIdentifier;
+    private readonly resourceSet;
+    constructor({ dataset, factory, }: {
+        dataset: DatasetCore;
+        factory: Factory<NodeShapeT, OntologyT, PropertyGroupT, PropertyShapeT, ShapeT>;
+    });
+    nodeShapeByIdentifier(nodeShapeNode: BlankNode | NamedNode): Maybe<NodeShapeT>;
+    ontologyByIdentifier(identifier: BlankNode | NamedNode): Maybe<OntologyT>;
+    propertyGroupByIdentifier(identifier: BlankNode | NamedNode): Maybe<PropertyGroupT>;
+    propertyShapeByIdentifier(identifier: BlankNode | NamedNode): Maybe<PropertyShapeT>;
+    shapeByIdentifier(identifier: BlankNode | NamedNode): Maybe<ShapeT>;
+    private readGraph;
+    private readOntologies;
+    private readPropertyGroups;
+    private readShapes;
+}
+//# sourceMappingURL=RdfjsShapesGraph.d.ts.map