@shaclmate/compiler 2.0.22 → 2.0.24

package/dist/input/NodeShape.js

@@ -1,14 +1,14 @@
-import { NodeShape as ShaclCoreNodeShape } from "@shaclmate/shacl-ast";
+import { NodeShape as ShaclCoreNodeShape, } from "@shaclmate/shacl-ast";
 import { Maybe } from "purify-ts";
 import { tsFeatures } from "./tsFeatures.js";
 export class NodeShape extends ShaclCoreNodeShape {
-    isClass;
-    isList;
     ancestorClassIris;
     childClassIris;
     descendantClassIris;
     generatedShaclmateNodeShape;
     parentClassIris;
+    isClass;
+    isList;
     constructor({ ancestorClassIris, childClassIris, descendantClassIris, generatedShaclmateNodeShape, isClass, isList, parentClassIris, shapesGraph, }) {
         super(generatedShaclmateNodeShape, shapesGraph);
         this.ancestorClassIris = ancestorClassIris;
@@ -44,19 +44,7 @@ export class NodeShape extends ShaclCoreNodeShape {
         return this.generatedShaclmateNodeShape.extern;
     }
     get fromRdfType() {
-        // Check for an explicit shaclmate:fromRdfType
-        const fromRdfType = this.generatedShaclmateNodeShape.fromRdfType;
-        if (fromRdfType.isJust()) {
-            return fromRdfType;
-        }
-        // No explicit shaclmate:fromRdfType
-        // If the shape is a class, not abstract, and identified by an IRI then use the shape IRI as the fromRdfType.
-        if (!this.abstract.orDefault(false) &&
-            this.isClass &&
-            this.identifier.termType === "NamedNode") {
-            return Maybe.of(this.identifier);
-        }
-        return Maybe.empty();
+        return this.generatedShaclmateNodeShape.fromRdfType;
     }
     get identifierMintingStrategy() {
         const thisMintingStrategy = this._mintingStrategy;
@@ -106,28 +94,26 @@ export class NodeShape extends ShaclCoreNodeShape {
             ? this.parentClassIris.flatMap((classIri) => this.shapesGraph.nodeShapeByIdentifier(classIri).toList())
             : [];
     }
+    get rdfType() {
+        // Check for an explicit shaclmate:rdfType
+        const rdfType = this.generatedShaclmateNodeShape.rdfType;
+        if (rdfType.isJust()) {
+            return rdfType;
+        }
+        // No explicit shaclmate:rdfType
+        // If the shape is a class, not abstract, and identified by an IRI then use the shape IRI as the fromRdfType.
+        if (!this.abstract.orDefault(false) &&
+            this.isClass &&
+            this.identifier.termType === "NamedNode") {
+            return Maybe.of(this.identifier);
+        }
+        return Maybe.empty();
+    }
     get shaclmateName() {
         return this.generatedShaclmateNodeShape.name;
     }
     get toRdfTypes() {
-        // Look for one or more explicit shaclmate:toRdfType's
-        const toRdfTypes = this.generatedShaclmateNodeShape.toRdfTypes.concat();
-        // Ensure the toRdfTypes includes the fromRdfType if there is one
-        this.fromRdfType.ifJust((fromRdfType) => {
-            if (!toRdfTypes.some((toRdfType) => toRdfType.equals(fromRdfType))) {
-                toRdfTypes.push(fromRdfType);
-            }
-        });
-        if (toRdfTypes.length === 0) {
-            // No explicit shaclmate:toRdfType's
-            // If the shape is a class, not abstract, and identified by an IRI then use the shape IRI as the fromRdfType.
-            if (!this.abstract.orDefault(false) &&
-                this.isClass &&
-                this.identifier.termType === "NamedNode") {
-                toRdfTypes.push(this.identifier);
-            }
-        }
-        return toRdfTypes;
+        return this.generatedShaclmateNodeShape.toRdfTypes;
     }
     get tsFeatures() {
         return tsFeatures(this.generatedShaclmateNodeShape).altLazy(() => this.isDefinedBy.chain((ontology) => ontology.tsFeatures));
@@ -149,16 +135,6 @@ export class NodeShape extends ShaclCoreNodeShape {
         })
             .altLazy(() => this.isDefinedBy.chain((ontology) => ontology.tsObjectDeclarationType));
     }
-    get tsObjectIdentifierPrefixPropertyName() {
-        return this.generatedShaclmateNodeShape.tsObjectIdentifierPrefixPropertyName.altLazy(() => this.isDefinedBy.chain((ontology) => ontology.tsObjectIdentifierPrefixPropertyName));
-    }
-    get tsObjectIdentifierPropertyName() {
-        return this.generatedShaclmateNodeShape.tsObjectIdentifierPrefixPropertyName.altLazy(() => this.isDefinedBy.chain((ontology) => ontology.tsObjectIdentifierPropertyName));
-    }
-    get tsObjectTypeDiscriminatorPropertyName() {
-        return this.generatedShaclmateNodeShape
-            .tsObjectTypeDiscriminatorPropertyName;
-    }
     get _mintingStrategy() {
         return this.generatedShaclmateNodeShape.identifierMintingStrategy.map((iri) => {
             switch (iri.value) {

package/dist/input/Ontology.d.ts

@@ -5,11 +5,8 @@ import type * as generated from "./generated.js";
 export declare class Ontology extends OwlOntology {
     private readonly generatedShaclmateOntology;
     constructor(generatedShaclmateOntology: generated.ShaclmateOntology);
-    get tsDataFactoryVariable(): Maybe<string>;
     get tsFeatures(): Maybe<Set<TsFeature>>;
     get tsImports(): readonly string[];
     get tsObjectDeclarationType(): Maybe<TsObjectDeclarationType>;
-    get tsObjectIdentifierPrefixPropertyName(): Maybe<string>;
-    get tsObjectIdentifierPropertyName(): Maybe<string>;
 }
 //# sourceMappingURL=Ontology.d.ts.map

package/dist/input/Ontology.js

@@ -6,9 +6,6 @@ export class Ontology extends OwlOntology {
         super(generatedShaclmateOntology);
         this.generatedShaclmateOntology = generatedShaclmateOntology;
     }
-    get tsDataFactoryVariable() {
-        return this.generatedShaclmateOntology.tsDataFactoryVariable;
-    }
     get tsFeatures() {
         return tsFeatures(this.generatedShaclmateOntology);
     }
@@ -27,11 +24,5 @@ export class Ontology extends OwlOntology {
             }
         });
     }
-    get tsObjectIdentifierPrefixPropertyName() {
-        return this.generatedShaclmateOntology.tsObjectIdentifierPrefixPropertyName;
-    }
-    get tsObjectIdentifierPropertyName() {
-        return this.generatedShaclmateOntology.tsObjectIdentifierPropertyName;
-    }
 }
 //# sourceMappingURL=Ontology.js.map

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,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/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,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/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,9 +10,8 @@ export class ShapesGraph extends RdfjsShapesGraph {
             dataset,
             factory: {
                 nodeShapeFromRdf({ resource, shapesGraph, }) {
-                    return generated.ShaclmateNodeShape.fromRdf({
+                    return generated.ShaclmateNodeShape.$fromRdf(resource, {
                         ignoreRdfType: true,
-                        resource,
                     }).map((generatedShape) => new NodeShape({
                         ancestorClassIris: ancestorClassIris(resource, Number.MAX_SAFE_INTEGER),
                         childClassIris: descendantClassIris(resource, 1),
@@ -26,21 +25,18 @@ export class ShapesGraph extends RdfjsShapesGraph {
                     }));
                 },
                 ontologyFromRdf({ resource, }) {
-                    return generated.ShaclmateOntology.fromRdf({
+                    return generated.ShaclmateOntology.$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((generatedPropertyGroup) => new PropertyGroup(generatedPropertyGroup));
                 },
                 propertyShapeFromRdf({ resource, shapesGraph, }) {
-                    return generated.ShaclmatePropertyShape.fromRdf({
+                    return generated.ShaclmatePropertyShape.$fromRdf(resource, {
                         ignoreRdfType: true,
-                        resource,
                     }).map((generatedShape) => new PropertyShape(generatedShape, shapesGraph));
                 },
             },