@shaclmate/compiler 2.0.22 → 2.0.23

package/dist/input/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,12 @@ export interface ZeroOrOnePath {
 }
 export type PropertyPath = AlternativePath | InversePath | OneOrMorePath | PredicatePath | SequencePath | ZeroOrMorePath | ZeroOrOnePath;
 export declare namespace PropertyPath {
-    function fromRdf({ resource, }: {
+    function $fromRdf({ resource, }: {
         [_index: string]: any;
         ignoreRdfType?: boolean;
         languageIn?: readonly string[];
-        resource: rdfjsResource.Resource;
-    }): purify.Either<rdfjsResource.Resource.ValueError, PropertyPath>;
+        resource: Resource;
+    }): Either<Error, PropertyPath>;
+    function $toRdf(_propertyPath: PropertyPath, _options?: any): Resource;
 }
 //# sourceMappingURL=PropertyPath.d.ts.map

package/dist/input/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,13 +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({
+                    const member = PropertyPath.$fromRdf({
                         resource: memberResource.unsafeCoerce(),
                     });
                     if (member.isLeft()) {
@@ -39,11 +35,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 +52,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({ resource: 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({ resource: objectResource }).map((path) => ({
                     kind: "OneOrMorePath",
                     path,
                 }));
@@ -82,24 +74,24 @@ export var PropertyPath;
             }
             // Zero or more path
             if (quad.predicate.equals(sh.zeroOrMorePath)) {
-                return PropertyPath.fromRdf({ resource: objectResource }).map((path) => ({
+                return PropertyPath.$fromRdf({ resource: objectResource }).map((path) => ({
                     kind: "ZeroOrMorePath",
                     path,
                 }));
             }
             if (quad.predicate.equals(sh.zeroOrOnePath)) {
-                return PropertyPath.fromRdf({ resource: objectResource }).map((path) => ({
+                return PropertyPath.$fromRdf({ resource: 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/input/PropertyShape.d.ts

@@ -7,9 +7,11 @@ import type { NodeShape, Ontology, PropertyGroup, ShapesGraph } from "./index.js
 export declare class PropertyShape extends ShaclCorePropertyShape<NodeShape, Ontology, PropertyGroup, any, Shape> {
     private readonly generatedShaclmatePropertyShape;
     constructor(generatedShaclmatePropertyShape: generated.ShaclmatePropertyShape, shapesGraph: ShapesGraph);
-    get extern(): Maybe<boolean>;
+    get lazy(): Maybe<boolean>;
     get mutable(): Maybe<boolean>;
     get shaclmateName(): Maybe<string>;
+    get stub(): Maybe<NodeShape>;
     get visibility(): PropertyVisibility;
+    get widen(): Maybe<boolean>;
 }
 //# sourceMappingURL=PropertyShape.d.ts.map

package/dist/input/PropertyShape.js

@@ -6,8 +6,8 @@ export class PropertyShape extends ShaclCorePropertyShape {
         super({ ...generatedShaclmatePropertyShape, uniqueLang: Maybe.empty() }, shapesGraph);
         this.generatedShaclmatePropertyShape = generatedShaclmatePropertyShape;
     }
-    get extern() {
-        return this.generatedShaclmatePropertyShape.extern;
+    get lazy() {
+        return this.generatedShaclmatePropertyShape.lazy;
     }
     get mutable() {
         return this.generatedShaclmatePropertyShape.mutable;
@@ -15,6 +15,9 @@ export class PropertyShape extends ShaclCorePropertyShape {
     get shaclmateName() {
         return this.generatedShaclmatePropertyShape.name;
     }
+    get stub() {
+        return this.generatedShaclmatePropertyShape.stub.chain((identifier) => this.shapesGraph.nodeShapeByIdentifier(identifier));
+    }
     get visibility() {
         return this.generatedShaclmatePropertyShape.visibility
             .map((iri) => {
@@ -31,5 +34,8 @@ export class PropertyShape extends ShaclCorePropertyShape {
         })
             .orDefault("public");
     }
+    get widen() {
+        return this.generatedShaclmatePropertyShape.widen;
+    }
 }
 //# sourceMappingURL=PropertyShape.js.map

package/dist/input/ShapesGraph.js

@@ -10,7 +10,7 @@ export class ShapesGraph extends RdfjsShapesGraph {
             dataset,
             factory: {
                 nodeShapeFromRdf({ resource, shapesGraph, }) {
-                    return generated.ShaclmateNodeShape.fromRdf({
+                    return generated.ShaclmateNodeShape.$fromRdf({
                         ignoreRdfType: true,
                         resource,
                     }).map((generatedShape) => new NodeShape({
@@ -26,19 +26,19 @@ export class ShapesGraph extends RdfjsShapesGraph {
                     }));
                 },
                 ontologyFromRdf({ resource, }) {
-                    return generated.ShaclmateOntology.fromRdf({
+                    return generated.ShaclmateOntology.$fromRdf({
                         ignoreRdfType: true,
                         resource,
                     }).map((generatedOntology) => new Ontology(generatedOntology));
                 },
                 propertyGroupFromRdf({ resource, }) {
-                    return generated.ShaclCorePropertyGroup.fromRdf({
+                    return generated.ShaclCorePropertyGroup.$fromRdf({
                         ignoreRdfType: true,
                         resource,
                     }).map((generatedPropertyGroup) => new PropertyGroup(generatedPropertyGroup));
                 },
                 propertyShapeFromRdf({ resource, shapesGraph, }) {
-                    return generated.ShaclmatePropertyShape.fromRdf({
+                    return generated.ShaclmatePropertyShape.$fromRdf({
                         ignoreRdfType: true,
                         resource,
                     }).map((generatedShape) => new PropertyShape(generatedShape, shapesGraph));