@shaclmate/compiler 4.0.23 → 4.0.24

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/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

@@ -25,7 +25,6 @@ function synthesizePartialAstObjectType({ identifierType, tsFeatures, }) {
         extern: false,
         fromRdfType: Maybe.empty(),
         identifierType,
-        identifierMintingStrategy: Maybe.empty(),
         label: Maybe.empty(),
         name: Maybe.of(syntheticName),
         shapeIdentifier: dataFactory.namedNode(`urn:shaclmate:synthetic:${syntheticName}`),
@@ -49,13 +48,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 +63,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 +201,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,7 +259,7 @@ 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)

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,7 +4,6 @@ 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";
@@ -13,7 +12,6 @@ const listPropertiesObjectType = new ast.ObjectType({
     extern: false,
     comment: Maybe.empty(),
     label: Maybe.empty(),
-    identifierMintingStrategy: Maybe.empty(),
     identifierType: new ast.IdentifierType({
         comment: Maybe.empty(),
         label: Maybe.empty(),
@@ -47,9 +45,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 +57,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 +124,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 +132,7 @@ export function transformShapeToAstListType(shape, shapeStack) {
                     });
                 });
             })().ifLeft(() => {
-                this.cachedAstTypesByShapeIdentifier.delete(nodeShape.$identifier);
+                this.cachedAstTypesByShapeIdentifier.delete(nodeShape.$identifier());
             });
         });
     }

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstObjectType.js

@@ -5,7 +5,6 @@ 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";
@@ -54,16 +53,17 @@ 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()
+        return Eithers.chain4(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,]) => {
+                .map((ontology) => ontology.chain((ontology) => ontology.tsObjectDeclarationType.map(TsObjectDeclarationType.fromIri)))).chain(([nodeKinds, propertyShapes, tsFeatures, tsObjectDeclarationType]) => {
             const abstract = nodeShape.abstract.orDefault(false);
-            const { ancestors: ancestorNodeShapes, descendants: descendantNodeShapes, children: childNodeShapes, parents: parentNodeShapes, } = this.relatedNodeShapesByIdentifier.get(nodeShape.$identifier);
+            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));
@@ -71,8 +71,8 @@ export function transformShapeToAstObjectType(shape, shapeStack) {
             let toRdfTypes;
             if (!abstract) {
                 fromRdfType = nodeShape.fromRdfType.alt(nodeShape.rdfType);
-                if (isClass && nodeShape.$identifier.termType === "NamedNode") {
-                    fromRdfType = fromRdfType.alt(Maybe.of(nodeShape.$identifier));
+                if (isClass && nodeShapeIdentifier.termType === "NamedNode") {
+                    fromRdfType = fromRdfType.alt(Maybe.of(nodeShapeIdentifier));
                 }
                 toRdfTypes = nodeShape.toRdfTypes.concat();
                 if (toRdfTypes.length === 0) {
@@ -97,7 +97,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());
@@ -134,16 +134,15 @@ export function transformShapeToAstObjectType(shape, shapeStack) {
                 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) => {
@@ -180,7 +179,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/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;
     }

package/dist/ast/ObjectType.d.ts

@@ -2,7 +2,6 @@ import type { BlankNode, NamedNode } from "@rdfjs/types";
 import { PropertyPath } from "@rdfx/resource";
 import type { NodeKind } from "@shaclmate/shacl-ast";
 import type { Maybe } from "purify-ts";
-import type { IdentifierMintingStrategy } from "../enums/IdentifierMintingStrategy.js";
 import type { TsFeature } from "../enums/TsFeature.js";
 import type { TsObjectDeclarationType } from "../enums/TsObjectDeclarationType.js";
 import type { Visibility } from "../enums/Visibility.js";
@@ -32,10 +31,6 @@ export declare class ObjectType extends AbstractType {
      * class targets).
      */
     readonly fromRdfType: Maybe<NamedNode>;
-    /**
-     * Strategy for minting new object identifiers.
-     */
-    readonly identifierMintingStrategy: Maybe<IdentifierMintingStrategy>;
     /**
      * Identifier type.
      */
@@ -73,11 +68,10 @@ export declare class ObjectType extends AbstractType {
      * Whether to generate a TypeScript class or interface for this type.
      */
     readonly tsObjectDeclarationType: TsObjectDeclarationType;
-    constructor({ abstract, extern, fromRdfType, identifierMintingStrategy, identifierType, synthetic, toRdfTypes, tsFeatures, tsImports, tsObjectDeclarationType, ...superParameters }: {
+    constructor({ abstract, extern, fromRdfType, identifierType, synthetic, toRdfTypes, tsFeatures, tsImports, tsObjectDeclarationType, ...superParameters }: {
         abstract: boolean;
         extern: boolean;
         fromRdfType: Maybe<NamedNode>;
-        identifierMintingStrategy: Maybe<IdentifierMintingStrategy>;
         identifierType: BlankNodeType | IdentifierType | IriType;
         synthetic: boolean;
         toRdfTypes: readonly NamedNode[];
@@ -100,7 +94,6 @@ export declare class ObjectType extends AbstractType {
     sortProperties(): void;
     toJSON(): {
         fromRdfType: NamedNode<string> | undefined;
-        identifierMintingStrategy: "blankNode" | "sha256" | "uuidv4" | undefined;
         identifierType: {
             hasValues: readonly NamedNode<string>[] | undefined;
             in: readonly NamedNode<string>[] | undefined;

package/dist/ast/ObjectType.js

@@ -62,10 +62,6 @@ export class ObjectType extends AbstractType {
      * class targets).
      */
     fromRdfType;
-    /**
-     * Strategy for minting new object identifiers.
-     */
-    identifierMintingStrategy;
     /**
      * Identifier type.
      */
@@ -103,12 +99,11 @@ export class ObjectType extends AbstractType {
      * Whether to generate a TypeScript class or interface for this type.
      */
     tsObjectDeclarationType;
-    constructor({ abstract, extern, fromRdfType, identifierMintingStrategy, identifierType, synthetic, toRdfTypes, tsFeatures, tsImports, tsObjectDeclarationType, ...superParameters }) {
+    constructor({ abstract, extern, fromRdfType, identifierType, synthetic, toRdfTypes, tsFeatures, tsImports, tsObjectDeclarationType, ...superParameters }) {
         super(superParameters);
         this.abstract = abstract;
         this.extern = extern;
         this.fromRdfType = fromRdfType;
-        this.identifierMintingStrategy = identifierMintingStrategy;
         this.identifierType = identifierType;
         this.synthetic = synthetic;
         this.toRdfTypes = toRdfTypes;
@@ -171,7 +166,6 @@ export class ObjectType extends AbstractType {
         return {
             ...super.toJSON(),
             fromRdfType: this.fromRdfType.extract(),
-            identifierMintingStrategy: this.identifierMintingStrategy.extract(),
             identifierType: this.identifierType.toJSON(),
             parentObjectTypes: this.parentObjectTypes.length > 0
                 ? this.parentObjectTypes.map((parentObjectType) => parentObjectType.name.extract() ??

package/dist/generators/ts/AbstractUnionType.js

@@ -239,7 +239,7 @@ ${joinCode(this.concreteMembers.map(({ type, typeCheck, unwrap }) => code `if ($
 ${joinCode([
             ...this.identifierType
                 .map((identifierType) => code `\
-if (filter.${syntheticNamePrefix}identifier !== undefined && !${identifierType.filterFunction}(filter.${syntheticNamePrefix}identifier, value.${syntheticNamePrefix}identifier)) {
+if (filter.${syntheticNamePrefix}identifier !== undefined && !${identifierType.filterFunction}(filter.${syntheticNamePrefix}identifier, value.${syntheticNamePrefix}identifier())) {
   return false;
 }`)
                 .toList(),

package/dist/generators/ts/ListType.d.ts

@@ -1,6 +1,4 @@
 import type { NamedNode } from "@rdfjs/types";
-import type { Maybe } from "purify-ts";
-import type { IdentifierMintingStrategy } from "../../enums/IdentifierMintingStrategy.js";
 import { AbstractCollectionType } from "./AbstractCollectionType.js";
 import type { AnonymousUnionType } from "./AnonymousUnionType.js";
 import type { BigDecimalType } from "./BigDecimalType.js";
@@ -22,13 +20,11 @@ import type { TermType } from "./TermType.js";
 import type { Type } from "./Type.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class ListType<ItemTypeT extends ListType.ItemType> extends AbstractCollectionType<ItemTypeT> {
-    private readonly identifierMintingStrategy;
     private readonly identifierNodeKind;
     private readonly toRdfTypes;
     readonly kind = "ListType";
-    constructor({ identifierNodeKind, identifierMintingStrategy, toRdfTypes, ...superParameters }: {
+    constructor({ identifierNodeKind, toRdfTypes, ...superParameters }: {
         identifierNodeKind: ListType<ItemTypeT>["identifierNodeKind"];
-        identifierMintingStrategy: Maybe<IdentifierMintingStrategy>;
         toRdfTypes: readonly NamedNode[];
     } & ConstructorParameters<typeof AbstractCollectionType<ItemTypeT>>[0]);
     get valueSparqlConstructTriplesFunction(): Code;