@shaclmate/compiler 4.0.96 → 4.0.98

package/dist/_ShapesGraphToAstTransformer/synthesizePartialAstStructType.d.ts

@@ -0,0 +1,6 @@
+import * as ast from "../ast/index.js";
+import type { ShapesGraphToAstTransformer } from "../ShapesGraphToAstTransformer.js";
+export declare function synthesizePartialAstStructType(this: ShapesGraphToAstTransformer, { identifierType, }: {
+    identifierType: ast.IdentifierType | ast.IriType;
+}): ast.StructType;
+//# sourceMappingURL=synthesizePartialAstStructType.d.ts.map

package/dist/_ShapesGraphToAstTransformer/synthesizePartialAstStructType.js

@@ -0,0 +1,38 @@
+import dataFactory from "@rdfx/data-factory";
+import { Maybe } from "purify-ts";
+import * as ast from "../ast/index.js";
+export function synthesizePartialAstStructType({ identifierType, }) {
+    let syntheticName;
+    switch (identifierType.kind) {
+        case "Identifier":
+            syntheticName = "DefaultPartial";
+            break;
+        case "Iri":
+            syntheticName = "NamedDefaultPartial";
+            break;
+    }
+    let partialAstStructType = this.syntheticAstStructTypes.find((syntheticAstStructType) => syntheticAstStructType.name.extract() === syntheticName &&
+        ast.Type.equals(syntheticAstStructType.identifierType, identifierType));
+    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: [],
+    });
+    partialAstStructType.addField(new ast.StructType.IdentifierField({
+        structType: partialAstStructType,
+        type: identifierType,
+    }));
+    this.syntheticAstStructTypes.push(partialAstStructType);
+    return partialAstStructType;
+}
+//# sourceMappingURL=synthesizePartialAstStructType.js.map

package/dist/_ShapesGraphToAstTransformer/transformPropertyShapeToAstStructTypeField.js

@@ -1,11 +1,11 @@
 import { Curie } from "@rdfx/curie";
-import dataFactory from "@rdfx/data-factory";
 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 { synthesizePartialAstStructType } from "./synthesizePartialAstStructType.js";
 import { transformShapeToAstType } from "./transformShapeToAstType.js";
 function fieldName(propertyShape, structType) {
     // Explicit shaclmate:name or sh:name
@@ -62,41 +62,7 @@ function propertyCardinality(propertyShape) {
     }
     return { maxCount, minCount };
 }
-function synthesizePartialAstStructType({ identifierType, }) {
-    let syntheticName;
-    switch (identifierType.kind) {
-        case "Identifier":
-            syntheticName = "DefaultPartial";
-            break;
-        case "Iri":
-            syntheticName = "NamedDefaultPartial";
-            break;
-    }
-    let partialAstStructType = this.syntheticAstStructTypes.find((syntheticAstStructType) => syntheticAstStructType.name.extract() === syntheticName &&
-        ast.Type.equals(syntheticAstStructType.identifierType, identifierType));
-    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: [],
-    });
-    partialAstStructType.addField(new ast.StructType.IdentifierField({
-        structType: partialAstStructType,
-        type: identifierType,
-    }));
-    this.syntheticAstStructTypes.push(partialAstStructType);
-    return partialAstStructType;
-}
-function transformPropertyShapeToAstType(propertyShape, shapeStack) {
+function transformPropertyShapeToAstCardinalityType(propertyShape, shapeStack) {
     // if (
     //   propertyShape.path.kind === "PredicatePath" &&
     //   propertyShape.path.iri.value.endsWith("termProperty")
@@ -136,102 +102,78 @@ function transformPropertyShapeToAstType(propertyShape, shapeStack) {
         }));
     });
 }
-/**
- * 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) {
+function transformPropertyShapeToAstLazyType({ propertyShape, propertyShapeAstCardinalityType, shapeStack, }) {
+    if (propertyShape.resolve.isNothing()) {
         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
-            .nodeShape(propertyShape.resolve.extract())
-            .map(Maybe.of)
-        : Either.of(Maybe.empty()), transformPropertyShapeToAstType.call(this, propertyShape, shapeStack)).chain(([propertyShapeResolve, astType]) => {
-        let astResolveItemType;
-        if (propertyShapeResolve.isJust()) {
-            const astResolveTypeEither = transformShapeToAstType
-                .call(this, propertyShapeResolve.unsafeCoerce(), shapeStack)
-                .chain((astResolveType) => {
-                switch (astResolveType.kind) {
-                    case "Struct":
-                        return Either.of(astResolveType);
-                    case "DiscriminatedUnion":
-                        if (
-                        // This check relies on .members being populated, which may not happen in cycles
-                        astResolveType.members.length > 0 &&
-                            !astResolveType.isStructDiscriminatedUnionType()) {
-                            return Left(new Error(`${propertyShape} resolve cannot refer to a ${astResolveType.kind} with non-StructType members`));
-                        }
-                        return Either.of(astResolveType);
-                    default:
-                        return Left(new Error(`${propertyShape} resolve cannot refer to a ${astResolveType.kind}`));
-                }
-            });
-            if (astResolveTypeEither.isLeft()) {
-                return astResolveTypeEither;
-            }
-            astResolveItemType = astResolveTypeEither.unsafeCoerce();
-        }
-        if (astResolveItemType) {
-            let astItemType;
-            switch (astType.kind) {
-                case "DefaultValue":
-                case "Option":
-                case "Set":
-                    astItemType = astType.itemType;
-                    break;
-                case "LazyOption":
-                case "LazySet":
-                // biome-ignore lint/suspicious/noFallthroughSwitchClause: break is unreachable
-                case "Lazy":
-                    invariant(false, `lazy types should not appear here: ${astType.kind}`);
-                default:
-                    astItemType = astType;
-                    break;
-            }
-            let astPartialItemType;
-            switch (astItemType.kind) {
-                case "Identifier":
-                case "Iri":
-                    astPartialItemType = synthesizePartialAstStructType.call(this, {
-                        identifierType: astItemType,
-                    });
-                    break;
+    return this.shapesGraph
+        .nodeShape(propertyShape.resolve.extract())
+        .chain((resolveNodeShape) => {
+        const resolveAstItemTypeEither = transformShapeToAstType
+            .call(this, resolveNodeShape, shapeStack)
+            .chain((resolveAstItemType) => {
+            switch (resolveAstItemType.kind) {
                 case "Struct":
-                    astPartialItemType = astItemType;
-                    break;
+                    return Either.of(resolveAstItemType);
                 case "DiscriminatedUnion":
-                    if (!astItemType.isStructDiscriminatedUnionType()) {
-                        return Left(new Error(`${propertyShape} partial type cannot be a ${astItemType.kind} with non-StructType members`));
+                    if (
+                    // This check relies on .members being populated, which may not happen in cycles
+                    resolveAstItemType.members.length > 0 &&
+                        !resolveAstItemType.isStructDiscriminatedUnionType()) {
+                        return Left(new Error(`${propertyShape} resolve cannot refer to a ${resolveAstItemType.kind} with non-StructType members`));
                     }
-                    astPartialItemType = astItemType;
-                    break;
+                    return Either.of(resolveAstItemType);
                 default:
-                    return Left(new Error(`${propertyShape} has a resolve with an incompatible partial type ${astItemType.kind}`));
+                    return Left(new Error(`${propertyShape} resolve cannot refer to a ${resolveAstItemType.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 (resolveAstItemTypeEither.isLeft()) {
+            return resolveAstItemTypeEither;
+        }
+        const resolveAstItemType = resolveAstItemTypeEither.unsafeCoerce();
+        let propertyShapeAstItemType;
+        switch (propertyShapeAstCardinalityType.kind) {
+            case "DefaultValue":
+            case "Option":
+            case "Set":
+                propertyShapeAstItemType = propertyShapeAstCardinalityType.itemType;
+                break;
+            case "LazyOption":
+            case "LazySet":
+            // biome-ignore lint/suspicious/noFallthroughSwitchClause: break is unreachable
+            case "Lazy":
+                invariant(false, `lazy types should not appear here: ${propertyShapeAstCardinalityType.kind}`);
+            default:
+                propertyShapeAstItemType = propertyShapeAstCardinalityType;
+                break;
+        }
+        let partialAstItemType;
+        switch (propertyShapeAstItemType.kind) {
+            case "Identifier":
+            case "Iri":
+                partialAstItemType = synthesizePartialAstStructType.call(this, {
+                    identifierType: propertyShapeAstItemType,
+                });
+                break;
+            case "Struct":
+                partialAstItemType = propertyShapeAstItemType;
+                break;
+            case "DiscriminatedUnion":
+                if (!propertyShapeAstItemType.isStructDiscriminatedUnionType()) {
+                    return Left(new Error(`${propertyShape} partial type cannot be a ${propertyShapeAstItemType.kind} with non-StructType members`));
+                }
+                partialAstItemType = propertyShapeAstItemType;
+                break;
+            default:
+                return Left(new Error(`${propertyShape} has a resolve with an incompatible partial type ${propertyShapeAstItemType.kind}`));
+        }
+        return Eithers.chain2(ast.StructCompoundType.identifierType(partialAstItemType), ast.StructCompoundType.identifierType(resolveAstItemType)).chain(([partialAstItemIdentifierType, resolveAstItemIdentifierType]) => {
+            if (partialAstItemIdentifierType.kind !==
+                resolveAstItemIdentifierType.kind) {
+                return Left(new Error(`${propertyShape} has a resolve with a different identifier type (${resolveAstItemIdentifierType.kind}) than the partial's identifier type (${partialAstItemIdentifierType.kind})`));
             }
-            if (astPartialItemIdentifierType.kind === "BlankNode") {
-                return Left(new Error(`${propertyShape} has a ${astPartialItemIdentifierType.kind} identifier type, which is incompatible with shaclmate:resolve`));
+            if (partialAstItemIdentifierType.kind === "BlankNode") {
+                return Left(new Error(`${propertyShape} has a ${partialAstItemIdentifierType.kind} identifier type, which is incompatible with shaclmate:resolve`));
             }
             const astAbstractTypeProperties = {
                 comment: Maybe.empty(),
@@ -239,50 +181,77 @@ export function transformPropertyShapeToAstStructTypeField({ propertyShape, stru
                 name: Maybe.empty(),
                 shapeIdentifier: propertyShape.$identifier(),
             };
-            switch (astType.kind) {
+            switch (propertyShapeAstCardinalityType.kind) {
                 case "BlankNode":
                 case "Identifier":
                 case "Iri":
                 case "Struct":
                 case "DiscriminatedUnion":
-                    astType = new ast.LazyType({
+                    return Either.of(Maybe.of(new ast.LazyType({
                         ...astAbstractTypeProperties,
-                        partialType: astPartialItemType,
-                        resolveType: astResolveItemType,
-                    });
-                    break;
+                        partialType: partialAstItemType,
+                        resolveType: resolveAstItemType,
+                    })));
                 case "Option":
-                    astType = new ast.LazyOptionType({
+                    return Either.of(Maybe.of(new ast.LazyOptionType({
                         ...astAbstractTypeProperties,
                         partialType: new ast.OptionType({
-                            itemType: astPartialItemType,
+                            itemType: partialAstItemType,
                         }),
                         resolveType: new ast.OptionType({
-                            itemType: astResolveItemType,
+                            itemType: resolveAstItemType,
                         }),
-                    });
-                    break;
+                    })));
                 case "Set":
-                    astType = new ast.LazySetType({
+                    return Either.of(Maybe.of(new ast.LazySetType({
                         ...astAbstractTypeProperties,
                         partialType: new ast.SetType({
-                            itemType: astPartialItemType,
+                            itemType: partialAstItemType,
                             minCount: 0n,
                             mutable: false,
                         }),
                         resolveType: new ast.SetType({
-                            itemType: astResolveItemType,
+                            itemType: resolveAstItemType,
                             minCount: 0n,
                             mutable: false,
                         }),
-                    });
-                    break;
+                    })));
                 default:
-                    invariant(false, `unexpected lazy AST type ${astType.kind}`);
+                    invariant(false, `unexpected lazy AST type ${propertyShapeAstCardinalityType.kind}`);
             }
-        }
+        });
+    });
+}
+/**
+ * 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 transformPropertyShapeToAstCardinalityType
+        .call(this, propertyShape, shapeStack)
+        .chain((propertyShapeAstCardinalityType) => transformPropertyShapeToAstLazyType
+        .call(this, {
+        propertyShape,
+        propertyShapeAstCardinalityType,
+        shapeStack,
+    })
+        .chain((propertyShapeAstLazyType) => {
+        const propertyShapeAstType = propertyShapeAstLazyType.orDefault(propertyShapeAstCardinalityType);
         if (propertyShape.path.termType === "InversePath" &&
-            astType.nodeKinds.has("Literal")) {
+            propertyShapeAstType.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.ShaclField({
@@ -297,8 +266,8 @@ export function transformPropertyShapeToAstStructTypeField({ propertyShape, stru
             path: propertyShape.path,
             shapeIdentifier: propertyShape.$identifier(),
             structType,
-            type: astType,
+            type: propertyShapeAstType,
         })));
-    });
+    }));
 }
 //# sourceMappingURL=transformPropertyShapeToAstStructTypeField.js.map

package/dist/_ShapesGraphToAstTransformer/transformShapeNodeConstraintToAstType.d.ts

@@ -0,0 +1,7 @@
+import { Either, Maybe } from "purify-ts";
+import type * 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 transformShapeNodeConstraintToAstType(this: ShapesGraphToAstTransformer, shape: input.UndiscriminatedShape, shapeStack: ShapeStack): Either<Error, Maybe<ast.Type>>;
+//# sourceMappingURL=transformShapeNodeConstraintToAstType.d.ts.map

package/dist/_ShapesGraphToAstTransformer/transformShapeNodeConstraintToAstType.js

@@ -0,0 +1,13 @@
+import { Either, Maybe } from "purify-ts";
+import { transformShapeToAstType } from "./transformShapeToAstType.js";
+export function transformShapeNodeConstraintToAstType(shape, shapeStack) {
+    // If the shape has an sh:node itself then transform that instead
+    if (shape.node.isJust()) {
+        return this.shapesGraph
+            .nodeShape(shape.node.unsafeCoerce())
+            .chain((nodeShape) => transformShapeToAstType.call(this, nodeShape, shapeStack))
+            .map(Maybe.of);
+    }
+    return Either.of(Maybe.empty());
+}
+//# sourceMappingURL=transformShapeNodeConstraintToAstType.js.map

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

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstStructType.js

@@ -8,46 +8,6 @@ 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.kind) {
-        case "Identifier":
-            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.kind;
-            throw new Error("should never reach this point");
-    }
-}
 function transformNodeShapeNodeKindsToAstIdentifierType(nodeKinds, nodeShape) {
     const identifierTypeProperties = {
         comment: Maybe.empty(),
@@ -79,13 +39,6 @@ function transformNodeShapeNodeKindsToAstIdentifierType(nodeKinds, nodeShape) {
 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())
-                .chain((nodeShape) => transformShapeToAstType.call(this, nodeShape, shapeStack))
-                .map(Maybe.of);
-        }
         if (!isNodeShape(shape)) {
             return Either.of(Maybe.empty());
         }
@@ -173,11 +126,6 @@ export function transformShapeToAstStructType(shape, shapeStack) {
                         return fieldEither;
                     }
                 }
-                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`));
-                }
                 structType.sortFields();
                 return Either.of(Maybe.of(structType));
             })().ifLeft(() => {

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstType.js

@@ -1,4 +1,5 @@
 import { Either, Left } from "purify-ts";
+import { transformShapeNodeConstraintToAstType } from "./transformShapeNodeConstraintToAstType.js";
 import { transformShapeToAstCompoundType } from "./transformShapeToAstCompoundType.js";
 import { transformShapeToAstListType } from "./transformShapeToAstListType.js";
 import { transformShapeToAstStructType } from "./transformShapeToAstStructType.js";
@@ -6,6 +7,7 @@ import { transformShapeToAstTermType } from "./transformShapeToAstTermType.js";
 const tryTransformShapeToAstTypeMethods = [
     transformShapeToAstListType, // List type must be before compound type since a list shape uses sh:xone
     transformShapeToAstCompoundType,
+    transformShapeNodeConstraintToAstType,
     transformShapeToAstStructType,
 ];
 /**

package/dist/ast/StructCompoundType.d.ts

@@ -1,3 +1,4 @@
+import { Either } from "purify-ts";
 import { BlankNodeType } from "./BlankNodeType.js";
 import { IdentifierType } from "./IdentifierType.js";
 import { IriType } from "./IriType.js";
@@ -6,7 +7,7 @@ import type { StructIntersectionType } from "./StructIntersectionType.js";
 import type { StructType } from "./StructType.js";
 export type StructCompoundType = StructIntersectionType | StructDiscriminatedUnionType;
 export declare namespace StructCompoundType {
-    function identifierType(structCompoundType: StructCompoundType): BlankNodeType | IdentifierType | IriType;
-    function memberStructTypes(objectCompoundType: StructCompoundType): readonly StructType[];
+    function hasIdentifierField(structCompoundType: StructCompoundType | StructType): boolean;
+    function identifierType(structCompoundType: StructCompoundType | StructType): Either<Error, BlankNodeType | IdentifierType | IriType>;
 }
 //# sourceMappingURL=StructCompoundType.d.ts.map

package/dist/ast/StructCompoundType.js

@@ -1,87 +1,70 @@
 import { TermSet } from "@rdfx/collection";
-import { Maybe } from "purify-ts";
+import { Either, Maybe } from "purify-ts";
 import { invariant } from "ts-invariant";
 import { BlankNodeType } from "./BlankNodeType.js";
 import { IdentifierType } from "./IdentifierType.js";
 import { IriType } from "./IriType.js";
 export var StructCompoundType;
 (function (StructCompoundType) {
+    function hasIdentifierField(structCompoundType) {
+        if (structCompoundType.kind === "Struct") {
+            return structCompoundType.identifierField.isJust();
+        }
+        return structCompoundType.members.every((member) => hasIdentifierField(member.type));
+    }
+    StructCompoundType.hasIdentifierField = hasIdentifierField;
     function identifierType(structCompoundType) {
+        if (structCompoundType.kind === "Struct") {
+            return Either.of(structCompoundType.identifierType);
+        }
         const memberIdentifierTypeNodeKinds = new Set();
         const memberIdentifierTypesIn = new TermSet();
-        for (const memberType of memberStructTypes(structCompoundType)) {
-            for (const nodeKind of memberType.identifierType.nodeKinds) {
-                memberIdentifierTypeNodeKinds.add(nodeKind);
-            }
-            for (const in_ of memberType.identifierType.in_) {
-                memberIdentifierTypesIn.add(in_);
+        for (const member of structCompoundType.members) {
+            const memberIdentifierTypeEither = identifierType(member.type);
+            if (memberIdentifierTypeEither.isLeft()) {
+                return memberIdentifierTypeEither;
             }
+            memberIdentifierTypeEither.ifRight((memberIdentifierType) => {
+                for (const nodeKind of memberIdentifierType.nodeKinds) {
+                    memberIdentifierTypeNodeKinds.add(nodeKind);
+                }
+                for (const in_ of memberIdentifierType.in_) {
+                    memberIdentifierTypesIn.add(in_);
+                }
+            });
         }
         invariant(memberIdentifierTypeNodeKinds.size > 0);
         if (memberIdentifierTypeNodeKinds.size === 2) {
-            return new IdentifierType({
+            return Either.of(new IdentifierType({
                 comment: Maybe.empty(),
                 label: Maybe.empty(),
                 name: Maybe.empty(),
                 shapeIdentifier: structCompoundType.shapeIdentifier,
-            });
+            }));
         }
         const memberIdentifierTypeNodeKind = [...memberIdentifierTypeNodeKinds][0];
         switch (memberIdentifierTypeNodeKind) {
             case "BlankNode":
-                return new BlankNodeType({
+                return Either.of(new BlankNodeType({
                     comment: Maybe.empty(),
                     label: Maybe.empty(),
                     name: Maybe.empty(),
                     shapeIdentifier: structCompoundType.shapeIdentifier,
-                });
+                }));
             case "IRI":
-                return new IriType({
+                return Either.of(new IriType({
                     comment: Maybe.empty(),
                     hasValues: [],
                     in_: [...memberIdentifierTypesIn],
                     label: Maybe.empty(),
                     name: Maybe.empty(),
                     shapeIdentifier: structCompoundType.shapeIdentifier,
-                });
+                }));
             default:
                 memberIdentifierTypeNodeKind;
                 throw new Error("should never reach here");
         }
     }
     StructCompoundType.identifierType = identifierType;
-    function memberStructTypes(objectCompoundType) {
-        const memberStructTypes_ = [];
-        for (const member of objectCompoundType.members) {
-            switch (member.type.kind) {
-                case "Struct":
-                    memberStructTypes_.push(member.type);
-                    break;
-                case "Intersection":
-                case "DiscriminatedUnion": {
-                    invariant(member.type.kind === objectCompoundType.kind);
-                    memberStructTypes_.push(...memberStructTypes(member.type));
-                    break;
-                }
-            }
-        }
-        invariant(memberStructTypes_.length >= objectCompoundType.members.length, "object compound type has no member StructType's");
-        // Member object types must have distinct RDF types or no RDF types at all.
-        const fromRdfTypes = new TermSet();
-        let expectUniqueFromRdfTypesCount = 0;
-        for (const memberStructType of memberStructTypes_) {
-            if (memberStructType.extern) {
-                continue;
-            }
-            expectUniqueFromRdfTypesCount++;
-            memberStructType.fromRdfType.ifJust((fromRdfType) => fromRdfTypes.add(fromRdfType));
-        }
-        if (fromRdfTypes.size > 0 &&
-            fromRdfTypes.size !== expectUniqueFromRdfTypesCount) {
-            throw new Error(`one or more ${objectCompoundType} members ([${memberStructTypes_.map((memberType) => memberType.toString()).join(", ")}]) lack distinguishing fromRdfType's ({${[...fromRdfTypes].join(", ")}})`);
-        }
-        return memberStructTypes_;
-    }
-    StructCompoundType.memberStructTypes = memberStructTypes;
 })(StructCompoundType || (StructCompoundType = {}));
 //# sourceMappingURL=StructCompoundType.js.map

package/dist/ast/StructDiscriminatedUnionType.d.ts

@@ -1,4 +1,8 @@
 import type { DiscriminatedUnionType } from "./DiscriminatedUnionType.js";
+import type { StructIntersectionType } from "./StructIntersectionType.js";
 import type { StructType } from "./StructType.js";
-export type StructDiscriminatedUnionType = DiscriminatedUnionType<DiscriminatedUnionType<StructType> | StructType>;
+export type StructDiscriminatedUnionType = DiscriminatedUnionType<StructDiscriminatedUnionType.MemberType>;
+export declare namespace StructDiscriminatedUnionType {
+    type MemberType = DiscriminatedUnionType<MemberType> | StructIntersectionType | StructType;
+}
 //# sourceMappingURL=StructDiscriminatedUnionType.d.ts.map

package/dist/ast/StructIntersectionType.d.ts

@@ -1,4 +1,7 @@
 import type { IntersectionType } from "./IntersectionType.js";
 import type { StructType } from "./StructType.js";
-export type StructIntersectionType = IntersectionType<IntersectionType<StructType> | StructType>;
+export type StructIntersectionType = IntersectionType<StructIntersectionType.MemberType>;
+export declare namespace StructIntersectionType {
+    type MemberType = IntersectionType<MemberType> | StructType;
+}
 //# sourceMappingURL=StructIntersectionType.d.ts.map