@shaclmate/compiler 4.0.23 → 4.0.25

package/dist/Compiler.d.ts

@@ -1,7 +1,7 @@
 import type { Either } from "purify-ts";
 import type { Logger } from "ts-log";
-import type { TsFeature } from "./enums/TsFeature.js";
 import type { Generator } from "./generators/Generator.js";
+import type { TsFeature } from "./generators/ts/TsFeature.js";
 import type { ShapesGraph } from "./input/ShapesGraph.js";
 export declare class Compiler {
     private readonly generator;

package/dist/ShapesGraphToAstTransformer.d.ts

@@ -3,7 +3,7 @@ import type { BlankNode, NamedNode } from "@rdfjs/types";
 import { Either } from "purify-ts";
 import type { Logger } from "ts-log";
 import type * as ast from "./ast/index.js";
-import type { TsFeature } from "./enums/TsFeature.js";
+import type { TsFeature } from "./generators/ts/TsFeature.js";
 import type * as input from "./input/index.js";
 interface RelatedNodeShapes {
     readonly ancestors: input.NodeShape[];

package/dist/ShapesGraphToAstTransformer.js

@@ -7,13 +7,13 @@ import { transformShapeToAstType } from "./_ShapesGraphToAstTransformer/transfor
 function relatedNodeShapes({ logger, shapesGraph, }) {
     const immediateRelatedNodeShapes = new TermMap();
     for (const childNodeShape of shapesGraph.nodeShapes) {
-        let childRelatedNodeShapes = immediateRelatedNodeShapes.get(childNodeShape.$identifier);
+        let childRelatedNodeShapes = immediateRelatedNodeShapes.get(childNodeShape.$identifier());
         if (!childRelatedNodeShapes) {
             childRelatedNodeShapes = {
                 children: new TermMap(),
                 parents: new TermMap(),
             };
-            immediateRelatedNodeShapes.set(childNodeShape.$identifier, childRelatedNodeShapes);
+            immediateRelatedNodeShapes.set(childNodeShape.$identifier(), childRelatedNodeShapes);
         }
         for (const parentClassIdentifier of childNodeShape.subClassOf) {
             shapesGraph
@@ -22,29 +22,29 @@ function relatedNodeShapes({ logger, shapesGraph, }) {
                 logger.error("%s is rdfs:subClassOf %s which is either missing or not a node shape: %s", childNodeShape, parentClassIdentifier, error.message);
             })
                 .ifRight((parentNodeShape) => {
-                childRelatedNodeShapes.parents.set(parentNodeShape.$identifier, parentNodeShape);
-                let parentRelatedNodeShapes = immediateRelatedNodeShapes.get(parentNodeShape.$identifier);
+                childRelatedNodeShapes.parents.set(parentNodeShape.$identifier(), parentNodeShape);
+                let parentRelatedNodeShapes = immediateRelatedNodeShapes.get(parentNodeShape.$identifier());
                 if (!parentRelatedNodeShapes) {
                     parentRelatedNodeShapes = {
                         children: new TermMap(),
                         parents: new TermMap(),
                     };
-                    immediateRelatedNodeShapes.set(parentNodeShape.$identifier, parentRelatedNodeShapes);
+                    immediateRelatedNodeShapes.set(parentNodeShape.$identifier(), parentRelatedNodeShapes);
                 }
-                parentRelatedNodeShapes.children.set(childNodeShape.$identifier, childNodeShape);
+                parentRelatedNodeShapes.children.set(childNodeShape.$identifier(), childNodeShape);
             });
         }
     }
     const result = new TermMap();
     for (const nodeShape of shapesGraph.nodeShapes) {
-        const { children: childNodeShapes, parents: parentNodeShapes } = immediateRelatedNodeShapes.get(nodeShape.$identifier);
+        const { children: childNodeShapes, parents: parentNodeShapes } = immediateRelatedNodeShapes.get(nodeShape.$identifier());
         const ancestorNodeShapes = new TermMap();
         function recurseAncestorNodeShapes(nodeShape) {
             for (const parentNodeShape of immediateRelatedNodeShapes
-                .get(nodeShape.$identifier)
+                .get(nodeShape.$identifier())
                 .parents.values()) {
-                if (!ancestorNodeShapes.has(parentNodeShape.$identifier)) {
-                    ancestorNodeShapes.set(parentNodeShape.$identifier, parentNodeShape);
+                if (!ancestorNodeShapes.has(parentNodeShape.$identifier())) {
+                    ancestorNodeShapes.set(parentNodeShape.$identifier(), parentNodeShape);
                     recurseAncestorNodeShapes(parentNodeShape);
                 }
             }
@@ -53,16 +53,16 @@ function relatedNodeShapes({ logger, shapesGraph, }) {
         const descendantNodeShapes = new TermMap();
         function recurseDescendantNodeShapes(nodeShape) {
             for (const childNodeShape of immediateRelatedNodeShapes
-                .get(nodeShape.$identifier)
+                .get(nodeShape.$identifier())
                 .children.values()) {
-                if (!descendantNodeShapes.has(childNodeShape.$identifier)) {
-                    descendantNodeShapes.set(childNodeShape.$identifier, childNodeShape);
+                if (!descendantNodeShapes.has(childNodeShape.$identifier())) {
+                    descendantNodeShapes.set(childNodeShape.$identifier(), childNodeShape);
                     recurseDescendantNodeShapes(childNodeShape);
                 }
             }
         }
         recurseDescendantNodeShapes(nodeShape);
-        result.set(nodeShape.$identifier, {
+        result.set(nodeShape.$identifier(), {
             ancestors: [...ancestorNodeShapes.values()],
             children: [...childNodeShapes.values()],
             descendants: [...descendantNodeShapes.values()],
@@ -95,10 +95,10 @@ export class ShapesGraphToAstTransformer {
         const syntheticAstObjectTypesByName = {};
         const astNamedUnionTypes = [];
         for (const nodeShape of this.shapesGraph.nodeShapes) {
-            if (nodeShape.$identifier.termType !== "NamedNode") {
+            if (nodeShape.$identifier().termType !== "NamedNode") {
                 continue;
             }
-            if (nodeShape.$identifier.value.startsWith(dash[""].value)) {
+            if (nodeShape.$identifier().value.startsWith(dash[""].value)) {
                 continue;
             }
             const nodeShapeAstTypeEither = transformShapeToAstType.call(this, nodeShape, new ShapeStack());

package/dist/_ShapesGraphToAstTransformer/nodeShapeTsFeatures.d.ts

@@ -1,5 +1,5 @@
 import { Either } from "purify-ts";
-import { type TsFeature } from "../enums/TsFeature.js";
+import { type TsFeature } from "../generators/ts/TsFeature.js";
 import type * as input from "../input/index.js";
 import type { ShapesGraphToAstTransformer } from "../ShapesGraphToAstTransformer.js";
 export declare function nodeShapeTsFeatures(this: ShapesGraphToAstTransformer, nodeShape: input.NodeShape): Either<Error, ReadonlySet<TsFeature>>;

package/dist/_ShapesGraphToAstTransformer/nodeShapeTsFeatures.js

@@ -1,5 +1,5 @@
 import { Either } from "purify-ts";
-import { TS_FEATURES } from "../enums/TsFeature.js";
+import { TS_FEATURES } from "../generators/ts/TsFeature.js";
 import { shapeOntology } from "./shapeOntology.js";
 export function nodeShapeTsFeatures(nodeShape) {
     const tsFeaturesDefault = this.tsFeaturesDefault;
@@ -55,9 +55,12 @@ export function nodeShapeTsFeatures(nodeShape) {
                 tsFeatures.add(tsFeature);
             }
         }
-        if (tsFeatures.has("graphql")) {
+        if (tsFeatures.has("graphql") || tsFeatures.has("sparql")) {
             tsFeatures.add("rdf");
         }
+        if (tsFeatures.has("json") || tsFeatures.has("rdf")) {
+            tsFeatures.add("create");
+        }
         return Either.of(tsFeatures);
     });
 }

package/dist/_ShapesGraphToAstTransformer/shapeAstTypeName.js

@@ -4,7 +4,8 @@ export function shapeAstTypeName(shape) {
     if (shape.$type !== "NodeShape") {
         return Maybe.empty();
     }
-    if (shape.$identifier.termType !== "NamedNode") {
+    const shapeIdentifier = shape.$identifier();
+    if (shapeIdentifier.termType !== "NamedNode") {
         return Maybe.empty();
     }
     // Explicit shaclmate:name
@@ -16,11 +17,11 @@ export function shapeAstTypeName(shape) {
         return shape.label;
     }
     // CURIE shape identifier
-    if (shape.$identifier instanceof Curie) {
-        if (shape.$identifier.hasUniqueReference) {
-            return Maybe.of(shape.$identifier.reference);
+    if (shapeIdentifier instanceof Curie) {
+        if (shapeIdentifier.hasUniqueReference) {
+            return Maybe.of(shapeIdentifier.reference);
         }
-        return Maybe.of(`${shape.$identifier.prefix}_${shape.$identifier.reference}`);
+        return Maybe.of(`${shapeIdentifier.prefix}_${shapeIdentifier.reference}`);
     }
     return Maybe.empty();
 }

package/dist/_ShapesGraphToAstTransformer/shapeNodeKinds.js

@@ -12,7 +12,7 @@ function nodeShapeNodeKinds(nodeShape) {
         .orDefault(new Set());
     // Recurse into parents
     const parentNodeKinds = new Set();
-    for (const parentNodeShape of this.relatedNodeShapesByIdentifier.get(nodeShape.$identifier).parents) {
+    for (const parentNodeShape of this.relatedNodeShapesByIdentifier.get(nodeShape.$identifier()).parents) {
         nodeShapeNodeKinds
             .call(this, parentNodeShape)
             .ifRight((parentNodeKinds_) => {

package/dist/_ShapesGraphToAstTransformer/shapeOntology.js

@@ -12,9 +12,10 @@ export function shapeOntology(shape) {
         // If there's a single ontology in the shapes graph, consider the shape a part of the ontology
         return Either.of(Maybe.of(ontologies[0]));
     }
-    if (shape.$identifier.termType === "NamedNode") {
-        const prefixOntologies = ontologies.filter((ontology) => ontology.$identifier.termType === "NamedNode" &&
-            shape.$identifier.value.startsWith(ontology.$identifier.value));
+    const shapeIdentifier = shape.$identifier();
+    if (shapeIdentifier.termType === "NamedNode") {
+        const prefixOntologies = ontologies.filter((ontology) => ontology.$identifier().termType === "NamedNode" &&
+            shapeIdentifier.value.startsWith(ontology.$identifier().value));
         if (prefixOntologies.length === 1) {
             // If there's a single ontology whose IRI is a prefix of this shape's IRI, consider the shape a part of the ontology
             return Either.of(Maybe.of(prefixOntologies[0]));

package/dist/_ShapesGraphToAstTransformer/transformPropertyShapeToAstObjectTypeProperty.js

@@ -4,7 +4,6 @@ import { Either, Left, Maybe } from "purify-ts";
 import { invariant } from "ts-invariant";
 import * as ast from "../ast/index.js";
 import { Eithers } from "../Eithers.js";
-import { Visibility } from "../enums/Visibility.js";
 import { ShapeStack } from "./ShapeStack.js";
 import { transformShapeToAstType } from "./transformShapeToAstType.js";
 function synthesizePartialAstObjectType({ identifierType, tsFeatures, }) {
@@ -20,12 +19,10 @@ function synthesizePartialAstObjectType({ identifierType, tsFeatures, }) {
             break;
     }
     return new ast.ObjectType({
-        abstract: false,
         comment: Maybe.empty(),
         extern: false,
         fromRdfType: Maybe.empty(),
         identifierType,
-        identifierMintingStrategy: Maybe.empty(),
         label: Maybe.empty(),
         name: Maybe.of(syntheticName),
         shapeIdentifier: dataFactory.namedNode(`urn:shaclmate:synthetic:${syntheticName}`),
@@ -33,7 +30,6 @@ function synthesizePartialAstObjectType({ identifierType, tsFeatures, }) {
         toRdfTypes: [],
         tsFeatures,
         tsImports: [],
-        tsObjectDeclarationType: "class",
     });
 }
 function propertyName(objectType, propertyShape) {
@@ -49,13 +45,14 @@ function propertyName(objectType, propertyShape) {
     }
     // Pick up the common pattern of a property shape identifier being the node shape's identifier -localName,
     // like ex:NodeShape-property
-    if (propertyShape.$identifier.termType === "NamedNode" &&
+    const propertyShapeIdentifier = propertyShape.$identifier();
+    if (propertyShapeIdentifier.termType === "NamedNode" &&
         objectType.shapeIdentifier.termType === "NamedNode") {
         const propertyShapeIdentifierPrefix = `${objectType.shapeIdentifier.value}-`;
-        if (propertyShape.$identifier.value.startsWith(propertyShapeIdentifierPrefix) &&
-            propertyShape.$identifier.value.length >
+        if (propertyShapeIdentifier.value.startsWith(propertyShapeIdentifierPrefix) &&
+            propertyShapeIdentifier.value.length >
                 propertyShapeIdentifierPrefix.length) {
-            return propertyShape.$identifier.value.substring(propertyShapeIdentifierPrefix.length);
+            return propertyShapeIdentifier.value.substring(propertyShapeIdentifierPrefix.length);
         }
     }
     // sh:path CURIE reference
@@ -63,12 +60,12 @@ function propertyName(objectType, propertyShape) {
         return propertyShape.path.reference;
     }
     // Shape identifier CURIE reference
-    if (propertyShape.$identifier instanceof Curie) {
-        return propertyShape.$identifier.reference;
+    if (propertyShapeIdentifier instanceof Curie) {
+        return propertyShapeIdentifier.reference;
     }
     // Shape identifier IRI
-    if (propertyShape.$identifier.termType === "NamedNode") {
-        return propertyShape.$identifier.value;
+    if (propertyShapeIdentifier.termType === "NamedNode") {
+        return propertyShapeIdentifier.value;
     }
     // sh:path IRI
     if (propertyShape.path.termType === "NamedNode") {
@@ -201,7 +198,7 @@ export function transformPropertyShapeToAstObjectTypeProperty({ objectType, prop
                 comment: Maybe.empty(),
                 label: Maybe.empty(),
                 name: Maybe.empty(),
-                shapeIdentifier: propertyShape.$identifier,
+                shapeIdentifier: propertyShape.$identifier(),
             };
             switch (astType.kind) {
                 case "BlankNodeType":
@@ -259,11 +256,8 @@ export function transformPropertyShapeToAstObjectTypeProperty({ objectType, prop
             objectType,
             order: propertyShape.order.orDefault(0),
             path: propertyShape.path,
-            shapeIdentifier: propertyShape.$identifier,
+            shapeIdentifier: propertyShape.$identifier(),
             type: astType,
-            visibility: propertyShape.visibility
-                .map(Visibility.fromIri)
-                .orDefault("public"),
         }));
     });
 }

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstCompoundType.js

@@ -45,7 +45,7 @@ export function transformShapeToAstCompoundType(shape, shapeStack) {
                 comment: shape.comment,
                 label: shape.label,
                 name: shapeAstTypeName(shape),
-                shapeIdentifier: shape.$identifier,
+                shapeIdentifier: shape.$identifier(),
                 tsFeatures,
             });
             if (memberShapes.length === 1) {
@@ -54,7 +54,7 @@ export function transformShapeToAstCompoundType(shape, shapeStack) {
                     .map(Maybe.of);
             }
             // Put a placeholder in the cache to deal with cyclic references
-            this.cachedAstTypesByShapeIdentifier.set(shape.$identifier, compoundType);
+            this.cachedAstTypesByShapeIdentifier.set(shape.$identifier(), compoundType);
             return Either.sequence(memberShapes.map((memberShape) => transformShapeToAstType.call(this, memberShape, shapeStack)))
                 .chain((memberShapeTypes) => {
                 for (let memberI = 0; memberI < memberShapes.length; memberI++) {
@@ -88,7 +88,7 @@ export function transformShapeToAstCompoundType(shape, shapeStack) {
                 return Either.of(Maybe.of(compoundType));
             })
                 .ifLeft(() => {
-                this.cachedAstTypesByShapeIdentifier.delete(shape.$identifier);
+                this.cachedAstTypesByShapeIdentifier.delete(shape.$identifier());
             });
         });
     }

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstListType.js

@@ -4,16 +4,13 @@ import { Either, Left, Maybe } from "purify-ts";
 import * as ast from "../ast/index.js";
 import { Eithers } from "../Eithers.js";
 import { defaultNodeShapeNodeKinds } from "./defaultNodeShapeNodeKinds.js";
-import { nodeShapeIdentifierMintingStrategy } from "./nodeShapeIdentifierMintingStrategy.js";
 import { shapeAstTypeName } from "./shapeAstTypeName.js";
 import { shapeNodeKinds } from "./shapeNodeKinds.js";
 import { transformPropertyShapeToAstObjectTypeProperty } from "./transformPropertyShapeToAstObjectTypeProperty.js";
 const listPropertiesObjectType = new ast.ObjectType({
-    abstract: false,
     extern: false,
     comment: Maybe.empty(),
     label: Maybe.empty(),
-    identifierMintingStrategy: Maybe.empty(),
     identifierType: new ast.IdentifierType({
         comment: Maybe.empty(),
         label: Maybe.empty(),
@@ -24,7 +21,6 @@ const listPropertiesObjectType = new ast.ObjectType({
     name: Maybe.empty(),
     toRdfTypes: [],
     tsFeatures: new Set([]),
-    tsObjectDeclarationType: "class",
     shapeIdentifier: dataFactory.blankNode(),
     synthetic: true,
     tsImports: [],
@@ -47,9 +43,9 @@ export function transformShapeToAstListType(shape, shapeStack) {
             return empty;
         }
         const nodeShape = shape;
-        return Eithers.chain3(nodeShapeIdentifierMintingStrategy.call(this, nodeShape), shapeNodeKinds.call(this, nodeShape, { defaultNodeShapeNodeKinds }), Either.sequence(nodeShape.xone
+        return Eithers.chain2(shapeNodeKinds.call(this, nodeShape, { defaultNodeShapeNodeKinds }), Either.sequence(nodeShape.xone
             .orDefault([])
-            .map((shapeIdentifier) => this.shapesGraph.shape(shapeIdentifier)))).chain(([identifierMintingStrategy, nodeKinds, xone]) => {
+            .map((shapeIdentifier) => this.shapesGraph.shape(shapeIdentifier)))).chain(([nodeKinds, xone]) => {
             // Put a placeholder in the cache to deal with cyclic references
             // Remove the placeholder if the transformation fails.
             const listType = new ast.ListType({
@@ -59,11 +55,10 @@ export function transformShapeToAstListType(shape, shapeStack) {
                 label: nodeShape.label,
                 mutable: nodeShape.mutable.orDefault(false),
                 name: shapeAstTypeName(nodeShape),
-                identifierMintingStrategy,
-                shapeIdentifier: nodeShape.$identifier,
+                shapeIdentifier: nodeShape.$identifier(),
                 toRdfTypes: nodeShape.toRdfTypes,
             });
-            this.cachedAstTypesByShapeIdentifier.set(nodeShape.$identifier, listType);
+            this.cachedAstTypesByShapeIdentifier.set(nodeShape.$identifier(), listType);
             return (() => {
                 let emptyListShape;
                 let nonEmptyListShape;
@@ -127,7 +122,7 @@ export function transformShapeToAstListType(shape, shapeStack) {
                         })
                             .chain((restProperty) => {
                             if (restProperty.type.kind !== "ListType" ||
-                                !restProperty.type.shapeIdentifier.equals(nodeShape.$identifier)) {
+                                !restProperty.type.shapeIdentifier.equals(nodeShape.$identifier())) {
                                 return Left(new Error(`${nodeShape} rdf:rest property is not recursive into the node shape`));
                             }
                             return Either.of(Maybe.of(listType));
@@ -135,7 +130,7 @@ export function transformShapeToAstListType(shape, shapeStack) {
                     });
                 });
             })().ifLeft(() => {
-                this.cachedAstTypesByShapeIdentifier.delete(nodeShape.$identifier);
+                this.cachedAstTypesByShapeIdentifier.delete(nodeShape.$identifier());
             });
         });
     }

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstObjectType.js

@@ -3,14 +3,11 @@ import { Either, Left, Maybe } from "purify-ts";
 import { invariant } from "ts-invariant";
 import * as ast from "../ast/index.js";
 import { Eithers } from "../Eithers.js";
-import { TsObjectDeclarationType } from "../enums/TsObjectDeclarationType.js";
 import { defaultNodeShapeNodeKinds } from "./defaultNodeShapeNodeKinds.js";
-import { nodeShapeIdentifierMintingStrategy } from "./nodeShapeIdentifierMintingStrategy.js";
 import { nodeShapeTsFeatures } from "./nodeShapeTsFeatures.js";
 import { ShapeStack } from "./ShapeStack.js";
 import { shapeAstTypeName } from "./shapeAstTypeName.js";
 import { shapeNodeKinds } from "./shapeNodeKinds.js";
-import { shapeOntology } from "./shapeOntology.js";
 import { transformPropertyShapeToAstObjectTypeProperty } from "./transformPropertyShapeToAstObjectTypeProperty.js";
 import { transformShapeToAstType } from "./transformShapeToAstType.js";
 function isObjectTypePropertyRequired(property) {
@@ -54,41 +51,29 @@ export function transformShapeToAstObjectType(shape, shapeStack) {
             nodeShape.xone.orDefault([]).length > 0) {
             return Either.of(Maybe.empty());
         }
-        if (nodeShape.$identifier.termType !== "NamedNode") {
+        if (nodeShape.$identifier().termType !== "NamedNode") {
             return Either.of(Maybe.empty());
         }
-        return Eithers.chain5(nodeShapeIdentifierMintingStrategy.call(this, nodeShape), shapeNodeKinds.call(this, nodeShape, { defaultNodeShapeNodeKinds }), Either.sequence(nodeShape.properties.map((propertyShapeIdentifier) => this.shapesGraph.propertyShape(propertyShapeIdentifier))), nodeShapeTsFeatures.call(this, nodeShape), nodeShape.tsObjectDeclarationType.isJust()
-            ? Either.of(nodeShape.tsObjectDeclarationType.map(TsObjectDeclarationType.fromIri))
-            : shapeOntology
-                .call(this, nodeShape)
-                .map((ontology) => ontology.chain((ontology) => ontology.tsObjectDeclarationType.map(TsObjectDeclarationType.fromIri)))).chain(([identifierMintingStrategy, nodeKinds, propertyShapes, tsFeatures, tsObjectDeclarationType,]) => {
-            const abstract = nodeShape.abstract.orDefault(false);
-            const { ancestors: ancestorNodeShapes, descendants: descendantNodeShapes, children: childNodeShapes, parents: parentNodeShapes, } = this.relatedNodeShapesByIdentifier.get(nodeShape.$identifier);
+        return Eithers.chain3(shapeNodeKinds.call(this, nodeShape, { defaultNodeShapeNodeKinds }), Either.sequence(nodeShape.properties.map((propertyShapeIdentifier) => this.shapesGraph.propertyShape(propertyShapeIdentifier))), nodeShapeTsFeatures.call(this, nodeShape)).chain(([nodeKinds, propertyShapes, tsFeatures]) => {
+            const nodeShapeIdentifier = nodeShape.$identifier();
+            const { ancestors: ancestorNodeShapes, descendants: descendantNodeShapes, children: childNodeShapes, parents: parentNodeShapes, } = this.relatedNodeShapesByIdentifier.get(nodeShapeIdentifier);
             const isClass = nodeShape.subClassOf.length > 0 ||
                 descendantNodeShapes.length > 0 || // A node shape that is the object of an rdfs:subClassOf is itself an rdfs:Class
                 nodeShape.types.some((type) => type.equals(owl.Class) || type.equals(rdfs.Class));
-            let fromRdfType;
-            let toRdfTypes;
-            if (!abstract) {
-                fromRdfType = nodeShape.fromRdfType.alt(nodeShape.rdfType);
-                if (isClass && nodeShape.$identifier.termType === "NamedNode") {
-                    fromRdfType = fromRdfType.alt(Maybe.of(nodeShape.$identifier));
-                }
-                toRdfTypes = nodeShape.toRdfTypes.concat();
-                if (toRdfTypes.length === 0) {
-                    toRdfTypes.push(...nodeShape.rdfType.toList());
-                }
-                // Ensure toRdfTypes has fromRdfType
-                fromRdfType.ifJust((fromRdfType) => {
-                    if (!toRdfTypes.some((toRdfType) => toRdfType.equals(fromRdfType))) {
-                        toRdfTypes.push(fromRdfType);
-                    }
-                });
+            let fromRdfType = nodeShape.fromRdfType.alt(nodeShape.rdfType);
+            if (isClass && nodeShapeIdentifier.termType === "NamedNode") {
+                fromRdfType = fromRdfType.alt(Maybe.of(nodeShapeIdentifier));
             }
-            else {
-                fromRdfType = Maybe.empty();
-                toRdfTypes = [];
+            const toRdfTypes = nodeShape.toRdfTypes.concat();
+            if (toRdfTypes.length === 0) {
+                toRdfTypes.push(...nodeShape.rdfType.toList());
             }
+            // Ensure toRdfTypes has fromRdfType
+            fromRdfType.ifJust((fromRdfType) => {
+                if (!toRdfTypes.some((toRdfType) => toRdfType.equals(fromRdfType))) {
+                    toRdfTypes.push(fromRdfType);
+                }
+            });
             if (nodeKinds.has("Literal")) {
                 return Left(new Error(`${nodeShape} should not have a nodeKind "Literal"`));
             }
@@ -97,7 +82,7 @@ export function transformShapeToAstObjectType(shape, shapeStack) {
                 comment: Maybe.empty(),
                 label: Maybe.empty(),
                 name: Maybe.empty(),
-                shapeIdentifier: nodeShape.$identifier,
+                shapeIdentifier: nodeShape.$identifier(),
             };
             if (nodeKinds.size === 2) {
                 invariant(nodeShape.in_.isNothing());
@@ -128,22 +113,19 @@ export function transformShapeToAstObjectType(shape, shapeStack) {
             // If this node shape's properties (directly or indirectly) refer to the node shape itself,
             // we'll return this placeholder.
             const objectType = new ast.ObjectType({
-                abstract,
                 comment: nodeShape.comment,
                 extern: nodeShape.extern.orDefault(false),
                 fromRdfType,
                 label: nodeShape.label,
                 identifierType,
-                identifierMintingStrategy,
                 name: shapeAstTypeName(nodeShape),
-                shapeIdentifier: nodeShape.$identifier,
+                shapeIdentifier: nodeShape.$identifier(),
                 synthetic: false,
                 toRdfTypes,
                 tsFeatures,
                 tsImports: nodeShape.tsImports,
-                tsObjectDeclarationType: tsObjectDeclarationType.orDefault("class"),
             });
-            this.cachedAstTypesByShapeIdentifier.set(nodeShape.$identifier, objectType);
+            this.cachedAstTypesByShapeIdentifier.set(nodeShape.$identifier(), objectType);
             return (() => {
                 // Populate ancestor and descendant object types
                 const relatedObjectTypes = (relatedNodeShapes) => {
@@ -171,8 +153,7 @@ export function transformShapeToAstObjectType(shape, shapeStack) {
                         objectType.addProperties(property);
                     });
                 }
-                if (!objectType.abstract &&
-                    !objectType.extern &&
+                if (!objectType.extern &&
                     objectType.fromRdfType.isNothing() &&
                     !objectType.properties.some(isObjectTypePropertyRequired)) {
                     return Left(new Error(`${nodeShape} has no required properties and no implicitly required rdf:type`));
@@ -180,7 +161,7 @@ export function transformShapeToAstObjectType(shape, shapeStack) {
                 objectType.sortProperties();
                 return Either.of(Maybe.of(objectType));
             })().ifLeft(() => {
-                this.cachedAstTypesByShapeIdentifier.delete(nodeShape.$identifier);
+                this.cachedAstTypesByShapeIdentifier.delete(nodeShape.$identifier());
             });
         });
     }

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstTermType.js

@@ -15,7 +15,7 @@ export function transformShapeToAstTermType(shape, shapeStack) {
                 comment: Maybe.empty(),
                 name: Maybe.empty(),
                 label: Maybe.empty(),
-                shapeIdentifier: shape.$identifier,
+                shapeIdentifier: shape.$identifier(),
             };
             let termType;
             if (nodeKinds.size === 1) {

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstType.js

@@ -13,7 +13,7 @@ const tryTransformShapeToAstTypeMethods = [
  * not the other transformShapeToAst*Type functions directly.
  */
 export function transformShapeToAstType(shape, shapeStack) {
-    const astType = this.cachedAstTypesByShapeIdentifier.get(shape.$identifier);
+    const astType = this.cachedAstTypesByShapeIdentifier.get(shape.$identifier());
     if (astType) {
         return Either.of(astType);
     }
@@ -28,14 +28,14 @@ export function transformShapeToAstType(shape, shapeStack) {
         }
         const astType = either.unsafeCoerce().extract();
         if (astType) {
-            this.cachedAstTypesByShapeIdentifier.set(shape.$identifier, astType);
+            this.cachedAstTypesByShapeIdentifier.set(shape.$identifier(), astType);
             return Either.of(astType);
         }
     }
     return transformShapeToAstTermType
         .call(this, shape, shapeStack)
         .ifRight((astType) => {
-        this.cachedAstTypesByShapeIdentifier.set(shape.$identifier, astType);
+        this.cachedAstTypesByShapeIdentifier.set(shape.$identifier(), astType);
     });
 }
 //# sourceMappingURL=transformShapeToAstType.js.map

package/dist/ast/AbstractCompoundType.d.ts

@@ -1,5 +1,5 @@
 import type { NodeKind } from "@shaclmate/shacl-ast";
-import type { TsFeature } from "../enums/TsFeature.js";
+import type { TsFeature } from "../generators/ts/TsFeature.js";
 import { AbstractType } from "./AbstractType.js";
 import type { BlankNodeType } from "./BlankNodeType.js";
 import type { IdentifierType } from "./IdentifierType.js";

package/dist/ast/AbstractLazyObjectType.d.ts

@@ -21,7 +21,6 @@ export declare abstract class AbstractLazyObjectType<PartialTypeT extends Abstra
     toJSON(): {
         partialType: {
             fromRdfType: import("@rdfjs/types").NamedNode<string> | undefined;
-            identifierMintingStrategy: "blankNode" | "sha256" | "uuidv4" | undefined;
             identifierType: {
                 hasValues: readonly import("@rdfjs/types").NamedNode<string>[] | undefined;
                 in: readonly import("@rdfjs/types").NamedNode<string>[] | undefined;
@@ -64,7 +63,6 @@ export declare abstract class AbstractLazyObjectType<PartialTypeT extends Abstra
         };
         resolveType: {
             fromRdfType: import("@rdfjs/types").NamedNode<string> | undefined;
-            identifierMintingStrategy: "blankNode" | "sha256" | "uuidv4" | undefined;
             identifierType: {
                 hasValues: readonly import("@rdfjs/types").NamedNode<string>[] | undefined;
                 in: readonly import("@rdfjs/types").NamedNode<string>[] | undefined;

package/dist/ast/ListType.d.ts

@@ -1,7 +1,5 @@
 import type { BlankNode, NamedNode } from "@rdfjs/types";
 import type { IdentifierNodeKind } from "@shaclmate/shacl-ast";
-import type { Maybe } from "purify-ts";
-import type { IdentifierMintingStrategy } from "../enums/IdentifierMintingStrategy.js";
 import { AbstractCollectionType } from "./AbstractCollectionType.js";
 import type { BlankNodeType } from "./BlankNodeType.js";
 import type { IdentifierType } from "./IdentifierType.js";
@@ -25,10 +23,6 @@ export declare class ListType<ItemTypeT extends ListType.ItemType = ListType.Ite
      */
     readonly identifierNodeKind: IdentifierNodeKind;
     readonly kind = "ListType";
-    /**
-     * Strategy for minting new list and sub-list identifiers.
-     */
-    readonly identifierMintingStrategy: Maybe<IdentifierMintingStrategy>;
     /**
      * rdf:type's that will be added to this object when it's serialized toRdf.
      *
@@ -36,8 +30,7 @@ export declare class ListType<ItemTypeT extends ListType.ItemType = ListType.Ite
      * class targets).
      */
     readonly toRdfTypes: readonly NamedNode[];
-    constructor({ identifierMintingStrategy, identifierNodeKind, toRdfTypes, ...superParameters }: {
-        identifierMintingStrategy: Maybe<IdentifierMintingStrategy>;
+    constructor({ identifierNodeKind, toRdfTypes, ...superParameters }: {
         identifierNodeKind: IdentifierNodeKind;
         shapeIdentifier: BlankNode | NamedNode;
         toRdfTypes: readonly NamedNode[];

package/dist/ast/ListType.js

@@ -12,10 +12,6 @@ export class ListType extends AbstractCollectionType {
      */
     identifierNodeKind;
     kind = "ListType";
-    /**
-     * Strategy for minting new list and sub-list identifiers.
-     */
-    identifierMintingStrategy;
     /**
      * rdf:type's that will be added to this object when it's serialized toRdf.
      *
@@ -23,9 +19,8 @@ export class ListType extends AbstractCollectionType {
      * class targets).
      */
     toRdfTypes;
-    constructor({ identifierMintingStrategy, identifierNodeKind, toRdfTypes, ...superParameters }) {
+    constructor({ identifierNodeKind, toRdfTypes, ...superParameters }) {
         super(superParameters);
-        this.identifierMintingStrategy = identifierMintingStrategy;
         this.identifierNodeKind = identifierNodeKind;
         this.toRdfTypes = toRdfTypes;
     }