@shaclmate/compiler 4.0.41 → 4.0.42

package/dist/ShapesGraphToAstTransformer.d.ts

@@ -6,6 +6,7 @@ import type * as ast from "./ast/index.js";
 import type * as input from "./input/index.js";
 export declare class ShapesGraphToAstTransformer {
     protected readonly cachedAstTypesByShapeIdentifier: TermMap<BlankNode | NamedNode, ast.Type>;
+    protected readonly syntheticAstStructTypesByName: Map<string, ast.StructType>;
     protected readonly logger: Logger;
     protected readonly shapesGraph: input.ShapesGraph;
     constructor({ logger, shapesGraph, }: {

package/dist/ShapesGraphToAstTransformer.js

@@ -1,12 +1,11 @@
 import TermMap from "@rdfjs/term-map";
-import { dash } from "@tpluscode/rdf-ns-builders";
 import { Either } from "purify-ts";
-import { invariant } from "ts-invariant";
 import { ShapeStack } from "./_ShapesGraphToAstTransformer/ShapeStack.js";
 import { transformShapeToAstType } from "./_ShapesGraphToAstTransformer/transformShapeToAstType.js";
 export class ShapesGraphToAstTransformer {
     // Members are protected so they're accessible to functions in other files
     cachedAstTypesByShapeIdentifier = new TermMap();
+    syntheticAstStructTypesByName = new Map();
     logger;
     shapesGraph;
     constructor({ logger, shapesGraph, }) {
@@ -15,67 +14,33 @@ export class ShapesGraphToAstTransformer {
     }
     transform() {
         const astNamedTypes = [];
-        const syntheticAstObjectTypesByName = {};
         for (const nodeShape of this.shapesGraph.nodeShapes) {
             if (nodeShape.$identifier().termType !== "NamedNode") {
                 continue;
             }
-            if (nodeShape.$identifier().value.startsWith(dash[""].value)) {
-                continue;
-            }
             const nodeShapeAstTypeEither = transformShapeToAstType.call(this, nodeShape, new ShapeStack());
             if (nodeShapeAstTypeEither.isLeft()) {
                 return nodeShapeAstTypeEither;
             }
             const nodeShapeAstType = nodeShapeAstTypeEither.unsafeCoerce();
-            switch (nodeShapeAstType.kind) {
-                case "Intersection":
-                case "Union":
-                    if (nodeShapeAstType.name.isJust()) {
-                        astNamedTypes.push(nodeShapeAstType);
-                    }
-                    break;
-                case "Object": {
-                    invariant(nodeShapeAstType.name.isJust(), `node shape missing name: ${nodeShapeAstType.shapeIdentifier}`);
-                    astNamedTypes.push(nodeShapeAstType);
-                    for (const property of nodeShapeAstType.properties) {
-                        switch (property.type.kind) {
-                            case "LazyObjectOption":
-                            case "LazyObjectSet":
-                            case "LazyObject": {
-                                const partialItemType = property.type.partialType.kind === "Object" ||
-                                    property.type.partialType.kind === "Union"
-                                    ? property.type.partialType
-                                    : property.type.partialType.itemType;
-                                if (partialItemType.kind === "Object" &&
-                                    partialItemType.synthetic) {
-                                    const partialItemTypeName = partialItemType.name.unsafeCoerce();
-                                    if (!syntheticAstObjectTypesByName[partialItemTypeName]) {
-                                        syntheticAstObjectTypesByName[partialItemTypeName] =
-                                            partialItemType;
-                                    }
-                                }
-                            }
-                        }
-                    }
-                    break;
-                }
-                default:
-                    break;
-            }
+            nodeShapeAstType.name.ifJust(() => {
+                astNamedTypes.push(nodeShapeAstType);
+            });
         }
         return Either.of({
             lazyTypesCount: [...this.cachedAstTypesByShapeIdentifier.values()].reduce((acc, astType) => {
                 switch (astType.kind) {
-                    case "LazyObject":
-                    case "LazyObjectOption":
-                    case "LazyObjectSet":
+                    case "Lazy":
+                    case "LazyOption":
+                    case "LazySet":
                         return acc + 1;
                     default:
                         return acc;
                 }
             }, 0),
-            namedTypes: astNamedTypes.concat(Object.values(syntheticAstObjectTypesByName)),
+            namedTypes: astNamedTypes.concat([
+                ...this.syntheticAstStructTypesByName.values(),
+            ]),
         });
     }
 }

package/dist/_ShapesGraphToAstTransformer/transformPropertyShapeToAstStructTypeField.d.ts

@@ -0,0 +1,17 @@
+import { Either, Maybe } from "purify-ts";
+import * as ast from "../ast/index.js";
+import type * as input from "../input/index.js";
+import type { ShapesGraphToAstTransformer } from "../ShapesGraphToAstTransformer.js";
+/**
+ * Try to transform a property shape to an ast.StructType.Field.
+ *
+ * Returns:
+ *  - Right<Just<ast.StructType.Field>> if the transformation succeeds
+ *  - Right<Nothing> if the property shape should be ignored
+ *  - Left<Error> if the transformation fails
+ */
+export declare function transformPropertyShapeToAstStructTypeField(this: ShapesGraphToAstTransformer, { propertyShape, structType, }: {
+    propertyShape: input.PropertyShape;
+    structType: ast.StructType;
+}): Either<Error, Maybe<ast.StructType.Field>>;
+//# sourceMappingURL=transformPropertyShapeToAstStructTypeField.d.ts.map

package/dist/_ShapesGraphToAstTransformer/{transformPropertyShapeToAstObjectTypeProperty.js → transformPropertyShapeToAstStructTypeField.js}

@@ -1,37 +1,13 @@
 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";
 import * as ast from "../ast/index.js";
 import { Eithers } from "../Eithers.js";
 import { ShapeStack } from "./ShapeStack.js";
 import { transformShapeToAstType } from "./transformShapeToAstType.js";
-function synthesizePartialAstObjectType({ identifierType, }) {
-    let syntheticName;
-    switch (identifierType.kind) {
-        case "BlankNode":
-            throw new Error("should never happen");
-        case "Identifier":
-            syntheticName = "DefaultPartial";
-            break;
-        case "Iri":
-            syntheticName = "NamedDefaultPartial";
-            break;
-    }
-    return new ast.ObjectType({
-        comment: Maybe.empty(),
-        extern: false,
-        fromRdfType: Maybe.empty(),
-        identifierType,
-        label: Maybe.empty(),
-        name: Maybe.of(syntheticName),
-        shapeIdentifier: dataFactory.namedNode(`urn:shaclmate:synthetic:${syntheticName}`),
-        synthetic: true,
-        toRdfTypes: [],
-        tsImports: [],
-    });
-}
-function propertyName(objectType, propertyShape) {
+function fieldName(propertyShape, structType) {
     // Explicit shaclmate:name or sh:name
     const name = propertyShape.shaclmateName.alt(propertyShape.name).extract();
     if (name) {
@@ -46,8 +22,8 @@ function propertyName(objectType, propertyShape) {
     // like ex:NodeShape-property
     const propertyShapeIdentifier = propertyShape.$identifier();
     if (propertyShapeIdentifier.termType === "NamedNode" &&
-        objectType.shapeIdentifier.termType === "NamedNode") {
-        const propertyShapeIdentifierPrefix = `${objectType.shapeIdentifier.value}-`;
+        structType.shapeIdentifier.termType === "NamedNode") {
+        const propertyShapeIdentifierPrefix = `${structType.shapeIdentifier.value}-`;
         if (propertyShapeIdentifier.value.startsWith(propertyShapeIdentifierPrefix) &&
             propertyShapeIdentifier.value.length >
                 propertyShapeIdentifierPrefix.length) {
@@ -72,6 +48,37 @@ function propertyName(objectType, propertyShape) {
     }
     throw new Error(`${propertyShape}: unable to infer name`);
 }
+function synthesizePartialAstStructType({ identifierType, }) {
+    let syntheticName;
+    switch (identifierType.kind) {
+        case "BlankNode":
+            throw new Error("should never happen");
+        case "Identifier":
+            syntheticName = "DefaultPartial";
+            break;
+        case "Iri":
+            syntheticName = "NamedDefaultPartial";
+            break;
+    }
+    let partialAstStructType = this.syntheticAstStructTypesByName.get(syntheticName);
+    if (partialAstStructType) {
+        return partialAstStructType;
+    }
+    partialAstStructType = new ast.StructType({
+        comment: Maybe.empty(),
+        extern: false,
+        fromRdfType: Maybe.empty(),
+        identifierType,
+        label: Maybe.empty(),
+        name: Maybe.of(syntheticName),
+        shapeIdentifier: dataFactory.namedNode(`urn:shaclmate:synthetic:${syntheticName}`),
+        synthetic: true,
+        toRdfTypes: [],
+        tsImports: [],
+    });
+    this.syntheticAstStructTypesByName.set(syntheticName, partialAstStructType);
+    return partialAstStructType;
+}
 function transformPropertyShapeToAstType(propertyShape, shapeStack) {
     // if (
     //   propertyShape.path.kind === "PredicatePath" &&
@@ -122,7 +129,23 @@ function transformPropertyShapeToAstType(propertyShape, shapeStack) {
         }));
     });
 }
-export function transformPropertyShapeToAstObjectTypeProperty({ objectType, propertyShape, }) {
+/**
+ * Try to transform a property shape to an ast.StructType.Field.
+ *
+ * Returns:
+ *  - Right<Just<ast.StructType.Field>> if the transformation succeeds
+ *  - Right<Nothing> if the property shape should be ignored
+ *  - Left<Error> if the transformation fails
+ */
+export function transformPropertyShapeToAstStructTypeField({ propertyShape, structType, }) {
+    if (propertyShape.ignore) {
+        return Either.of(Maybe.empty());
+    }
+    switch (propertyShape.severity.orDefault(sh.Violation).value) {
+        case "http://www.w3.org/ns/shacl#Info":
+        case "http://www.w3.org/ns/shacl#Warning":
+            return Either.of(Maybe.empty());
+    }
     const shapeStack = new ShapeStack(); // Start a new ShapeStack per property shape
     return Eithers.chain2(propertyShape.resolve.isJust()
         ? this.shapesGraph
@@ -135,14 +158,14 @@ export function transformPropertyShapeToAstObjectTypeProperty({ objectType, prop
                 .call(this, propertyShapeResolve.unsafeCoerce(), shapeStack)
                 .chain((astResolveType) => {
                 switch (astResolveType.kind) {
-                    case "Object":
+                    case "Struct":
                         return Either.of(astResolveType);
                     case "Union":
                         if (
                         // This check relies on .members being populated, which may not happen in cycles
                         astResolveType.members.length > 0 &&
-                            !astResolveType.isObjectUnionType()) {
-                            return Left(new Error(`${propertyShape} resolve cannot refer to a ${astResolveType.kind} with non-ObjectType members`));
+                            !astResolveType.isStructUnionType()) {
+                            return Left(new Error(`${propertyShape} resolve cannot refer to a ${astResolveType.kind} with non-StructType members`));
                         }
                         return Either.of(astResolveType);
                     default:
@@ -162,10 +185,10 @@ export function transformPropertyShapeToAstObjectTypeProperty({ objectType, prop
                 case "Set":
                     astItemType = astType.itemType;
                     break;
-                case "LazyObjectOption":
-                case "LazyObjectSet":
+                case "LazyOption":
+                case "LazySet":
                 // biome-ignore lint/suspicious/noFallthroughSwitchClause: break is unreachable
-                case "LazyObject":
+                case "Lazy":
                     invariant(false, `lazy types should not appear here: ${astType.kind}`);
                 default:
                     astItemType = astType;
@@ -176,16 +199,16 @@ export function transformPropertyShapeToAstObjectTypeProperty({ objectType, prop
                 case "BlankNode":
                 case "Identifier":
                 case "Iri":
-                    astPartialItemType = synthesizePartialAstObjectType({
+                    astPartialItemType = synthesizePartialAstStructType.call(this, {
                         identifierType: astItemType,
                     });
                     break;
-                case "Object":
+                case "Struct":
                     astPartialItemType = astItemType;
                     break;
                 case "Union":
-                    if (!astItemType.isObjectUnionType()) {
-                        return Left(new Error(`${propertyShape} partial type cannot be a ${astItemType.kind} with non-ObjectType members`));
+                    if (!astItemType.isStructUnionType()) {
+                        return Left(new Error(`${propertyShape} partial type cannot be a ${astItemType.kind} with non-StructType members`));
                     }
                     astPartialItemType = astItemType;
                     break;
@@ -202,16 +225,16 @@ export function transformPropertyShapeToAstObjectTypeProperty({ objectType, prop
                 case "BlankNode":
                 case "Identifier":
                 case "Iri":
-                case "Object":
+                case "Struct":
                 case "Union":
-                    astType = new ast.LazyObjectType({
+                    astType = new ast.LazyType({
                         ...astAbstractTypeProperties,
                         partialType: astPartialItemType,
                         resolveType: astResolveItemType,
                     });
                     break;
                 case "Option":
-                    astType = new ast.LazyObjectOptionType({
+                    astType = new ast.LazyOptionType({
                         ...astAbstractTypeProperties,
                         partialType: new ast.OptionType({
                             itemType: astPartialItemType,
@@ -222,7 +245,7 @@ export function transformPropertyShapeToAstObjectTypeProperty({ objectType, prop
                     });
                     break;
                 case "Set":
-                    astType = new ast.LazyObjectSetType({
+                    astType = new ast.LazySetType({
                         ...astAbstractTypeProperties,
                         partialType: new ast.SetType({
                             itemType: astPartialItemType,
@@ -244,19 +267,19 @@ export function transformPropertyShapeToAstObjectTypeProperty({ objectType, prop
             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(new ast.ObjectType.Property({
+        return Either.of(Maybe.of(new ast.StructType.Field({
             comment: propertyShape.comment,
             description: propertyShape.description,
             display: propertyShape.display,
             label: propertyShape.label,
             mutable: propertyShape.mutable.orDefault(false),
-            name: propertyName.call(this, objectType, propertyShape),
-            objectType,
+            name: fieldName.call(this, propertyShape, structType),
             order: propertyShape.order.orDefault(0),
             path: propertyShape.path,
             shapeIdentifier: propertyShape.$identifier(),
+            structType,
             type: astType,
-        }));
+        })));
     });
 }
-//# sourceMappingURL=transformPropertyShapeToAstObjectTypeProperty.js.map
+//# sourceMappingURL=transformPropertyShapeToAstStructTypeField.js.map

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstListType.d.ts

@@ -4,7 +4,7 @@ import type * as input from "../input/index.js";
 import type { ShapesGraphToAstTransformer } from "../ShapesGraphToAstTransformer.js";
 import type { ShapeStack } from "./ShapeStack.js";
 /**
- * Is an ast.ObjectType actually the shape of an RDF list?
+ * 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>>;

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstListType.js

@@ -4,10 +4,9 @@ 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 { shapeAstTypeName } from "./shapeAstTypeName.js";
 import { shapeNodeKinds } from "./shapeNodeKinds.js";
-import { transformPropertyShapeToAstObjectTypeProperty } from "./transformPropertyShapeToAstObjectTypeProperty.js";
-const listPropertiesObjectType = new ast.ObjectType({
+import { transformPropertyShapeToAstStructTypeField } from "./transformPropertyShapeToAstStructTypeField.js";
+const listPropertiesStructType = new ast.StructType({
     extern: false,
     comment: Maybe.empty(),
     label: Maybe.empty(),
@@ -32,7 +31,7 @@ const astListTypePlaceholderItemType = new ast.BlankNodeType({
 });
 const empty = Either.of(Maybe.empty());
 /**
- * Is an ast.ObjectType actually the shape of an RDF list?
+ * Is an ast.StructType actually the shape of an RDF list?
  * If so, return the type of its rdf:first.
  */
 export function transformShapeToAstListType(shape, shapeStack) {
@@ -53,7 +52,9 @@ export function transformShapeToAstListType(shape, shapeStack) {
                 itemType: astListTypePlaceholderItemType,
                 label: nodeShape.label,
                 mutable: nodeShape.mutable.orDefault(false),
-                name: shapeAstTypeName(nodeShape),
+                // name: shapeAstTypeName(nodeShape),
+                // List types don't need names currently
+                name: Maybe.empty(),
                 shapeIdentifier: nodeShape.$identifier(),
                 toRdfTypes: nodeShape.toRdfTypes,
             });
@@ -74,10 +75,10 @@ export function transformShapeToAstListType(shape, shapeStack) {
                 if (!emptyListShape || !nonEmptyListShape) {
                     return empty;
                 }
-                return Either.sequence(nonEmptyListShape.properties.map((propertyShapeIdentifier) => this.shapesGraph.propertyShape(propertyShapeIdentifier))).chain((nonEmptyListShapeProperties) => {
+                return Either.sequence(nonEmptyListShape.properties.map((propertyShapeIdentifier) => this.shapesGraph.propertyShape(propertyShapeIdentifier))).chain((nonEmptyListShapePropertyShapes) => {
                     let firstPropertyShape;
                     let restPropertyShape;
-                    for (const propertyShape of nonEmptyListShapeProperties) {
+                    for (const propertyShape of nonEmptyListShapePropertyShapes) {
                         if (propertyShape.path.termType !== "NamedNode") {
                             continue;
                         }
@@ -102,26 +103,34 @@ export function transformShapeToAstListType(shape, shapeStack) {
                         restPropertyShape.minCount.extract() !== 1n) {
                         return Left(new Error(`${nodeShape} non-empty list shape rdf:rest property shape does not have sh:maxCount=1 and/or sh:minCount=1`));
                     }
-                    return transformPropertyShapeToAstObjectTypeProperty
+                    return transformPropertyShapeToAstStructTypeField
                         .call(this, {
-                        // Just need a dummy ast.ObjectType here to get the properties transformed.
-                        objectType: listPropertiesObjectType,
+                        // Just need a dummy ast.StructType here to get the properties transformed.
                         propertyShape: firstPropertyShape,
+                        structType: listPropertiesStructType,
                     })
-                        .chain((firstProperty) => {
-                        if (!ast.ListType.isItemType(firstProperty.type)) {
-                            return Left(new Error(`${nodeShape}: ${firstProperty.type.kind} is not a valid list item type`));
+                        .chain((firstFieldMaybe) => {
+                        const firstField = firstFieldMaybe.extract();
+                        if (!firstField) {
+                            return Left(new Error(`${nodeShape}: rdf:first field is ignored`));
                         }
-                        listType.itemType = firstProperty.type;
-                        return transformPropertyShapeToAstObjectTypeProperty
+                        if (!ast.ListType.isItemType(firstField.type)) {
+                            return Left(new Error(`${nodeShape}: ${firstField.type.kind} is not a valid list item type`));
+                        }
+                        listType.itemType = firstField.type;
+                        return transformPropertyShapeToAstStructTypeField
                             .call(this, {
-                            // Just need a dummy ast.ObjectType here to get the properties transformed.
-                            objectType: listPropertiesObjectType,
+                            // Just need a dummy ast.StructType here to get the properties transformed.
                             propertyShape: restPropertyShape,
+                            structType: listPropertiesStructType,
                         })
-                            .chain((restProperty) => {
-                            if (restProperty.type.kind !== "List" ||
-                                !restProperty.type.shapeIdentifier.equals(nodeShape.$identifier())) {
+                            .chain((restFieldMaybe) => {
+                            const restField = restFieldMaybe.extract();
+                            if (!restField) {
+                                return Left(new Error(`${nodeShape}: rdf:rest field is ignored`));
+                            }
+                            if (restField.type.kind !== "List" ||
+                                !restField.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));

package/dist/_ShapesGraphToAstTransformer/{transformShapeToAstObjectType.d.ts → 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 transformShapeToAstObjectType(this: ShapesGraphToAstTransformer, shape: input.Shape, shapeStack: ShapeStack): Either<Error, Maybe<ast.Type>>;
-//# sourceMappingURL=transformShapeToAstObjectType.d.ts.map
+export declare function transformShapeToAstStructType(this: ShapesGraphToAstTransformer, shape: input.Shape, shapeStack: ShapeStack): Either<Error, Maybe<ast.Type>>;
+//# sourceMappingURL=transformShapeToAstStructType.d.ts.map

package/dist/_ShapesGraphToAstTransformer/{transformShapeToAstObjectType.js → transformShapeToAstStructType.js}

@@ -6,41 +6,42 @@ import { Eithers } from "../Eithers.js";
 import { defaultNodeShapeNodeKinds } from "./defaultNodeShapeNodeKinds.js";
 import { shapeAstTypeName } from "./shapeAstTypeName.js";
 import { shapeNodeKinds } from "./shapeNodeKinds.js";
-import { transformPropertyShapeToAstObjectTypeProperty } from "./transformPropertyShapeToAstObjectTypeProperty.js";
+import { transformPropertyShapeToAstStructTypeField } from "./transformPropertyShapeToAstStructTypeField.js";
 import { transformShapeToAstType } from "./transformShapeToAstType.js";
-function isObjectTypePropertyRequired(property) {
-    switch (property.type.kind) {
+function isStructTypeFieldRequired(field) {
+    switch (field.type.kind) {
         case "DefaultValue":
             return false;
-        case "LazyObjectOption":
+        case "LazyOption":
             return false;
-        case "LazyObjectSet":
-            return property.type.partialType.minCount > 0n;
+        case "LazySet":
+            return field.type.partialType.minCount > 0n;
         case "Option":
             return false;
         case "Set":
-            return property.type.minCount > 0;
+            return field.type.minCount > 0;
         case "Union":
-            return property.type.members.every((member) => isObjectTypePropertyRequired({ type: member.type }));
+            return field.type.members.every((member) => isStructTypeFieldRequired({ type: member.type }));
         case "BlankNode":
         case "Identifier":
         case "Iri":
-        case "LazyObject":
+        case "Lazy":
         case "List":
         case "Literal":
-        case "Object":
+        case "Struct":
         case "Term":
             return true;
         case "Intersection":
             throw new Error("unsupported");
         default:
-            property.type;
+            field.type;
             throw new Error("should never reach this point");
     }
 }
-export function transformShapeToAstObjectType(shape, shapeStack) {
+export function transformShapeToAstStructType(shape, shapeStack) {
     shapeStack.push(shape);
     try {
+        // If the shape has an sh:node itself then transform that instead
         if (shape.node.isJust()) {
             return this.shapesGraph
                 .nodeShape(shape.node.unsafeCoerce())
@@ -55,9 +56,12 @@ export function transformShapeToAstObjectType(shape, shapeStack) {
             nodeShape.xone.orDefault([]).length > 0) {
             return Either.of(Maybe.empty());
         }
-        if (nodeShape.$identifier().termType !== "NamedNode") {
-            return Either.of(Maybe.empty());
-        }
+        if (!nodeShape.extern.orDefault(false)) {
+            if (nodeShape.properties.length === 0) {
+                // A node shape must have sh:property to be considered a StructType
+                return Either.of(Maybe.empty());
+            }
+        } // else assume all extern node shapes are structs
         return Eithers.chain2(shapeNodeKinds.call(this, nodeShape, { defaultNodeShapeNodeKinds }), Either.sequence(nodeShape.properties.map((propertyShapeIdentifier) => this.shapesGraph.propertyShape(propertyShapeIdentifier)))).chain(([nodeKinds, propertyShapes]) => {
             const nodeShapeIdentifier = nodeShape.$identifier();
             const isClass = nodeShape.subClassOf.length > 0 ||
@@ -114,7 +118,7 @@ export function transformShapeToAstObjectType(shape, shapeStack) {
             // Remove the placeholder if the transformation fails.
             // 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({
+            const structType = new ast.StructType({
                 comment: nodeShape.comment,
                 extern: nodeShape.extern.orDefault(false),
                 fromRdfType,
@@ -126,28 +130,30 @@ export function transformShapeToAstObjectType(shape, shapeStack) {
                 toRdfTypes,
                 tsImports: nodeShape.tsImports,
             });
-            this.cachedAstTypesByShapeIdentifier.set(nodeShape.$identifier(), objectType);
+            this.cachedAstTypesByShapeIdentifier.set(nodeShape.$identifier(), structType);
             return (() => {
                 // Populate properties
                 for (const propertyShape of propertyShapes) {
-                    const propertyEither = transformPropertyShapeToAstObjectTypeProperty.call(this, {
-                        objectType,
+                    const fieldEither = transformPropertyShapeToAstStructTypeField.call(this, {
                         propertyShape,
+                        structType,
                     });
-                    if (propertyEither.isLeft()) {
-                        return propertyEither;
+                    if (fieldEither.isLeft()) {
+                        return fieldEither;
                     }
-                    propertyEither.ifRight((property) => {
-                        objectType.addProperties(property);
+                    fieldEither.ifRight((property) => {
+                        property.ifJust((property) => {
+                            structType.addFields(property);
+                        });
                     });
                 }
-                if (!objectType.extern &&
-                    objectType.fromRdfType.isNothing() &&
-                    !objectType.properties.some(isObjectTypePropertyRequired)) {
+                if (!structType.extern &&
+                    structType.fromRdfType.isNothing() &&
+                    !structType.fields.some(isStructTypeFieldRequired)) {
                     return Left(new Error(`${nodeShape} has no required properties and no implicitly required rdf:type`));
                 }
-                objectType.sortProperties();
-                return Either.of(Maybe.of(objectType));
+                structType.sortFields();
+                return Either.of(Maybe.of(structType));
             })().ifLeft(() => {
                 this.cachedAstTypesByShapeIdentifier.delete(nodeShape.$identifier());
             });
@@ -157,4 +163,4 @@ export function transformShapeToAstObjectType(shape, shapeStack) {
         shapeStack.pop(shape);
     }
 }
-//# sourceMappingURL=transformShapeToAstObjectType.js.map
+//# sourceMappingURL=transformShapeToAstStructType.js.map

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstTermType.js

@@ -1,6 +1,7 @@
 import { Either, Left, Maybe } from "purify-ts";
 import { invariant } from "ts-invariant";
 import * as ast from "../ast/index.js";
+import { shapeAstTypeName } from "./shapeAstTypeName.js";
 import { shapeNodeKinds } from "./shapeNodeKinds.js";
 /**
  * Try to convert a shape to an AST TermType using some heuristics.
@@ -13,7 +14,7 @@ export function transformShapeToAstTermType(shape, shapeStack) {
             const in_ = shapeStack.constraints.in_;
             const astAbstractTypeProperties = {
                 comment: Maybe.empty(),
-                name: Maybe.empty(),
+                name: shapeAstTypeName(shape),
                 label: Maybe.empty(),
                 shapeIdentifier: shape.$identifier(),
             };

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstType.d.ts

@@ -4,7 +4,7 @@ import type * as input from "../input/index.js";
 import type { ShapesGraphToAstTransformer } from "../ShapesGraphToAstTransformer.js";
 import type { ShapeStack } from "./ShapeStack.js";
 /**
- * Try to convert a shape to a type using some heuristics. All shape -> AST type transformation calls should go through this function,
+ * 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>;

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstType.js

@@ -1,15 +1,15 @@
 import { Either } from "purify-ts";
 import { transformShapeToAstCompoundType } from "./transformShapeToAstCompoundType.js";
 import { transformShapeToAstListType } from "./transformShapeToAstListType.js";
-import { transformShapeToAstObjectType } from "./transformShapeToAstObjectType.js";
+import { transformShapeToAstStructType } from "./transformShapeToAstStructType.js";
 import { transformShapeToAstTermType } from "./transformShapeToAstTermType.js";
 const tryTransformShapeToAstTypeMethods = [
     transformShapeToAstListType, // List type must be before compound type since a list shape uses sh:xone
     transformShapeToAstCompoundType,
-    transformShapeToAstObjectType,
+    transformShapeToAstStructType,
 ];
 /**
- * Try to convert a shape to a type using some heuristics. All shape -> AST type transformation calls should go through this function,
+ * 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 function transformShapeToAstType(shape, shapeStack) {

package/dist/ast/AbstractCompoundType.d.ts

@@ -6,7 +6,7 @@ import type { IntersectionType } from "./IntersectionType.js";
 import type { IriType } from "./IriType.js";
 import type { ListType } from "./ListType.js";
 import type { LiteralType } from "./LiteralType.js";
-import type { ObjectType } from "./ObjectType.js";
+import type { StructType } from "./StructType.js";
 import type { TermType } from "./TermType.js";
 import type { Type } from "./Type.js";
 import type { UnionType } from "./UnionType.js";
@@ -39,7 +39,7 @@ export declare namespace AbstractCompoundType {
     interface Member<TypeT extends MemberType> {
         readonly type: TypeT;
     }
-    type MemberType = BlankNodeType | IdentifierType | IntersectionType | IriType | ListType | LiteralType | ObjectType | TermType | UnionType;
+    type MemberType = BlankNodeType | IdentifierType | IntersectionType | IriType | ListType | LiteralType | StructType | TermType | UnionType;
     function isMemberType(type: Type): type is MemberType;
 }
 //# sourceMappingURL=AbstractCompoundType.d.ts.map