@shaclmate/shacl-ast 2.0.22 → 2.0.24

package/dist/IdentifierNodeKind.d.ts

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

package/dist/IdentifierNodeKind.js

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

package/dist/NodeShape.d.ts

@@ -5,13 +5,13 @@ import type { ShapesGraph } from "./ShapesGraph.js";
 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>);
+    constructor(generatedShaclCoreNodeShape: Omit<generated.ShaclCoreNodeShape, "$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>);
+        constructor(generatedShaclCoreNodeShape: Omit<generated.ShaclCoreNodeShape, "$type">, shapesGraph: ShapesGraph<NodeShapeT, OntologyT, PropertyGroupT, PropertyShapeT, ShapeT>);
         get closed(): Maybe<boolean>;
         get properties(): readonly PropertyShapeT[];
     }

package/dist/Ontology.d.ts

@@ -3,7 +3,7 @@ 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">);
+    constructor(generatedOntology: Omit<generated.OwlOntology, "$type">);
     get identifier(): BlankNode | NamedNode;
     toString(): string;
 }

package/dist/Ontology.js

@@ -4,7 +4,7 @@ export class Ontology {
         this.generatedOntology = generatedOntology;
     }
     get identifier() {
-        return this.generatedOntology.identifier;
+        return this.generatedOntology.$identifier;
     }
     toString() {
         return `Ontology(node=${this.identifier.value})`;

package/dist/PropertyGroup.js

@@ -7,7 +7,7 @@ export class PropertyGroup {
         return this.delegate.comments;
     }
     get identifier() {
-        return this.delegate.identifier;
+        return this.delegate.$identifier;
     }
     get labels() {
         return this.delegate.labels;

package/dist/PropertyPath.d.ts

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

package/dist/PropertyPath.js

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

package/dist/PropertyShape.d.ts

@@ -1,4 +1,4 @@
-import type { BlankNode, Literal, NamedNode } from "@rdfjs/types";
+import type { Literal, NamedNode } from "@rdfjs/types";
 import type { Maybe } from "purify-ts";
 import type { OntologyLike } from "./OntologyLike.js";
 import type { PropertyPath } from "./PropertyPath.js";
@@ -8,8 +8,8 @@ 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>;
+    constructor(generatedShaclCorePropertyShape: Omit<generated.ShaclCorePropertyShape, "$type">, shapesGraph: ShapesGraph<NodeShapeT, OntologyT, PropertyGroupT, PropertyShapeT, ShapeT>);
+    get defaultValue(): Maybe<Literal | NamedNode>;
     get descriptions(): readonly Literal[];
     get groups(): readonly PropertyGroupT[];
     get names(): readonly Literal[];

package/dist/Shape.d.ts

@@ -8,7 +8,7 @@ export declare abstract class Shape<NodeShapeT extends ShapeT, OntologyT extends
     private readonly generatedShaclCoreShape;
     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(generatedShaclCoreShape: Omit<generated.ShaclCoreShape, "$type">, shapesGraph: ShapesGraph<NodeShapeT, OntologyT, PropertyGroupT, PropertyShapeT, ShapeT>);
     get comments(): readonly Literal[];
     get identifier(): BlankNode | NamedNode;
     get isDefinedBy(): Maybe<OntologyT>;
@@ -18,12 +18,12 @@ export declare namespace Shape {
     class Constraints<NodeShapeT extends ShapeT, OntologyT extends OntologyLike, PropertyGroupT, PropertyShapeT extends ShapeT, ShapeT> {
         private readonly generatedShaclCoreShape;
         protected readonly shapesGraph: ShapesGraph<NodeShapeT, OntologyT, PropertyGroupT, PropertyShapeT, ShapeT>;
-        constructor(generatedShaclCoreShape: Omit<generated.ShaclCoreShape, "type">, shapesGraph: ShapesGraph<NodeShapeT, OntologyT, PropertyGroupT, PropertyShapeT, ShapeT>);
+        constructor(generatedShaclCoreShape: Omit<generated.ShaclCoreShape, "$type">, shapesGraph: ShapesGraph<NodeShapeT, OntologyT, PropertyGroupT, PropertyShapeT, ShapeT>);
         get and(): readonly ShapeT[];
         get classes(): readonly NamedNode[];
         get datatype(): Maybe<NamedNode>;
-        get hasValues(): readonly (BlankNode | Literal | NamedNode)[];
-        get in_(): readonly (BlankNode | Literal | NamedNode)[];
+        get hasValues(): readonly (Literal | NamedNode)[];
+        get in_(): readonly (Literal | NamedNode)[];
         get languageIn(): readonly string[];
         get maxCount(): Maybe<number>;
         get maxExclusive(): Maybe<Literal>;

package/dist/Shape.js

@@ -10,7 +10,7 @@ export class Shape {
         return this.generatedShaclCoreShape.comments;
     }
     get identifier() {
-        return this.generatedShaclCoreShape.identifier;
+        return this.generatedShaclCoreShape.$identifier;
     }
     get isDefinedBy() {
         if (this.generatedShaclCoreShape.isDefinedBy.isJust()) {

package/dist/defaultFactory.js

@@ -5,27 +5,23 @@ import { PropertyShape } from "./PropertyShape.js";
 import * as generated from "./generated.js";
 export const defaultFactory = {
     nodeShapeFromRdf({ resource, shapesGraph, }) {
-        return generated.ShaclCoreNodeShape.fromRdf({
+        return generated.ShaclCoreNodeShape.$fromRdf(resource, {
             ignoreRdfType: true,
-            resource,
         }).map((generatedShape) => new NodeShape(generatedShape, shapesGraph));
     },
     ontologyFromRdf({ resource, }) {
-        return generated.OwlOntology.fromRdf({
+        return generated.OwlOntology.$fromRdf(resource, {
             ignoreRdfType: true,
-            resource,
         }).map((generatedOntology) => new Ontology(generatedOntology));
     },
     propertyGroupFromRdf({ resource, }) {
-        return generated.ShaclCorePropertyGroup.fromRdf({
+        return generated.ShaclCorePropertyGroup.$fromRdf(resource, {
             ignoreRdfType: true,
-            resource,
         }).map((propertyGroup) => new PropertyGroup(propertyGroup));
     },
     propertyShapeFromRdf({ resource, shapesGraph, }) {
-        return generated.ShaclCorePropertyShape.fromRdf({
+        return generated.ShaclCorePropertyShape.$fromRdf(resource, {
             ignoreRdfType: true,
-            resource,
         }).map((generatedShape) => new PropertyShape(generatedShape, shapesGraph));
     },
 };