@shaclmate/shacl-ast 4.0.6 → 4.0.8

package/dist/NodeShape.d.ts

@@ -5,13 +5,13 @@ import { Shape } from "./Shape.js";
 import type { ShapesGraph } from "./ShapesGraph.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>);
+    constructor(generatedNodeShape: Omit<generated.NodeShape, "$type">, shapesGraph: ShapesGraph<NodeShapeT, OntologyT, PropertyGroupT, PropertyShapeT, ShapeT>);
     toString(): string;
 }
 export declare namespace NodeShape {
     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>);
+        private readonly generatedNodeShape;
+        constructor(generatedNodeShape: Omit<generated.NodeShape, "$type">, shapesGraph: ShapesGraph<NodeShapeT, OntologyT, PropertyGroupT, PropertyShapeT, ShapeT>);
         get closed(): Maybe<boolean>;
         get properties(): Either<Error, readonly PropertyShapeT[]>;
     }

package/dist/NodeShape.js

@@ -10,9 +10,9 @@ import { Memoize } from "typescript-memoize";
 import { Shape } from "./Shape.js";
 export class NodeShape extends Shape {
     constraints;
-    constructor(generatedShaclCoreNodeShape, shapesGraph) {
-        super(generatedShaclCoreNodeShape, shapesGraph);
-        this.constraints = new NodeShape.Constraints(generatedShaclCoreNodeShape, shapesGraph);
+    constructor(generatedNodeShape, shapesGraph) {
+        super(generatedNodeShape, shapesGraph);
+        this.constraints = new NodeShape.Constraints(generatedNodeShape, shapesGraph);
     }
     toString() {
         return `NodeShape(identifier=${Resource.Identifier.toString(this.identifier)})`;
@@ -23,16 +23,16 @@ __decorate([
 ], NodeShape.prototype, "toString", null);
 (function (NodeShape) {
     class Constraints extends Shape.Constraints {
-        generatedShaclCoreNodeShape;
-        constructor(generatedShaclCoreNodeShape, shapesGraph) {
-            super(generatedShaclCoreNodeShape, shapesGraph);
-            this.generatedShaclCoreNodeShape = generatedShaclCoreNodeShape;
+        generatedNodeShape;
+        constructor(generatedNodeShape, shapesGraph) {
+            super(generatedNodeShape, shapesGraph);
+            this.generatedNodeShape = generatedNodeShape;
         }
         get closed() {
-            return this.generatedShaclCoreNodeShape.closed;
+            return this.generatedNodeShape.closed;
         }
         get properties() {
-            return Either.sequence(this.generatedShaclCoreNodeShape.properties.map((identifier) => this.shapesGraph.propertyShapeByIdentifier(identifier)));
+            return Either.sequence(this.generatedNodeShape.properties.map((identifier) => this.shapesGraph.propertyShapeByIdentifier(identifier)));
         }
     }
     __decorate([

package/dist/Ontology.d.ts

@@ -3,7 +3,7 @@ import type * as generated from "./generated.js";
 import type { OntologyLike } from "./OntologyLike.js";
 export declare class Ontology implements OntologyLike {
     private readonly generatedOntology;
-    constructor(generatedOntology: Omit<generated.OwlOntology, "$type">);
+    constructor(generatedOntology: Omit<generated.Ontology, "$type">);
     get identifier(): BlankNode | NamedNode;
     toString(): string;
 }

package/dist/PropertyGroup.d.ts

@@ -2,7 +2,7 @@ import type { BlankNode, NamedNode } from "@rdfjs/types";
 import type * as generated from "./generated.js";
 export declare class PropertyGroup {
     private readonly delegate;
-    constructor(delegate: generated.ShaclCorePropertyGroup);
+    constructor(delegate: generated.PropertyGroup);
     get comments(): readonly string[];
     get identifier(): BlankNode | NamedNode;
     get labels(): readonly string[];

package/dist/PropertyShape.d.ts

@@ -6,9 +6,9 @@ import type { OntologyLike } from "./OntologyLike.js";
 import { Shape } from "./Shape.js";
 import type { ShapesGraph } from "./ShapesGraph.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;
+    private readonly generatedPropertyShape;
     readonly constraints: Shape.Constraints<NodeShapeT, OntologyT, PropertyGroupT, PropertyShapeT, ShapeT>;
-    constructor(generatedShaclCorePropertyShape: Omit<generated.ShaclCorePropertyShape, "$type">, shapesGraph: ShapesGraph<NodeShapeT, OntologyT, PropertyGroupT, PropertyShapeT, ShapeT>);
+    constructor(generatedPropertyShape: Omit<generated.PropertyShape, "$type">, shapesGraph: ShapesGraph<NodeShapeT, OntologyT, PropertyGroupT, PropertyShapeT, ShapeT>);
     get defaultValue(): Maybe<Literal | NamedNode>;
     get descriptions(): readonly string[];
     get groups(): Either<Error, readonly PropertyGroupT[]>;

package/dist/PropertyShape.js

@@ -9,30 +9,30 @@ import { PropertyPath, Resource } from "rdfjs-resource";
 import { Memoize } from "typescript-memoize";
 import { Shape } from "./Shape.js";
 export class PropertyShape extends Shape {
-    generatedShaclCorePropertyShape;
+    generatedPropertyShape;
     constraints;
-    constructor(generatedShaclCorePropertyShape, shapesGraph) {
-        super(generatedShaclCorePropertyShape, shapesGraph);
-        this.generatedShaclCorePropertyShape = generatedShaclCorePropertyShape;
-        this.constraints = new Shape.Constraints(generatedShaclCorePropertyShape, shapesGraph);
+    constructor(generatedPropertyShape, shapesGraph) {
+        super(generatedPropertyShape, shapesGraph);
+        this.generatedPropertyShape = generatedPropertyShape;
+        this.constraints = new Shape.Constraints(generatedPropertyShape, shapesGraph);
     }
     get defaultValue() {
-        return this.generatedShaclCorePropertyShape.defaultValue;
+        return this.generatedPropertyShape.defaultValue;
     }
     get descriptions() {
-        return this.generatedShaclCorePropertyShape.descriptions;
+        return this.generatedPropertyShape.descriptions;
     }
     get groups() {
-        return Either.sequence(this.generatedShaclCorePropertyShape.groups.map((identifier) => this.shapesGraph.propertyGroupByIdentifier(identifier)));
+        return Either.sequence(this.generatedPropertyShape.groups.map((identifier) => this.shapesGraph.propertyGroupByIdentifier(identifier)));
     }
     get names() {
-        return this.generatedShaclCorePropertyShape.names;
+        return this.generatedPropertyShape.names;
     }
     get order() {
-        return this.generatedShaclCorePropertyShape.order;
+        return this.generatedPropertyShape.order;
     }
     get path() {
-        return this.generatedShaclCorePropertyShape.path;
+        return this.generatedPropertyShape.path;
     }
     toString() {
         return `PropertyShape(${[

package/dist/Shape.d.ts

@@ -5,10 +5,10 @@ import type { NodeKind } from "./NodeKind.js";
 import type { OntologyLike } from "./OntologyLike.js";
 import type { ShapesGraph } from "./ShapesGraph.js";
 export declare abstract class Shape<NodeShapeT extends ShapeT, OntologyT extends OntologyLike, PropertyGroupT, PropertyShapeT extends ShapeT, ShapeT> {
-    private readonly generatedShaclCoreShape;
+    private readonly generatedShape;
     protected readonly shapesGraph: ShapesGraph<NodeShapeT, OntologyT, PropertyGroupT, PropertyShapeT, ShapeT>;
     abstract readonly constraints: Shape.Constraints<NodeShapeT, OntologyT, PropertyGroupT, PropertyShapeT, ShapeT>;
-    constructor(generatedShaclCoreShape: Omit<generated.ShaclCoreShape, "$type">, shapesGraph: ShapesGraph<NodeShapeT, OntologyT, PropertyGroupT, PropertyShapeT, ShapeT>);
+    constructor(generatedShape: Omit<generated.Shape, "$type">, shapesGraph: ShapesGraph<NodeShapeT, OntologyT, PropertyGroupT, PropertyShapeT, ShapeT>);
     get comments(): readonly string[];
     get identifier(): BlankNode | NamedNode;
     get isDefinedBy(): Either<Error, Maybe<OntologyT>>;
@@ -16,9 +16,9 @@ export declare abstract class Shape<NodeShapeT extends ShapeT, OntologyT extends
 }
 export declare namespace Shape {
     class Constraints<NodeShapeT extends ShapeT, OntologyT extends OntologyLike, PropertyGroupT, PropertyShapeT extends ShapeT, ShapeT> {
-        private readonly generatedShaclCoreShape;
+        private readonly generatedShape;
         protected readonly shapesGraph: ShapesGraph<NodeShapeT, OntologyT, PropertyGroupT, PropertyShapeT, ShapeT>;
-        constructor(generatedShaclCoreShape: Omit<generated.ShaclCoreShape, "$type">, shapesGraph: ShapesGraph<NodeShapeT, OntologyT, PropertyGroupT, PropertyShapeT, ShapeT>);
+        constructor(generatedShape: Omit<generated.Shape, "$type">, shapesGraph: ShapesGraph<NodeShapeT, OntologyT, PropertyGroupT, PropertyShapeT, ShapeT>);
         get and(): Either<Error, readonly ShapeT[]>;
         get classes(): readonly NamedNode[];
         get datatype(): Maybe<NamedNode>;

package/dist/Shape.js

@@ -7,23 +7,23 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 import { Either, Maybe } from "purify-ts";
 import { Memoize } from "typescript-memoize";
 export class Shape {
-    generatedShaclCoreShape;
+    generatedShape;
     shapesGraph;
-    constructor(generatedShaclCoreShape, shapesGraph) {
-        this.generatedShaclCoreShape = generatedShaclCoreShape;
+    constructor(generatedShape, shapesGraph) {
+        this.generatedShape = generatedShape;
         this.shapesGraph = shapesGraph;
     }
     get comments() {
-        return this.generatedShaclCoreShape.comments;
+        return this.generatedShape.comments;
     }
     get identifier() {
-        return this.generatedShaclCoreShape.$identifier;
+        return this.generatedShape.$identifier;
     }
     get isDefinedBy() {
-        if (this.generatedShaclCoreShape.isDefinedBy.isJust()) {
+        if (this.generatedShape.isDefinedBy.isJust()) {
             // If there's an rdfs:isDefinedBy statement on the shape then don't fall back to anything else
             return this.shapesGraph
-                .ontologyByIdentifier(this.generatedShaclCoreShape.isDefinedBy.unsafeCoerce())
+                .ontologyByIdentifier(this.generatedShape.isDefinedBy.unsafeCoerce())
                 .map(Maybe.of);
         }
         // No rdfs:isDefinedBy statement on the shape
@@ -43,7 +43,7 @@ export class Shape {
         return Either.of(Maybe.empty());
     }
     get labels() {
-        return this.generatedShaclCoreShape.labels;
+        return this.generatedShape.labels;
     }
 }
 __decorate([
@@ -51,50 +51,50 @@ __decorate([
 ], Shape.prototype, "isDefinedBy", null);
 (function (Shape) {
     class Constraints {
-        generatedShaclCoreShape;
+        generatedShape;
         shapesGraph;
-        constructor(generatedShaclCoreShape, shapesGraph) {
-            this.generatedShaclCoreShape = generatedShaclCoreShape;
+        constructor(generatedShape, shapesGraph) {
+            this.generatedShape = generatedShape;
             this.shapesGraph = shapesGraph;
         }
         get and() {
-            return this.shapeListTakingConstraint(this.generatedShaclCoreShape.and);
+            return this.shapeListTakingConstraint(this.generatedShape.and);
         }
         get classes() {
-            return this.generatedShaclCoreShape.classes;
+            return this.generatedShape.classes;
         }
         get datatype() {
-            return this.generatedShaclCoreShape.datatype;
+            return this.generatedShape.datatype;
         }
         get hasValues() {
-            return this.generatedShaclCoreShape.hasValues;
+            return this.generatedShape.hasValues;
         }
         get in_() {
-            return this.generatedShaclCoreShape.in_.orDefault([]);
+            return this.generatedShape.in_.orDefault([]);
         }
         get languageIn() {
-            return this.generatedShaclCoreShape.languageIn.orDefault([]);
+            return this.generatedShape.languageIn.orDefault([]);
         }
         get maxCount() {
-            return this.generatedShaclCoreShape.maxCount;
+            return this.generatedShape.maxCount;
         }
         get maxExclusive() {
-            return this.generatedShaclCoreShape.maxExclusive;
+            return this.generatedShape.maxExclusive;
         }
         get maxInclusive() {
-            return this.generatedShaclCoreShape.maxInclusive;
+            return this.generatedShape.maxInclusive;
         }
         get minCount() {
-            return this.generatedShaclCoreShape.minCount;
+            return this.generatedShape.minCount;
         }
         get minExclusive() {
-            return this.generatedShaclCoreShape.minExclusive;
+            return this.generatedShape.minExclusive;
         }
         get minInclusive() {
-            return this.generatedShaclCoreShape.minInclusive;
+            return this.generatedShape.minInclusive;
         }
         get nodeKinds() {
-            return this.generatedShaclCoreShape.nodeKind
+            return this.generatedShape.nodeKind
                 .map((iri) => {
                 const nodeKinds = new Set();
                 switch (iri.value) {
@@ -125,16 +125,16 @@ __decorate([
                 .orDefault(new Set([]));
         }
         get nodes() {
-            return Either.sequence(this.generatedShaclCoreShape.nodes.map((identifier) => this.shapesGraph.nodeShapeByIdentifier(identifier)));
+            return Either.sequence(this.generatedShape.nodes.map((identifier) => this.shapesGraph.nodeShapeByIdentifier(identifier)));
         }
         get not() {
-            return Either.sequence(this.generatedShaclCoreShape.not.map((identifier) => this.shapesGraph.shapeByIdentifier(identifier)));
+            return Either.sequence(this.generatedShape.not.map((identifier) => this.shapesGraph.shapeByIdentifier(identifier)));
         }
         get or() {
-            return this.shapeListTakingConstraint(this.generatedShaclCoreShape.or);
+            return this.shapeListTakingConstraint(this.generatedShape.or);
         }
         get xone() {
-            return this.shapeListTakingConstraint(this.generatedShaclCoreShape.xone);
+            return this.shapeListTakingConstraint(this.generatedShape.xone);
         }
         shapeListTakingConstraint(identifiers) {
             return Either.sequence(identifiers.flatMap((identifiers) => identifiers.map((identifier) => this.shapesGraph.shapeByIdentifier(identifier))));

package/dist/ShapesGraph.js

@@ -279,25 +279,25 @@ __decorate([
     ShapesGraph.Factory = Factory;
     class DefaultFactory extends Factory {
         createNodeShape({ resource, shapesGraph, }) {
-            return generated.ShaclCoreNodeShape.$fromRdf(resource, {
+            return generated.NodeShape.$fromRdf(resource, {
                 ignoreRdfType: true,
                 preferredLanguages: this.preferredLanguages,
             }).map((generatedShape) => new NodeShape(generatedShape, shapesGraph));
         }
         createOntology({ resource, }) {
-            return generated.OwlOntology.$fromRdf(resource, {
+            return generated.Ontology.$fromRdf(resource, {
                 ignoreRdfType: true,
                 preferredLanguages: this.preferredLanguages,
             }).map((generatedOntology) => new Ontology(generatedOntology));
         }
         createPropertyGroup({ resource, }) {
-            return generated.ShaclCorePropertyGroup.$fromRdf(resource, {
+            return generated.PropertyGroup.$fromRdf(resource, {
                 ignoreRdfType: true,
                 preferredLanguages: this.preferredLanguages,
             }).map((propertyGroup) => new PropertyGroup(propertyGroup));
         }
         createPropertyShape({ resource, shapesGraph, }) {
-            return generated.ShaclCorePropertyShape.$fromRdf(resource, {
+            return generated.PropertyShape.$fromRdf(resource, {
                 ignoreRdfType: true,
                 preferredLanguages: this.preferredLanguages,
             }).map((generatedShape) => new PropertyShape(generatedShape, shapesGraph));