@shaclmate/compiler 3.0.3 → 4.0.0

package/dist/generators/ts/synthesizeUberObjectUnionType.js

@@ -0,0 +1,59 @@
+import { Maybe } from "purify-ts";
+import { BlankNodeType } from "./BlankNodeType.js";
+import { IdentifierType } from "./IdentifierType.js";
+import { IriType } from "./IriType.js";
+import { ObjectUnionType } from "./ObjectUnionType.js";
+import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
+/**
+ * Synthesize the $Object union.
+ */
+export function synthesizeUberObjectUnionType(parameters) {
+    const objectTypes = parameters.objectTypes.filter((objectType) => !objectType.extern);
+    const nodeKinds = objectTypes.reduce((nodeKinds, objectType) => {
+        for (const nodeKind of objectType.identifierType.nodeKinds) {
+            nodeKinds.add(nodeKind);
+        }
+        return nodeKinds;
+    }, new Set());
+    let identifierType;
+    if (nodeKinds.size === 2) {
+        identifierType = new IdentifierType({
+            comment: Maybe.empty(),
+            label: Maybe.empty(),
+        });
+    }
+    else {
+        switch ([...nodeKinds][0]) {
+            case "BlankNode":
+                identifierType = new BlankNodeType({
+                    comment: Maybe.empty(),
+                    label: Maybe.empty(),
+                });
+                break;
+            case "IRI":
+                identifierType = new IriType({
+                    comment: Maybe.empty(),
+                    hasValues: [],
+                    in_: [],
+                    label: Maybe.empty(),
+                });
+                break;
+        }
+    }
+    return new ObjectUnionType({
+        comment: Maybe.empty(),
+        export_: true,
+        features: objectTypes.reduce((features, objectType) => {
+            for (const feature of objectType.features) {
+                features.add(feature);
+            }
+            features.delete("graphql");
+            return features;
+        }, new Set()),
+        identifierType,
+        label: Maybe.empty(),
+        memberTypes: objectTypes,
+        name: `${syntheticNamePrefix}Object`,
+    });
+}
+//# sourceMappingURL=synthesizeUberObjectUnionType.js.map

package/dist/generators/ts/ts-poet-wrapper.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Wrapper around ts-poet, enabled during debugging to throw errors on Code.toString.
+ */
+export * from "ts-poet";
+//# sourceMappingURL=ts-poet-wrapper.d.ts.map

package/dist/generators/ts/ts-poet-wrapper.js

@@ -0,0 +1,13 @@
+/**
+ * Wrapper around ts-poet, enabled during debugging to throw errors on Code.toString.
+ */
+export * from "ts-poet";
+import { Code } from "ts-poet";
+const originalCodeToString = Code.prototype.toString;
+Code.prototype.toString = function (opts) {
+    if (!opts) {
+        throw new Error("Code.toString should not be called without opts");
+    }
+    return originalCodeToString.call(this, opts);
+};
+//# sourceMappingURL=ts-poet-wrapper.js.map

package/dist/generators/ts/tsName.d.ts

@@ -1,3 +1,12 @@
-import type * as ast from "../../ast/index.js";
-export declare function tsName(astName: ast.Name): string;
+import type { BlankNode, NamedNode } from "@rdfjs/types";
+import type { Maybe } from "purify-ts";
+import { type PropertyPath } from "rdfjs-resource";
+import * as ast from "../../ast/index.js";
+export declare function tsName(astConstruct: {
+    label: Maybe<string>;
+    name: Maybe<string>;
+    path?: ast.Curie | PropertyPath;
+    synthetic?: boolean;
+    shapeIdentifier: BlankNode | NamedNode;
+}): string;
 //# sourceMappingURL=tsName.d.ts.map

package/dist/generators/ts/tsName.js

@@ -1,37 +1,34 @@
 import { Resource } from "rdfjs-resource";
+import * as ast from "../../ast/index.js";
 import { stringToValidTsIdentifier } from "./stringToValidTsIdentifier.js";
 import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
-function* tsNameAlternatives(astName) {
-    yield astName.shaclmateName.extract();
-    yield astName.shName.extract()?.replace(" ", "_");
-    yield astName.label.extract()?.replace(" ", "_");
-    yield astName.propertyPath
-        .chain((propertyPath) => propertyPath.uniqueLocalPart())
-        .extract();
-    yield astName.propertyPath
-        .chain((propertyPath) => propertyPath.curie.map((curie) => `${curie.prefix}_${curie.reference}`))
-        .extract();
-    if (astName.identifier.termType === "NamedNode") {
-        yield astName.identifier.uniqueLocalPart().extract();
-        yield astName.identifier.curie
-            .map((curie) => `${curie.prefix}_${curie.reference}`)
-            .extract();
+export function tsName(astConstruct) {
+    const name = astConstruct.name.extract();
+    if (name) {
+        if (astConstruct.synthetic) {
+            return `${syntheticNamePrefix}${name}`;
+        }
+        return stringToValidTsIdentifier(name);
     }
-    yield astName.propertyPath
-        .map((propertyPath) => Resource.Identifier.toString(propertyPath))
-        .extract();
-    yield Resource.Identifier.toString(astName.identifier);
-}
-export function tsName(astName) {
-    const syntheticName = astName.syntheticName.extract();
-    if (syntheticName) {
-        return `${syntheticNamePrefix}${syntheticName}`;
+    const label = astConstruct.label.extract();
+    if (label) {
+        return stringToValidTsIdentifier(label.replace(" ", "_"));
+    }
+    const path = astConstruct.path;
+    if (path instanceof ast.Curie) {
+        if (path.hasUniqueReference) {
+            return stringToValidTsIdentifier(path.reference);
+        }
+        return stringToValidTsIdentifier(`${path.prefix}_${path.reference}`);
     }
-    for (const tsNameAlternative of tsNameAlternatives(astName)) {
-        if (tsNameAlternative) {
-            return stringToValidTsIdentifier(tsNameAlternative);
+    const shapeIdentifier = astConstruct.shapeIdentifier;
+    if (shapeIdentifier.termType === "NamedNode" &&
+        shapeIdentifier instanceof ast.Curie) {
+        if (shapeIdentifier.hasUniqueReference) {
+            return stringToValidTsIdentifier(shapeIdentifier.reference);
         }
+        return stringToValidTsIdentifier(`${shapeIdentifier.prefix}_${shapeIdentifier.reference}`);
     }
-    throw new Error("should never reach this point");
+    throw new Error(`should never reach this point (shapeIdentifier=${Resource.Identifier.toString(shapeIdentifier)})`);
 }
 //# sourceMappingURL=tsName.js.map

package/dist/generators/ts/unsupportedObjectSetMethodDeclarations.d.ts

@@ -1,10 +1,11 @@
-import { type MethodDeclarationStructure } from "ts-morph";
 import type { ObjectType } from "./ObjectType.js";
+import { type Code } from "./ts-poet-wrapper.js";
 export declare function unsupportedObjectSetMethodDeclarations({ objectType, }: {
     objectType: {
-        readonly identifierTypeAlias: string;
+        readonly filterType: Code;
+        readonly identifierTypeAlias: Code;
         readonly objectSetMethodNames: ObjectType.ObjectSetMethodNames;
         readonly name: string;
     };
-}): readonly MethodDeclarationStructure[];
+}): Readonly<Record<keyof ObjectType.ObjectSetMethodNames, Code>>;
 //# sourceMappingURL=unsupportedObjectSetMethodDeclarations.d.ts.map

package/dist/generators/ts/unsupportedObjectSetMethodDeclarations.js

@@ -1,19 +1,22 @@
-import { StructureKind } from "ts-morph";
+import { imports } from "./imports.js";
 import { objectSetMethodSignatures } from "./objectSetMethodSignatures.js";
+import { code } from "./ts-poet-wrapper.js";
+function unsupportedObjectSetMethodDeclaration({ name, parameters, returnType, }) {
+    return code `\
+async ${name}(${parameters}): ${returnType} {
+  return ${imports.Left}(new Error("${name}: not supported")) satisfies Awaited<${returnType}>;
+}`;
+}
 export function unsupportedObjectSetMethodDeclarations({ objectType, }) {
-    return Object.entries(objectSetMethodSignatures({ objectType })).map(([methodName, methodSignature]) => ({
-        ...methodSignature,
-        kind: StructureKind.Method,
-        parameters: methodSignature.parameters
-            ? methodSignature.parameters.map((parameter) => ({
-                ...parameter,
-                name: `_${parameter.name}`,
-            }))
-            : methodSignature.parameters,
-        isAsync: true,
-        statements: methodName === "objects"
-            ? [`return [purify.Left(new Error("${methodName}: not supported"))];`]
-            : [`return purify.Left(new Error("${methodName}: not supported"));`],
-    }));
+    const methodSignatures = objectSetMethodSignatures({
+        objectType,
+        parameterNamePrefix: "_",
+    });
+    return {
+        object: unsupportedObjectSetMethodDeclaration(methodSignatures.object),
+        objectCount: unsupportedObjectSetMethodDeclaration(methodSignatures.objectCount),
+        objectIdentifiers: unsupportedObjectSetMethodDeclaration(methodSignatures.objectIdentifiers),
+        objects: unsupportedObjectSetMethodDeclaration(methodSignatures.objects),
+    };
 }
 //# sourceMappingURL=unsupportedObjectSetMethodDeclarations.js.map

package/dist/index.d.ts

@@ -1,3 +1,8 @@
+export * as ast from "./ast/index.js";
 export * from "./Compiler.js";
-export * as generators from "./generators/index.js";
+export type { Generator } from "./generators/Generator.js";
+export { AstJsonGenerator } from "./generators/json/AstJsonGenerator.js";
+export { TsGenerator } from "./generators/ts/TsGenerator.js";
+export * from "./input/ShapesGraph.js";
+export * from "./ShapesGraphToAstTransformer.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1,3 +1,7 @@
+export * as ast from "./ast/index.js";
 export * from "./Compiler.js";
-export * as generators from "./generators/index.js";
+export { AstJsonGenerator } from "./generators/json/AstJsonGenerator.js";
+export { TsGenerator } from "./generators/ts/TsGenerator.js";
+export * from "./input/ShapesGraph.js";
+export * from "./ShapesGraphToAstTransformer.js";
 //# sourceMappingURL=index.js.map

package/dist/input/NodeShape.d.ts

@@ -1,10 +1,10 @@
 import type { NamedNode } from "@rdfjs/types";
-import { type IdentifierNodeKind, NodeShape as ShaclCoreNodeShape } from "@shaclmate/shacl-ast";
-import { Maybe } from "purify-ts";
-import type * as generated from "./generated.js";
+import { NodeShape as ShaclCoreNodeShape } from "@shaclmate/shacl-ast";
+import { Either, type Maybe } from "purify-ts";
 import type { IdentifierMintingStrategy, TsFeature, TsObjectDeclarationType } from "../enums/index.js";
-import type { Shape } from "./Shape.js";
+import type * as generated from "./generated.js";
 import type { Ontology, PropertyGroup, PropertyShape, ShapesGraph } from "./index.js";
+import type { Shape } from "./Shape.js";
 export declare class NodeShape extends ShaclCoreNodeShape<any, Ontology, PropertyGroup, PropertyShape, Shape> {
     private readonly ancestorClassIris;
     private readonly childClassIris;
@@ -13,6 +13,7 @@ export declare class NodeShape extends ShaclCoreNodeShape<any, Ontology, Propert
     private readonly parentClassIris;
     readonly isClass: boolean;
     readonly isList: boolean;
+    readonly kind = "NodeShape";
     constructor({ ancestorClassIris, childClassIris, descendantClassIris, generatedShaclmateNodeShape, isClass, isList, parentClassIris, shapesGraph, }: {
         ancestorClassIris: readonly NamedNode[];
         generatedShaclmateNodeShape: generated.ShaclmateNodeShape;
@@ -24,22 +25,24 @@ export declare class NodeShape extends ShaclCoreNodeShape<any, Ontology, Propert
         shapesGraph: ShapesGraph;
     });
     get abstract(): Maybe<boolean>;
-    get ancestorNodeShapes(): readonly NodeShape[];
-    get childNodeShapes(): readonly NodeShape[];
-    get descendantNodeShapes(): readonly NodeShape[];
+    get ancestorNodeShapes(): Either<Error, readonly NodeShape[]>;
+    get childNodeShapes(): Either<Error, readonly NodeShape[]>;
+    get comment(): Maybe<string>;
+    get descendantNodeShapes(): Either<Error, readonly NodeShape[]>;
+    get discriminantValue(): Maybe<string>;
     get export(): Maybe<boolean>;
     get extern(): Maybe<boolean>;
     get fromRdfType(): Maybe<NamedNode>;
+    get identifierIn(): readonly NamedNode[];
     get identifierMintingStrategy(): Maybe<IdentifierMintingStrategy>;
+    get label(): Maybe<string>;
     get mutable(): Maybe<boolean>;
-    get nodeKinds(): Set<IdentifierNodeKind>;
-    get parentNodeShapes(): readonly NodeShape[];
+    get parentNodeShapes(): Either<Error, readonly NodeShape[]>;
     get rdfType(): Maybe<NamedNode>;
     get shaclmateName(): Maybe<string>;
     get toRdfTypes(): readonly NamedNode[];
-    get tsFeatures(): Maybe<Set<TsFeature>>;
+    get tsFeatures(): Maybe<ReadonlySet<TsFeature>>;
     get tsImports(): readonly string[];
     get tsObjectDeclarationType(): Maybe<TsObjectDeclarationType>;
-    private get _mintingStrategy();
 }
 //# sourceMappingURL=NodeShape.d.ts.map

package/dist/input/NodeShape.js

@@ -1,5 +1,14 @@
-import { NodeShape as ShaclCoreNodeShape, } from "@shaclmate/shacl-ast";
-import { Maybe } from "purify-ts";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { NodeShape as ShaclCoreNodeShape } from "@shaclmate/shacl-ast";
+import { rdf } from "@tpluscode/rdf-ns-builders";
+import { Either, List } from "purify-ts";
+import { invariant } from "ts-invariant";
+import { Memoize } from "typescript-memoize";
 import { tsFeatures } from "./tsFeatures.js";
 export class NodeShape extends ShaclCoreNodeShape {
     ancestorClassIris;
@@ -9,8 +18,16 @@ export class NodeShape extends ShaclCoreNodeShape {
     parentClassIris;
     isClass;
     isList;
+    kind = "NodeShape";
     constructor({ ancestorClassIris, childClassIris, descendantClassIris, generatedShaclmateNodeShape, isClass, isList, parentClassIris, shapesGraph, }) {
         super(generatedShaclmateNodeShape, shapesGraph);
+        if (ancestorClassIris.length > 0 ||
+            childClassIris.length > 0 ||
+            descendantClassIris.length > 0 ||
+            isList ||
+            parentClassIris.length > 0) {
+            invariant(isClass);
+        }
         this.ancestorClassIris = ancestorClassIris;
         this.childClassIris = childClassIris;
         this.descendantClassIris = descendantClassIris;
@@ -23,19 +40,21 @@ export class NodeShape extends ShaclCoreNodeShape {
         return this.generatedShaclmateNodeShape.abstract;
     }
     get ancestorNodeShapes() {
-        return this.isClass
-            ? this.ancestorClassIris.flatMap((classIri) => this.shapesGraph.nodeShapeByIdentifier(classIri).toList())
-            : [];
+        return Either.sequence(this.ancestorClassIris
+            .filter((classIri) => !classIri.equals(rdf.List))
+            .map((classIri) => this.shapesGraph.nodeShapeByIdentifier(classIri)));
     }
     get childNodeShapes() {
-        return this.isClass
-            ? this.childClassIris.flatMap((classIri) => this.shapesGraph.nodeShapeByIdentifier(classIri).toList())
-            : [];
+        return Either.sequence(this.childClassIris.flatMap((classIri) => this.shapesGraph.nodeShapeByIdentifier(classIri)));
+    }
+    get comment() {
+        return List.head(this.comments);
     }
     get descendantNodeShapes() {
-        return this.isClass
-            ? this.descendantClassIris.flatMap((classIri) => this.shapesGraph.nodeShapeByIdentifier(classIri).toList())
-            : [];
+        return Either.sequence(this.descendantClassIris.flatMap((classIri) => this.shapesGraph.nodeShapeByIdentifier(classIri)));
+    }
+    get discriminantValue() {
+        return this.generatedShaclmateNodeShape.discriminantValue;
     }
     get export() {
         return this.generatedShaclmateNodeShape.export_;
@@ -46,68 +65,37 @@ export class NodeShape extends ShaclCoreNodeShape {
     get fromRdfType() {
         return this.generatedShaclmateNodeShape.fromRdfType;
     }
+    get identifierIn() {
+        return this.constraints.in_.filter((value) => value.termType === "NamedNode");
+    }
     get identifierMintingStrategy() {
-        const thisMintingStrategy = this._mintingStrategy;
-        if (thisMintingStrategy.isNothing()) {
-            for (const ancestorNodeShape of this.ancestorNodeShapes) {
-                const ancestorMintingStrategy = ancestorNodeShape._mintingStrategy;
-                if (ancestorMintingStrategy.isJust()) {
-                    return ancestorMintingStrategy;
-                }
+        return this.generatedShaclmateNodeShape.identifierMintingStrategy.map((iri) => {
+            switch (iri.value) {
+                case "http://purl.org/shaclmate/ontology#_IdentifierMintingStrategy_BlankNode":
+                    return "blankNode";
+                case "http://purl.org/shaclmate/ontology#_IdentifierMintingStrategy_SHA256":
+                    return "sha256";
+                case "http://purl.org/shaclmate/ontology#_IdentifierMintingStrategy_UUIDv4":
+                    return "uuidv4";
+                default:
+                    iri.value;
+                    throw new RangeError(iri.value);
             }
-        }
-        return thisMintingStrategy.altLazy(() => this.nodeKinds.has("BlankNode") ? Maybe.of("blankNode") : Maybe.empty());
+        });
+    }
+    get label() {
+        return List.head(this.labels);
     }
     get mutable() {
         return this.generatedShaclmateNodeShape.mutable;
     }
-    get nodeKinds() {
-        const thisNodeKinds = new Set([...this.constraints.nodeKinds.orDefault(new Set())].filter((nodeKind) => nodeKind !== "Literal"));
-        const parentNodeKinds = new Set();
-        for (const parentNodeShape of this.parentNodeShapes) {
-            for (const parentNodeKind of parentNodeShape.nodeKinds) {
-                parentNodeKinds.add(parentNodeKind);
-            }
-        }
-        if (thisNodeKinds.size === 0 && parentNodeKinds.size > 0) {
-            // No node kinds on this shape, use the parent's
-            return parentNodeKinds;
-        }
-        if (thisNodeKinds.size > 0 && parentNodeKinds.size > 0) {
-            // Node kinds on this shape and the parent's shape
-            // This node kinds must be a subset of parent node kinds.
-            for (const thisNodeKind of thisNodeKinds) {
-                if (!parentNodeKinds.has(thisNodeKind)) {
-                    throw new Error(`${this} has a nodeKind ${thisNodeKind} that is not in its parent's node kinds`);
-                }
-            }
-        }
-        if (thisNodeKinds.size === 0) {
-            // Default: both node kinds
-            thisNodeKinds.add("BlankNode");
-            thisNodeKinds.add("NamedNode");
-        }
-        return thisNodeKinds;
-    }
     get parentNodeShapes() {
-        return this.isClass
-            ? this.parentClassIris.flatMap((classIri) => this.shapesGraph.nodeShapeByIdentifier(classIri).toList())
-            : [];
+        return Either.sequence(this.parentClassIris
+            .filter((classIri) => !classIri.equals(rdf.List))
+            .map((classIri) => this.shapesGraph.nodeShapeByIdentifier(classIri)));
     }
     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();
+        return this.generatedShaclmateNodeShape.rdfType;
     }
     get shaclmateName() {
         return this.generatedShaclmateNodeShape.name;
@@ -116,14 +104,13 @@ export class NodeShape extends ShaclCoreNodeShape {
         return this.generatedShaclmateNodeShape.toRdfTypes;
     }
     get tsFeatures() {
-        return tsFeatures(this.generatedShaclmateNodeShape).altLazy(() => this.isDefinedBy.chain((ontology) => ontology.tsFeatures));
+        return tsFeatures(this.generatedShaclmateNodeShape);
     }
     get tsImports() {
         return this.generatedShaclmateNodeShape.tsImports;
     }
     get tsObjectDeclarationType() {
-        return this.generatedShaclmateNodeShape.tsObjectDeclarationType
-            .map((iri) => {
+        return this.generatedShaclmateNodeShape.tsObjectDeclarationType.map((iri) => {
             switch (iri.value) {
                 case "http://purl.org/shaclmate/ontology#_TsObjectDeclarationType_Class":
                     return "class";
@@ -132,20 +119,40 @@ export class NodeShape extends ShaclCoreNodeShape {
                 default:
                     throw new RangeError(iri.value);
             }
-        })
-            .altLazy(() => this.isDefinedBy.chain((ontology) => ontology.tsObjectDeclarationType));
-    }
-    get _mintingStrategy() {
-        return this.generatedShaclmateNodeShape.identifierMintingStrategy.map((iri) => {
-            switch (iri.value) {
-                case "http://purl.org/shaclmate/ontology#_IdentifierMintingStrategy_BlankNode":
-                    return "blankNode";
-                case "http://purl.org/shaclmate/ontology#_IdentifierMintingStrategy_SHA256":
-                    return "sha256";
-                case "http://purl.org/shaclmate/ontology#_IdentifierMintingStrategy_UUIDv4":
-                    return "uuidv4";
-            }
         });
     }
 }
+__decorate([
+    Memoize()
+], NodeShape.prototype, "ancestorNodeShapes", null);
+__decorate([
+    Memoize()
+], NodeShape.prototype, "childNodeShapes", null);
+__decorate([
+    Memoize()
+], NodeShape.prototype, "comment", null);
+__decorate([
+    Memoize()
+], NodeShape.prototype, "descendantNodeShapes", null);
+__decorate([
+    Memoize()
+], NodeShape.prototype, "identifierIn", null);
+__decorate([
+    Memoize()
+], NodeShape.prototype, "identifierMintingStrategy", null);
+__decorate([
+    Memoize()
+], NodeShape.prototype, "label", null);
+__decorate([
+    Memoize()
+], NodeShape.prototype, "parentNodeShapes", null);
+__decorate([
+    Memoize()
+], NodeShape.prototype, "rdfType", null);
+__decorate([
+    Memoize()
+], NodeShape.prototype, "tsFeatures", null);
+__decorate([
+    Memoize()
+], NodeShape.prototype, "tsObjectDeclarationType", null);
 //# sourceMappingURL=NodeShape.js.map

package/dist/input/Ontology.d.ts

@@ -5,7 +5,7 @@ import type * as generated from "./generated.js";
 export declare class Ontology extends OwlOntology {
     private readonly generatedShaclmateOntology;
     constructor(generatedShaclmateOntology: generated.ShaclmateOntology);
-    get tsFeatures(): Maybe<Set<TsFeature>>;
+    get tsFeatures(): Maybe<ReadonlySet<TsFeature>>;
     get tsImports(): readonly string[];
     get tsObjectDeclarationType(): Maybe<TsObjectDeclarationType>;
 }

package/dist/input/Ontology.js

@@ -1,4 +1,11 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
 import { Ontology as OwlOntology } from "@shaclmate/shacl-ast";
+import { Memoize } from "typescript-memoize";
 import { tsFeatures } from "./tsFeatures.js";
 export class Ontology extends OwlOntology {
     generatedShaclmateOntology;
@@ -25,4 +32,10 @@ export class Ontology extends OwlOntology {
         });
     }
 }
+__decorate([
+    Memoize()
+], Ontology.prototype, "tsFeatures", null);
+__decorate([
+    Memoize()
+], Ontology.prototype, "tsObjectDeclarationType", null);
 //# sourceMappingURL=Ontology.js.map

package/dist/input/PropertyShape.d.ts

@@ -1,17 +1,20 @@
 import { PropertyShape as ShaclCorePropertyShape } from "@shaclmate/shacl-ast";
-import { Maybe } from "purify-ts";
+import { Either, Maybe } from "purify-ts";
 import type { PropertyVisibility } from "../enums/index.js";
-import type { Shape } from "./Shape.js";
 import type * as generated from "./generated.js";
 import type { NodeShape, Ontology, PropertyGroup, ShapesGraph } from "./index.js";
+import type { Shape } from "./Shape.js";
 export declare class PropertyShape extends ShaclCorePropertyShape<NodeShape, Ontology, PropertyGroup, any, Shape> {
     private readonly generatedShaclmatePropertyShape;
+    readonly kind = "PropertyShape";
     constructor(generatedShaclmatePropertyShape: generated.ShaclmatePropertyShape, shapesGraph: ShapesGraph);
-    get lazy(): Maybe<boolean>;
+    get comment(): Maybe<string>;
+    get description(): Maybe<string>;
+    get label(): Maybe<string>;
     get mutable(): Maybe<boolean>;
+    get name(): Maybe<string>;
+    get resolve(): Either<Error, Maybe<NodeShape>>;
     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

@@ -1,23 +1,45 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
 import { PropertyShape as ShaclCorePropertyShape } from "@shaclmate/shacl-ast";
-import { Maybe } from "purify-ts";
+import { Either, List, Maybe } from "purify-ts";
+import { Memoize } from "typescript-memoize";
 export class PropertyShape extends ShaclCorePropertyShape {
     generatedShaclmatePropertyShape;
+    kind = "PropertyShape";
     constructor(generatedShaclmatePropertyShape, shapesGraph) {
         super({ ...generatedShaclmatePropertyShape, uniqueLang: Maybe.empty() }, shapesGraph);
         this.generatedShaclmatePropertyShape = generatedShaclmatePropertyShape;
     }
-    get lazy() {
-        return this.generatedShaclmatePropertyShape.lazy;
+    get comment() {
+        return List.head(this.comments);
+    }
+    get description() {
+        return List.head(super.descriptions);
+    }
+    get label() {
+        return List.head(this.labels);
     }
     get mutable() {
         return this.generatedShaclmatePropertyShape.mutable;
     }
+    get name() {
+        return List.head(this.names);
+    }
+    get resolve() {
+        const identifier = this.generatedShaclmatePropertyShape.resolve.extract();
+        return identifier
+            ? this.shapesGraph
+                .nodeShapeByIdentifier(identifier)
+                .map((_) => Maybe.of(_))
+            : Either.of(Maybe.empty());
+    }
     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) => {
@@ -34,8 +56,23 @@ export class PropertyShape extends ShaclCorePropertyShape {
         })
             .orDefault("public");
     }
-    get widen() {
-        return this.generatedShaclmatePropertyShape.widen;
-    }
 }
+__decorate([
+    Memoize()
+], PropertyShape.prototype, "comment", null);
+__decorate([
+    Memoize()
+], PropertyShape.prototype, "description", null);
+__decorate([
+    Memoize()
+], PropertyShape.prototype, "label", null);
+__decorate([
+    Memoize()
+], PropertyShape.prototype, "name", null);
+__decorate([
+    Memoize()
+], PropertyShape.prototype, "resolve", null);
+__decorate([
+    Memoize()
+], PropertyShape.prototype, "visibility", null);
 //# sourceMappingURL=PropertyShape.js.map