@shaclmate/compiler 4.0.94 → 4.0.95

package/dist/Eithers.d.ts

@@ -1,5 +1,6 @@
-import type { Either } from "purify-ts";
+import { Either } from "purify-ts";
 export declare namespace Eithers {
+    function chainMap<OldT, NewT>(oldValues: readonly OldT[], callback: (value: OldT, index: number) => Either<Error, NewT>): Either<Error, readonly NewT[]>;
     function chain2<R1, R2>(either1: Either<Error, R1>, either2: Either<Error, R2>): Either<Error, [R1, R2]>;
     function chain3<R1, R2, R3>(either1: Either<Error, R1>, either2: Either<Error, R2>, either3: Either<Error, R3>): Either<Error, [R1, R2, R3]>;
     function chain4<R1, R2, R3, R4>(either1: Either<Error, R1>, either2: Either<Error, R2>, either3: Either<Error, R3>, either4: Either<Error, R4>): Either<Error, [R1, R2, R3, R4]>;

package/dist/Eithers.js

@@ -1,5 +1,20 @@
+import { Either } from "purify-ts";
 export var Eithers;
 (function (Eithers) {
+    function chainMap(oldValues, callback) {
+        const newValues = [];
+        let valueI = 0;
+        for (const oldValue of oldValues) {
+            const callbackResult = callback(oldValue, valueI);
+            if (callbackResult.isLeft()) {
+                return callbackResult;
+            }
+            newValues.push(callbackResult.extract());
+            valueI++;
+        }
+        return Either.of(newValues);
+    }
+    Eithers.chainMap = chainMap;
     function chain2(either1, either2) {
         return either1.chain((r1) => either2.map((r2) => [r1, r2]));
     }

package/dist/ShapesGraphToAstTransformer.js

@@ -1,6 +1,7 @@
 import { TermMap } from "@rdfx/collection";
 import { Either } from "purify-ts";
 import { ShapeStack } from "./_ShapesGraphToAstTransformer/ShapeStack.js";
+// import { transformService } from "./_ShapesGraphToAstTransformer/transformService.js";
 import { transformShapeToAstType } from "./_ShapesGraphToAstTransformer/transformShapeToAstType.js";
 export class ShapesGraphToAstTransformer {
     // Members are protected so they're accessible to functions in other files
@@ -30,6 +31,14 @@ export class ShapesGraphToAstTransformer {
                 astNamedTypes.push(nodeShapeAstType);
             });
         }
+        const astServices = [];
+        // for (const inputService of this.shapesGraph.services) {
+        //   const astServiceEither = transformService.call(this, inputService);
+        //   if (astServiceEither.isLeft()) {
+        //     return astServiceEither;
+        //   }
+        //   astServices.push(astServiceEither.extract() as ast.Service);
+        // }
         return Either.of({
             lazyTypesCount: [...this.cachedAstTypesByShapeIdentifier.values()].reduce((acc, astType) => {
                 switch (astType.kind) {
@@ -42,6 +51,7 @@ export class ShapesGraphToAstTransformer {
                 }
             }, 0),
             namedTypes: astNamedTypes.concat(this.syntheticAstStructTypes),
+            services: astServices,
         });
     }
 }

package/dist/_ShapesGraphToAstTransformer/ShapeStack.d.ts

@@ -9,7 +9,7 @@ export declare class ShapeStack {
         readonly in_: readonly (Literal | NamedNode)[];
     };
     get defaultValue(): Maybe<Literal | NamedNode>;
-    pop(shape: input.Shape): this;
-    push(shape: input.Shape): this;
+    pop(shape: input.UndiscriminatedShape): this;
+    push(shape: input.UndiscriminatedShape): this;
 }
 //# sourceMappingURL=ShapeStack.d.ts.map

package/dist/_ShapesGraphToAstTransformer/ShapeStack.js

@@ -1,5 +1,6 @@
 import { Maybe } from "purify-ts";
 import { invariant } from "ts-invariant";
+import { isPropertyShape } from "./isPropertyShape.js";
 export class ShapeStack {
     stack = [];
     constructor() {
@@ -27,7 +28,7 @@ export class ShapeStack {
     constraints;
     get defaultValue() {
         for (const shape of this.stack.toReversed()) {
-            if (shape.$type !== "PropertyShape") {
+            if (!isPropertyShape(shape)) {
                 continue;
             }
             if (shape.defaultValue.isJust()) {

package/dist/_ShapesGraphToAstTransformer/isNodeShape.d.ts

@@ -0,0 +1,3 @@
+import type * as input from "../input/index.js";
+export declare function isNodeShape(shape: input.UndiscriminatedShape): shape is input.NodeShape;
+//# sourceMappingURL=isNodeShape.d.ts.map

package/dist/_ShapesGraphToAstTransformer/isNodeShape.js

@@ -0,0 +1,4 @@
+export function isNodeShape(shape) {
+    return !("path" in shape);
+}
+//# sourceMappingURL=isNodeShape.js.map

package/dist/_ShapesGraphToAstTransformer/isPropertyShape.d.ts

@@ -0,0 +1,3 @@
+import type * as input from "../input/index.js";
+export declare function isPropertyShape(shape: input.UndiscriminatedShape): shape is input.PropertyShape;
+//# sourceMappingURL=isPropertyShape.d.ts.map

package/dist/_ShapesGraphToAstTransformer/isPropertyShape.js

@@ -0,0 +1,4 @@
+export function isPropertyShape(shape) {
+    return "path" in shape;
+}
+//# sourceMappingURL=isPropertyShape.js.map

package/dist/_ShapesGraphToAstTransformer/shapeAstTypeName.d.ts

@@ -1,4 +1,5 @@
 import { Maybe } from "purify-ts";
 import type * as input from "../input/index.js";
-export declare function shapeAstTypeName(shape: input.Shape): Maybe<string>;
+import type { ShapesGraphToAstTransformer } from "../ShapesGraphToAstTransformer.js";
+export declare function shapeAstTypeName(this: ShapesGraphToAstTransformer, shape: input.UndiscriminatedShape): Maybe<string>;
 //# sourceMappingURL=shapeAstTypeName.d.ts.map

package/dist/_ShapesGraphToAstTransformer/shapeAstTypeName.js

@@ -1,7 +1,8 @@
-import { Curie } from "@shaclmate/shacl-ast";
+import { Curie } from "@rdfx/curie";
 import { Maybe } from "purify-ts";
+import { isNodeShape } from "./isNodeShape.js";
 export function shapeAstTypeName(shape) {
-    if (shape.$type !== "NodeShape") {
+    if (!isNodeShape(shape)) {
         return Maybe.empty();
     }
     const shapeIdentifier = shape.$identifier();
@@ -14,7 +15,7 @@ export function shapeAstTypeName(shape) {
     }
     // CURIE shape identifier
     if (shapeIdentifier instanceof Curie) {
-        if (shapeIdentifier.hasUniqueReference) {
+        if (this.shapesGraph.uniqueCurieReferences.has(shapeIdentifier.reference)) {
             return Maybe.of(shapeIdentifier.reference);
         }
         return Maybe.of(`${shapeIdentifier.prefix}_${shapeIdentifier.reference}`);

package/dist/_ShapesGraphToAstTransformer/shapeNodeKinds.d.ts

@@ -2,7 +2,7 @@ import { NodeKind } from "@shaclmate/shacl-ast";
 import { Either } from "purify-ts";
 import type * as input from "../input/index.js";
 import type { ShapesGraphToAstTransformer } from "../ShapesGraphToAstTransformer.js";
-export declare function shapeNodeKinds(this: ShapesGraphToAstTransformer, shape: input.Shape, options?: {
+export declare function shapeNodeKinds(this: ShapesGraphToAstTransformer, shape: input.UndiscriminatedShape, options?: {
     defaultNodeShapeNodeKinds: ReadonlySet<NodeKind>;
     defaultPropertyShapeNodeKinds?: ReadonlySet<NodeKind>;
 }): Either<Error, ReadonlySet<NodeKind>>;

package/dist/_ShapesGraphToAstTransformer/shapeNodeKinds.js

@@ -1,6 +1,9 @@
 import { NodeKind } from "@shaclmate/shacl-ast";
 import { Either, Left, Maybe } from "purify-ts";
+import { invariant } from "ts-invariant";
 import { defaultNodeShapeNodeKinds } from "./defaultNodeShapeNodeKinds.js";
+import { isNodeShape } from "./isNodeShape.js";
+import { isPropertyShape } from "./isPropertyShape.js";
 const defaultPropertyShapeNodeKinds = new Set([
     "BlankNode",
     "IRI",
@@ -31,7 +34,7 @@ export function shapeNodeKinds(shape, options) {
         [
             "sh:defaultValue",
             {
-                includeNodeKinds: shape.$type === "PropertyShape"
+                includeNodeKinds: isPropertyShape(shape)
                     ? shape.defaultValue
                         .map((value) => NodeKind.fromTermType(value.termType))
                         .toList()
@@ -103,7 +106,7 @@ export function shapeNodeKinds(shape, options) {
         [
             "shaclmate:resolve",
             {
-                includeNodeKinds: (shape.$type === "PropertyShape"
+                includeNodeKinds: (isPropertyShape(shape)
                     ? shape.resolve
                     : Maybe.empty())
                     .chain((resolve) => this.shapesGraph.nodeShape(resolve).toMaybe())
@@ -160,9 +163,10 @@ export function shapeNodeKinds(shape, options) {
     if (constraintNodeKinds.size > 0) {
         return Either.of(constraintNodeKinds);
     }
-    if (shape.$type === "NodeShape") {
+    if (isNodeShape(shape)) {
         return Either.of(options?.defaultNodeShapeNodeKinds ?? defaultNodeShapeNodeKinds);
     }
+    invariant(isPropertyShape(shape));
     if (shape.path.termType === "InversePath") {
         // Inverse paths can only have blank nodes and IRIs as values, because the value is the subject of a triple.
         return Either.of(new Set(["BlankNode", "IRI"]));

package/dist/_ShapesGraphToAstTransformer/shapeOntology.d.ts

@@ -1,5 +1,5 @@
 import { Either, Maybe } from "purify-ts";
 import type * as input from "../input/index.js";
 import type { ShapesGraphToAstTransformer } from "../ShapesGraphToAstTransformer.js";
-export declare function shapeOntology(this: ShapesGraphToAstTransformer, shape: input.Shape): Either<Error, Maybe<input.Ontology>>;
+export declare function shapeOntology(this: ShapesGraphToAstTransformer, shape: input.UndiscriminatedShape): Either<Error, Maybe<input.Ontology>>;
 //# sourceMappingURL=shapeOntology.d.ts.map

package/dist/_ShapesGraphToAstTransformer/transformPropertyShapeToAstStructTypeField.d.ts

@@ -13,5 +13,5 @@ import type { ShapesGraphToAstTransformer } from "../ShapesGraphToAstTransformer
 export declare function transformPropertyShapeToAstStructTypeField(this: ShapesGraphToAstTransformer, { propertyShape, structType, }: {
     propertyShape: input.PropertyShape;
     structType: ast.StructType;
-}): Either<Error, Maybe<ast.StructType.Field>>;
+}): Either<Error, Maybe<ast.StructType.ShaclField>>;
 //# sourceMappingURL=transformPropertyShapeToAstStructTypeField.d.ts.map

package/dist/_ShapesGraphToAstTransformer/transformPropertyShapeToAstStructTypeField.js

@@ -1,5 +1,5 @@
+import { Curie } from "@rdfx/curie";
 import dataFactory from "@rdfx/data-factory";
-import { Curie } from "@shaclmate/shacl-ast";
 import { sh } from "@tpluscode/rdf-ns-builders";
 import { Either, Left, Maybe } from "purify-ts";
 import { invariant } from "ts-invariant";
@@ -48,11 +48,23 @@ function fieldName(propertyShape, structType) {
     }
     throw new Error(`${propertyShape}: unable to infer name`);
 }
+function propertyCardinality(propertyShape) {
+    let maxCount = propertyShape.maxCount.orDefault(BigInt(Number.MAX_SAFE_INTEGER));
+    let minCount = propertyShape.minCount.orDefault(0n);
+    if (minCount < 0n) {
+        minCount = 0n;
+    }
+    if (propertyShape.hasValues.length > minCount) {
+        minCount = BigInt(propertyShape.hasValues.length);
+    }
+    if (maxCount < minCount) {
+        maxCount = minCount;
+    }
+    return { maxCount, minCount };
+}
 function synthesizePartialAstStructType({ identifierType, }) {
     let syntheticName;
     switch (identifierType.kind) {
-        case "BlankNode":
-            throw new Error("should never happen");
         case "Identifier":
             syntheticName = "DefaultPartial";
             break;
@@ -77,6 +89,10 @@ function synthesizePartialAstStructType({ identifierType, }) {
         toRdfTypes: [],
         tsImports: [],
     });
+    partialAstStructType.addField(new ast.StructType.IdentifierField({
+        structType: partialAstStructType,
+        type: identifierType,
+    }));
     this.syntheticAstStructTypes.push(partialAstStructType);
     return partialAstStructType;
 }
@@ -89,17 +105,7 @@ function transformPropertyShapeToAstType(propertyShape, shapeStack) {
     return transformShapeToAstType
         .call(this, propertyShape, shapeStack)
         .chain((propertyShapeAstType) => {
-        let maxCount = propertyShape.maxCount.orDefault(BigInt(Number.MAX_SAFE_INTEGER));
-        let minCount = propertyShape.minCount.orDefault(0n);
-        if (minCount < 0n) {
-            minCount = 0n;
-        }
-        if (propertyShape.hasValues.length > minCount) {
-            minCount = BigInt(propertyShape.hasValues.length);
-        }
-        if (maxCount < minCount) {
-            maxCount = minCount;
-        }
+        const { maxCount, minCount } = propertyCardinality(propertyShape);
         if (propertyShapeAstType.kind === "DefaultValue") {
             if (minCount > 0n) {
                 return Left(new Error(`${propertyShape}: has sh:minCount > 0 and sh:defaultValue`));
@@ -197,7 +203,6 @@ export function transformPropertyShapeToAstStructTypeField({ propertyShape, stru
             }
             let astPartialItemType;
             switch (astItemType.kind) {
-                case "BlankNode":
                 case "Identifier":
                 case "Iri":
                     astPartialItemType = synthesizePartialAstStructType.call(this, {
@@ -216,6 +221,18 @@ export function transformPropertyShapeToAstStructTypeField({ propertyShape, stru
                 default:
                     return Left(new Error(`${propertyShape} has a resolve with an incompatible partial type ${astItemType.kind}`));
             }
+            const astPartialItemIdentifierType = astPartialItemType.kind === "Struct"
+                ? astPartialItemType.identifierType
+                : ast.StructCompoundType.identifierType(astPartialItemType);
+            const astResolveItemIdentifierType = astResolveItemType.kind === "Struct"
+                ? astResolveItemType.identifierType
+                : ast.StructCompoundType.identifierType(astResolveItemType);
+            if (astPartialItemIdentifierType.kind !== astResolveItemIdentifierType.kind) {
+                return Left(new Error(`${propertyShape} has a resolve with a different identifier type (${astResolveItemIdentifierType.kind}) than the partial's identifier type (${astPartialItemIdentifierType.kind})`));
+            }
+            if (astPartialItemIdentifierType.kind === "BlankNode") {
+                return Left(new Error(`${propertyShape} has a ${astPartialItemIdentifierType.kind} identifier type, which is incompatible with shaclmate:resolve`));
+            }
             const astAbstractTypeProperties = {
                 comment: Maybe.empty(),
                 label: Maybe.empty(),
@@ -268,11 +285,12 @@ export function transformPropertyShapeToAstStructTypeField({ propertyShape, stru
             astType.nodeKinds.has("Literal")) {
             return Left(new Error(`${propertyShape}: property shapes with inverse paths can only have blank node or IRI node kinds`));
         }
-        return Either.of(Maybe.of(new ast.StructType.Field({
+        return Either.of(Maybe.of(new ast.StructType.ShaclField({
             comment: propertyShape.comment,
             description: propertyShape.description,
             display: propertyShape.display,
             label: propertyShape.label,
+            minCount: propertyCardinality(propertyShape).minCount,
             mutable: propertyShape.mutable.orDefault(false),
             name: fieldName.call(this, propertyShape, structType),
             order: propertyShape.order.orDefault(0),

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstCompoundType.d.ts

@@ -6,5 +6,5 @@ import type { ShapeStack } from "./ShapeStack.js";
 /**
  * Try to convert a shape to a compound type (intersection or union) using some heuristics.
  */
-export declare function transformShapeToAstCompoundType(this: ShapesGraphToAstTransformer, shape: input.Shape, shapeStack: ShapeStack): Either<Error, Maybe<ast.Type>>;
+export declare function transformShapeToAstCompoundType(this: ShapesGraphToAstTransformer, shape: input.UndiscriminatedShape, shapeStack: ShapeStack): Either<Error, Maybe<ast.Type>>;
 //# sourceMappingURL=transformShapeToAstCompoundType.d.ts.map

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstCompoundType.js

@@ -2,6 +2,7 @@ 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 { isNodeShape } from "./isNodeShape.js";
 import { shapeAstTypeName } from "./shapeAstTypeName.js";
 import { transformShapeToAstType } from "./transformShapeToAstType.js";
 /**
@@ -37,7 +38,7 @@ export function transformShapeToAstCompoundType(shape, shapeStack) {
                 : ast.DiscriminatedUnionType)({
                 comment: shape.comment,
                 label: shape.label,
-                name: shapeAstTypeName(shape),
+                name: shapeAstTypeName.call(this, shape),
                 shapeIdentifier: shape.$identifier(),
                 synthetic: false,
             });
@@ -62,7 +63,7 @@ export function transformShapeToAstCompoundType(shape, shapeStack) {
                     }
                     let memberDiscriminantValue;
                     if (compoundTypeKind === "DiscriminatedUnion") {
-                        if (memberShape.$type === "NodeShape") {
+                        if (isNodeShape(memberShape)) {
                             memberDiscriminantValue =
                                 memberShape.discriminantValue.extract();
                         }

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstListType.d.ts

@@ -7,5 +7,5 @@ import type { ShapeStack } from "./ShapeStack.js";
  * Is an ast.StructType actually the shape of an RDF list?
  * If so, return the type of its rdf:first.
  */
-export declare function transformShapeToAstListType(this: ShapesGraphToAstTransformer, shape: input.Shape, shapeStack: ShapeStack): Either<Error, Maybe<ast.ListType>>;
+export declare function transformShapeToAstListType(this: ShapesGraphToAstTransformer, shape: input.UndiscriminatedShape, shapeStack: ShapeStack): Either<Error, Maybe<ast.ListType>>;
 //# sourceMappingURL=transformShapeToAstListType.d.ts.map

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstListType.js

@@ -4,6 +4,7 @@ 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 { isNodeShape } from "./isNodeShape.js";
 import { shapeNodeKinds } from "./shapeNodeKinds.js";
 import { transformPropertyShapeToAstStructTypeField } from "./transformPropertyShapeToAstStructTypeField.js";
 const listPropertiesStructType = new ast.StructType({
@@ -37,7 +38,7 @@ const empty = Either.of(Maybe.empty());
 export function transformShapeToAstListType(shape, shapeStack) {
     shapeStack.push(shape);
     try {
-        if (shape.$type !== "NodeShape") {
+        if (!isNodeShape(shape)) {
             return empty;
         }
         const nodeShape = shape;
@@ -67,8 +68,7 @@ export function transformShapeToAstListType(shape, shapeStack) {
                         shape.hasValues[0].equals(rdf.nil)) {
                         emptyListShape = shape;
                     }
-                    else if (shape.$type === "NodeShape" &&
-                        shape.properties.length >= 2) {
+                    else if (isNodeShape(shape) && shape.properties.length >= 2) {
                         nonEmptyListShape = shape;
                     }
                 }

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstStructType.d.ts

@@ -3,5 +3,5 @@ import * as ast from "../ast/index.js";
 import type * as input from "../input/index.js";
 import type { ShapesGraphToAstTransformer } from "../ShapesGraphToAstTransformer.js";
 import type { ShapeStack } from "./ShapeStack.js";
-export declare function transformShapeToAstStructType(this: ShapesGraphToAstTransformer, shape: input.Shape, shapeStack: ShapeStack): Either<Error, Maybe<ast.Type>>;
+export declare function transformShapeToAstStructType(this: ShapesGraphToAstTransformer, shape: input.UndiscriminatedShape, shapeStack: ShapeStack): Either<Error, Maybe<ast.Type>>;
 //# sourceMappingURL=transformShapeToAstStructType.d.ts.map

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstStructType.js

@@ -4,40 +4,78 @@ import { invariant } from "ts-invariant";
 import * as ast from "../ast/index.js";
 import { Eithers } from "../Eithers.js";
 import { defaultNodeShapeNodeKinds } from "./defaultNodeShapeNodeKinds.js";
+import { isNodeShape } from "./isNodeShape.js";
 import { shapeAstTypeName } from "./shapeAstTypeName.js";
 import { shapeNodeKinds } from "./shapeNodeKinds.js";
 import { transformPropertyShapeToAstStructTypeField } from "./transformPropertyShapeToAstStructTypeField.js";
 import { transformShapeToAstType } from "./transformShapeToAstType.js";
 function isStructTypeFieldRequired(field) {
-    switch (field.type.kind) {
-        case "DefaultValue":
-            return false;
-        case "LazyOption":
-            return false;
-        case "LazySet":
-            return field.type.partialType.minCount > 0n;
-        case "Option":
-            return false;
-        case "Set":
-            return field.type.minCount > 0;
-        case "DiscriminatedUnion":
-            return field.type.members.every((member) => isStructTypeFieldRequired({ type: member.type }));
-        case "BlankNode":
+    switch (field.kind) {
         case "Identifier":
-        case "Iri":
-        case "Lazy":
-        case "List":
-        case "Literal":
-        case "Struct":
-        case "Term":
-            return true;
-        case "Intersection":
-            throw new Error("unsupported");
+            return field.type.kind === "Iri";
+        case "Shacl": {
+            switch (field.type.kind) {
+                case "DiscriminatedUnion":
+                    return field.type.members.every((member) => isStructTypeFieldRequired({ kind: "Shacl", type: member.type }));
+                case "DefaultValue":
+                    return false;
+                case "Intersection":
+                    return field.type.members.every((member) => isStructTypeFieldRequired({ kind: "Shacl", type: member.type }));
+                case "LazyOption":
+                    return false;
+                case "LazySet":
+                    return field.type.partialType.minCount > 0n;
+                case "Option":
+                    return false;
+                case "Set":
+                    return field.type.minCount > 0;
+                case "BlankNode":
+                case "Identifier":
+                case "Iri":
+                case "Lazy":
+                case "List":
+                case "Literal":
+                case "Struct":
+                case "Term":
+                    return true;
+                default:
+                    field.type;
+                    throw new Error("should never reach this point");
+            }
+        }
         default:
-            field.type;
+            field.kind;
             throw new Error("should never reach this point");
     }
 }
+function transformNodeShapeNodeKindsToAstIdentifierType(nodeKinds, nodeShape) {
+    const identifierTypeProperties = {
+        comment: Maybe.empty(),
+        label: Maybe.empty(),
+        name: Maybe.empty(),
+        shapeIdentifier: nodeShape.$identifier(),
+    };
+    if (nodeKinds.size === 2) {
+        invariant(nodeShape.in_.isNothing());
+        return new ast.IdentifierType(identifierTypeProperties);
+    }
+    const nodeKind = [...nodeKinds][0];
+    switch (nodeKind) {
+        case "BlankNode":
+            invariant(nodeShape.in_.isNothing());
+            return new ast.BlankNodeType(identifierTypeProperties);
+        case "IRI":
+            return new ast.IriType({
+                ...identifierTypeProperties,
+                hasValues: [],
+                in_: nodeShape.in_
+                    .orDefault([])
+                    .filter((_) => _.termType === "NamedNode"),
+            });
+        default:
+            throw new Error("should never happen");
+    }
+}
 export function transformShapeToAstStructType(shape, shapeStack) {
     shapeStack.push(shape);
     try {
@@ -48,7 +86,7 @@ export function transformShapeToAstStructType(shape, shapeStack) {
                 .chain((nodeShape) => transformShapeToAstType.call(this, nodeShape, shapeStack))
                 .map(Maybe.of);
         }
-        if (shape.$type !== "NodeShape") {
+        if (!isNodeShape(shape)) {
             return Either.of(Maybe.empty());
         }
         const nodeShape = shape;
@@ -88,37 +126,7 @@ export function transformShapeToAstStructType(shape, shapeStack) {
             if (nodeKinds.has("Literal")) {
                 return Left(new Error(`${nodeShape} should not have a nodeKind "Literal"`));
             }
-            let identifierType;
-            const identifierTypeProperties = {
-                comment: Maybe.empty(),
-                label: Maybe.empty(),
-                name: Maybe.empty(),
-                shapeIdentifier: nodeShape.$identifier(),
-            };
-            if (nodeKinds.size === 2) {
-                invariant(nodeShape.in_.isNothing());
-                identifierType = new ast.IdentifierType(identifierTypeProperties);
-            }
-            else {
-                switch ([...nodeKinds][0]) {
-                    case "BlankNode":
-                        invariant(nodeShape.in_.isNothing());
-                        identifierType = new ast.BlankNodeType(identifierTypeProperties);
-                        break;
-                    case "IRI":
-                        identifierType = new ast.IriType({
-                            ...identifierTypeProperties,
-                            hasValues: [],
-                            in_: nodeShape.in_
-                                .orDefault([])
-                                .filter((_) => _.termType === "NamedNode"),
-                        });
-                        break;
-                    default:
-                        throw new Error("should never happen");
-                }
-            }
-            invariant(identifierType);
+            const identifierType = transformNodeShapeNodeKindsToAstIdentifierType.call(this, nodeKinds, nodeShape);
             // Put a placeholder in the cache to deal with cyclic references
             // Remove the placeholder if the transformation fails.
             // If this node shape's properties (directly or indirectly) refer to the node shape itself,
@@ -127,30 +135,43 @@ export function transformShapeToAstStructType(shape, shapeStack) {
                 comment: nodeShape.comment,
                 extern: nodeShape.extern.orDefault(false),
                 fromRdfType,
-                label: nodeShape.label,
                 identifierType,
-                name: shapeAstTypeName(nodeShape),
+                label: nodeShape.label,
+                name: shapeAstTypeName.call(this, nodeShape),
                 shapeIdentifier: nodeShape.$identifier(),
                 synthetic: false,
                 toRdfTypes,
                 tsImports: nodeShape.tsImports,
             });
+            if (identifierType.kind !== "BlankNode") {
+                structType.addField(new ast.StructType.IdentifierField({
+                    structType,
+                    type: identifierType,
+                }));
+            }
             this.cachedAstTypesByShapeIdentifier.set(nodeShape.$identifier(), structType);
             return (() => {
-                // Populate properties
+                // Populate fields
+                const fieldNames = new Set();
                 for (const propertyShape of propertyShapes) {
-                    const fieldEither = transformPropertyShapeToAstStructTypeField.call(this, {
+                    const fieldEither = transformPropertyShapeToAstStructTypeField
+                        .call(this, {
                         propertyShape,
                         structType,
+                    })
+                        .chain((fieldMaybe) => {
+                        const field = fieldMaybe.extract();
+                        if (field) {
+                            if (fieldNames.has(field.name)) {
+                                return Left(new Error(`${nodeShape} has duplicate property name: ${field.name}`));
+                            }
+                            structType.addField(field);
+                        }
+                        return Either.of(undefined);
                     });
                     if (fieldEither.isLeft()) {
                         return fieldEither;
                     }
-                    fieldEither.ifRight((property) => {
-                        property.ifJust((property) => {
-                            structType.addFields(property);
-                        });
-                    });
                 }
                 if (!structType.extern &&
                     structType.fromRdfType.isNothing() &&

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstTermType.d.ts

@@ -7,6 +7,6 @@ type AstTermType = ast.BlankNodeType | ast.DefaultValueType<ast.IdentifierType |
 /**
  * Try to convert a shape to an AST TermType using some heuristics.
  */
-export declare function transformShapeToAstTermType(this: ShapesGraphToAstTransformer, shape: input.Shape, shapeStack: ShapeStack): Either<Error, AstTermType>;
+export declare function transformShapeToAstTermType(this: ShapesGraphToAstTransformer, shape: input.UndiscriminatedShape, shapeStack: ShapeStack): Either<Error, AstTermType>;
 export {};
 //# sourceMappingURL=transformShapeToAstTermType.d.ts.map

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstTermType.js

@@ -14,7 +14,7 @@ export function transformShapeToAstTermType(shape, shapeStack) {
             const in_ = shapeStack.constraints.in_;
             const astAbstractTypeProperties = {
                 comment: Maybe.empty(),
-                name: shapeAstTypeName(shape),
+                name: shapeAstTypeName.call(this, shape),
                 label: Maybe.empty(),
                 shapeIdentifier: shape.$identifier(),
             };

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstType.d.ts

@@ -7,5 +7,5 @@ import type { ShapeStack } from "./ShapeStack.js";
  * Try to transform a shape to an AST type using some heuristics. All shape -> AST type transformation calls should go through this function,
  * not the other transformShapeToAst*Type functions directly.
  */
-export declare function transformShapeToAstType(this: ShapesGraphToAstTransformer, shape: input.Shape, shapeStack: ShapeStack): Either<Error, ast.Type>;
+export declare function transformShapeToAstType(this: ShapesGraphToAstTransformer, shape: input.UndiscriminatedShape, shapeStack: ShapeStack): Either<Error, ast.Type>;
 //# sourceMappingURL=transformShapeToAstType.d.ts.map

package/dist/ast/AbstractCollectionType.d.ts

@@ -15,12 +15,12 @@ export declare abstract class AbstractCollectionType<ItemTypeT extends AbstractC
     toJSON(): {
         mutable: boolean | undefined;
         itemType: any;
-        comment: string | undefined;
         kind: string;
-        label: string | undefined;
         name: string | undefined;
         recursive: boolean | undefined;
         shapeIdentifier: import("@rdfjs/types").BlankNode | import("@rdfjs/types").NamedNode<string>;
+        comment: string | undefined;
+        label: string | undefined;
     };
 }
 export declare namespace AbstractCollectionType {