@shaclmate/compiler 4.0.8 → 4.0.10

package/dist/Compiler.d.ts

@@ -1,13 +1,10 @@
-import PrefixMap from "@rdfjs/prefix-map/PrefixMap.js";
 import type { Either } from "purify-ts";
 import type { Generator } from "./generators/Generator.js";
 import type { ShapesGraph } from "./input/ShapesGraph.js";
 export declare class Compiler {
     private readonly generator;
-    private readonly iriPrefixMap;
-    constructor({ generator, iriPrefixMap, }: {
+    constructor({ generator }: {
         generator: Generator;
-        iriPrefixMap?: PrefixMap;
     });
     compile(shapesGraph: ShapesGraph): Either<Error, string>;
 }

package/dist/Compiler.js

@@ -1,15 +1,11 @@
-import PrefixMap from "@rdfjs/prefix-map/PrefixMap.js";
 import { ShapesGraphToAstTransformer } from "./ShapesGraphToAstTransformer.js";
 export class Compiler {
     generator;
-    iriPrefixMap;
-    constructor({ generator, iriPrefixMap, }) {
+    constructor({ generator }) {
         this.generator = generator;
-        this.iriPrefixMap = iriPrefixMap ?? new PrefixMap();
     }
     compile(shapesGraph) {
         return new ShapesGraphToAstTransformer({
-            iriPrefixMap: this.iriPrefixMap,
             shapesGraph,
         })
             .transform()

package/dist/ShapesGraphToAstTransformer.d.ts

@@ -1,23 +1,14 @@
-import type PrefixMap from "@rdfjs/prefix-map/PrefixMap.js";
 import TermMap from "@rdfjs/term-map";
 import type * as rdfjs from "@rdfjs/types";
 import { Either } from "purify-ts";
-import { CurieFactory } from "./_ShapesGraphToAstTransformer/CurieFactory.js";
-import * as _ShapesGraphToAstTransformer from "./_ShapesGraphToAstTransformer/index.js";
 import type * as ast from "./ast/index.js";
 import type { TsFeature } from "./enums/TsFeature.js";
 import type * as input from "./input/index.js";
 export declare class ShapesGraphToAstTransformer {
-    protected readonly curieFactory: CurieFactory;
-    protected readonly nodeShapeAstTypesByIdentifier: TermMap<rdfjs.BlankNode | rdfjs.NamedNode, _ShapesGraphToAstTransformer.NodeShapeAstType>;
+    protected readonly cachedAstTypesByShapeIdentifier: TermMap<rdfjs.BlankNode | rdfjs.NamedNode, ast.Type>;
     protected readonly shapesGraph: input.ShapesGraph;
-    protected shapeIdentifier: typeof _ShapesGraphToAstTransformer.shapeIdentifier;
-    protected transformNodeShapeToAstType: typeof _ShapesGraphToAstTransformer.transformNodeShapeToAstType;
-    protected transformPropertyShapeToAstObjectTypeProperty: typeof _ShapesGraphToAstTransformer.transformPropertyShapeToAstObjectTypeProperty;
-    protected transformShapeToAstType: typeof _ShapesGraphToAstTransformer.transformShapeToAstType;
     protected tsFeaturesDefault: ReadonlySet<TsFeature>;
-    constructor({ iriPrefixMap, shapesGraph, tsFeaturesDefault, }: {
-        iriPrefixMap: PrefixMap;
+    constructor({ shapesGraph, tsFeaturesDefault, }: {
         shapesGraph: input.ShapesGraph;
         tsFeaturesDefault?: ReadonlySet<TsFeature>;
     });

package/dist/ShapesGraphToAstTransformer.js

@@ -1,30 +1,25 @@
 import TermMap from "@rdfjs/term-map";
 import { dash } from "@tpluscode/rdf-ns-builders";
 import { Either } from "purify-ts";
-import { CurieFactory } from "./_ShapesGraphToAstTransformer/CurieFactory.js";
-import * as _ShapesGraphToAstTransformer from "./_ShapesGraphToAstTransformer/index.js";
+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 the bound functions
-    curieFactory;
-    nodeShapeAstTypesByIdentifier = new TermMap();
+    // Members are protected so they're accessible to functions in other files
+    cachedAstTypesByShapeIdentifier = new TermMap();
     shapesGraph;
-    shapeIdentifier = _ShapesGraphToAstTransformer.shapeIdentifier;
-    transformNodeShapeToAstType = _ShapesGraphToAstTransformer.transformNodeShapeToAstType;
-    transformPropertyShapeToAstObjectTypeProperty = _ShapesGraphToAstTransformer.transformPropertyShapeToAstObjectTypeProperty;
-    transformShapeToAstType = _ShapesGraphToAstTransformer.transformShapeToAstType;
     tsFeaturesDefault;
-    constructor({ iriPrefixMap, shapesGraph, tsFeaturesDefault, }) {
-        this.curieFactory = new CurieFactory({ prefixMap: iriPrefixMap });
+    constructor({ shapesGraph, tsFeaturesDefault, }) {
         this.shapesGraph = shapesGraph;
         this.tsFeaturesDefault =
             tsFeaturesDefault ??
                 new Set(["create", "equals", "hash", "json", "rdf"]);
     }
     transform() {
-        const nodeShapeAstObjectIntersectionTypes = [];
-        const nodeShapeAstObjectTypes = [];
+        const astNamedIntersectionTypes = [];
+        const astObjectTypes = [];
         const syntheticAstObjectTypesByName = {};
-        const nodeShapeAstObjectUnionTypes = [];
+        const astNamedUnionTypes = [];
         for (const nodeShape of this.shapesGraph.nodeShapes) {
             if (nodeShape.identifier.termType !== "NamedNode") {
                 continue;
@@ -32,26 +27,27 @@ export class ShapesGraphToAstTransformer {
             if (nodeShape.identifier.value.startsWith(dash[""].value)) {
                 continue;
             }
-            const nodeShapeAstTypeEither = this.transformNodeShapeToAstType(nodeShape);
+            const nodeShapeAstTypeEither = transformShapeToAstType.call(this, nodeShape, new ShapeStack());
             if (nodeShapeAstTypeEither.isLeft()) {
                 return nodeShapeAstTypeEither;
             }
             const nodeShapeAstType = nodeShapeAstTypeEither.unsafeCoerce();
             switch (nodeShapeAstType.kind) {
-                case "ListType":
-                    break; // Ignore
-                case "ObjectIntersectionType":
-                    nodeShapeAstObjectIntersectionTypes.push(nodeShapeAstType);
+                case "IntersectionType":
+                    if (nodeShapeAstType.name.isJust()) {
+                        astNamedIntersectionTypes.push(nodeShapeAstType);
+                    }
                     break;
                 case "ObjectType": {
-                    nodeShapeAstObjectTypes.push(nodeShapeAstType);
+                    invariant(nodeShapeAstType.name.isJust());
+                    astObjectTypes.push(nodeShapeAstType);
                     for (const property of nodeShapeAstType.properties) {
                         switch (property.type.kind) {
                             case "LazyObjectOptionType":
                             case "LazyObjectSetType":
                             case "LazyObjectType": {
                                 const partialItemType = property.type.partialType.kind === "ObjectType" ||
-                                    property.type.partialType.kind === "ObjectUnionType"
+                                    property.type.partialType.kind === "UnionType"
                                     ? property.type.partialType
                                     : property.type.partialType.itemType;
                                 if (partialItemType.kind === "ObjectType" &&
@@ -67,17 +63,19 @@ export class ShapesGraphToAstTransformer {
                     }
                     break;
                 }
-                case "ObjectUnionType":
-                    nodeShapeAstObjectUnionTypes.push(nodeShapeAstType);
+                case "UnionType":
+                    if (nodeShapeAstType.name.isJust()) {
+                        astNamedUnionTypes.push(nodeShapeAstType);
+                    }
                     break;
                 default:
-                    nodeShapeAstType;
+                    break;
             }
         }
         return Either.of({
-            objectIntersectionTypes: nodeShapeAstObjectIntersectionTypes,
-            objectTypes: nodeShapeAstObjectTypes.concat(Object.values(syntheticAstObjectTypesByName)),
-            objectUnionTypes: nodeShapeAstObjectUnionTypes,
+            namedIntersectionTypes: astNamedIntersectionTypes,
+            namedObjectTypes: astObjectTypes.concat(Object.values(syntheticAstObjectTypesByName)),
+            namedUnionTypes: astNamedUnionTypes,
         });
     }
 }

package/dist/_ShapesGraphToAstTransformer/defaultNodeShapeNodeKinds.d.ts

@@ -0,0 +1,3 @@
+import type { NodeKind } from "@shaclmate/shacl-ast";
+export declare const defaultNodeShapeNodeKinds: ReadonlySet<NodeKind>;
+//# sourceMappingURL=defaultNodeShapeNodeKinds.d.ts.map

package/dist/_ShapesGraphToAstTransformer/defaultNodeShapeNodeKinds.js

@@ -0,0 +1,5 @@
+export const defaultNodeShapeNodeKinds = new Set([
+    "BlankNode",
+    "IRI",
+]);
+//# sourceMappingURL=defaultNodeShapeNodeKinds.js.map

package/dist/_ShapesGraphToAstTransformer/shapeAstTypeName.d.ts

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

package/dist/_ShapesGraphToAstTransformer/shapeAstTypeName.js

@@ -0,0 +1,27 @@
+import { Curie } from "@shaclmate/shacl-ast";
+import { Maybe } from "purify-ts";
+export function shapeAstTypeName(shape) {
+    if (shape.kind !== "NodeShape") {
+        return Maybe.empty();
+    }
+    if (shape.identifier.termType !== "NamedNode") {
+        return Maybe.empty();
+    }
+    // Explicit shaclmate:name
+    if (shape.shaclmateName.isJust()) {
+        return shape.shaclmateName;
+    }
+    // Explicit rdfs:label
+    if (shape.label.isJust()) {
+        return shape.label;
+    }
+    // CURIE shape identifier
+    if (shape.identifier instanceof Curie) {
+        if (shape.identifier.hasUniqueReference) {
+            return Maybe.of(shape.identifier.reference);
+        }
+        return Maybe.of(`${shape.identifier.prefix}_${shape.identifier.reference}`);
+    }
+    return Maybe.empty();
+}
+//# sourceMappingURL=shapeAstTypeName.js.map

package/dist/_ShapesGraphToAstTransformer/transformPropertyShapeToAstObjectTypeProperty.js

@@ -1,10 +1,11 @@
 import dataFactory from "@rdfjs/data-model";
+import { Curie } from "@shaclmate/shacl-ast";
 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 { transformShapeToAstAbstractTypeProperties } from "./transformShapeToAstAbstractTypeProperties.js";
+import { transformShapeToAstType } from "./transformShapeToAstType.js";
 function synthesizePartialAstObjectType({ identifierType, tsFeatures, }) {
     let syntheticName;
     switch (identifierType.kind) {
@@ -20,7 +21,6 @@ function synthesizePartialAstObjectType({ identifierType, tsFeatures, }) {
     return new ast.ObjectType({
         abstract: false,
         comment: Maybe.empty(),
-        export_: true,
         extern: false,
         fromRdfType: Maybe.empty(),
         identifierType,
@@ -35,13 +35,55 @@ function synthesizePartialAstObjectType({ identifierType, tsFeatures, }) {
         tsObjectDeclarationType: "class",
     });
 }
-function transformPropertyShapeToAstType(propertyShape) {
+function propertyName(objectType, propertyShape) {
+    // Explicit shaclmate:name or sh:name
+    const name = propertyShape.shaclmateName.alt(propertyShape.name).extract();
+    if (name) {
+        return name;
+    }
+    // Explicit rdfs:label
+    const label = propertyShape.label.extract();
+    if (label) {
+        return label;
+    }
+    // Pick up the common pattern of a property shape identifier being the node shape's identifier -localName,
+    // like ex:NodeShape-property
+    if (propertyShape.identifier.termType === "NamedNode" &&
+        objectType.shapeIdentifier.termType === "NamedNode") {
+        const propertyShapeIdentifierPrefix = `${objectType.shapeIdentifier.value}-`;
+        if (propertyShape.identifier.value.startsWith(propertyShapeIdentifierPrefix) &&
+            propertyShape.identifier.value.length >
+                propertyShapeIdentifierPrefix.length) {
+            return propertyShape.identifier.value.substring(propertyShapeIdentifierPrefix.length);
+        }
+    }
+    // sh:path CURIE reference
+    if (propertyShape.path instanceof Curie) {
+        return propertyShape.path.reference;
+    }
+    // Shape identifier CURIE reference
+    if (propertyShape.identifier instanceof Curie) {
+        return propertyShape.identifier.reference;
+    }
+    // Shape identifier IRI
+    if (propertyShape.identifier.termType === "NamedNode") {
+        return propertyShape.identifier.value;
+    }
+    // sh:path IRI
+    if (propertyShape.path.termType === "NamedNode") {
+        return propertyShape.path.value;
+    }
+    throw new Error(`${propertyShape}: unable to infer name`);
+}
+function transformPropertyShapeToAstType(propertyShape, shapeStack) {
     // if (
     //   propertyShape.path.kind === "PredicatePath" &&
     //   propertyShape.path.iri.value.endsWith("termProperty")
     // ) {
     // }
-    return this.transformShapeToAstType(propertyShape, new ShapeStack()).chain((propertyShapeAstType) => {
+    return transformShapeToAstType
+        .call(this, propertyShape, shapeStack)
+        .chain((propertyShapeAstType) => {
         let maxCount = propertyShape.constraints.maxCount.orDefault(Number.MAX_SAFE_INTEGER);
         let minCount = propertyShape.constraints.minCount.orDefault(0);
         if (minCount < 0) {
@@ -84,17 +126,23 @@ function transformPropertyShapeToAstType(propertyShape) {
     });
 }
 export function transformPropertyShapeToAstObjectTypeProperty({ objectType, propertyShape, }) {
-    return Eithers.chain3(transformShapeToAstAbstractTypeProperties(propertyShape), propertyShape.resolve, transformPropertyShapeToAstType.bind(this)(propertyShape)).chain(([astAbstractTypeProperties, propertyShapeResolve, astType]) => {
+    const shapeStack = new ShapeStack(); // Start a new ShapeStack per property shape
+    return Eithers.chain2(propertyShape.resolve, transformPropertyShapeToAstType.call(this, propertyShape, shapeStack)).chain(([propertyShapeResolve, astType]) => {
         let astResolveItemType;
         if (propertyShapeResolve.isJust()) {
-            const astResolveTypeEither = this.transformNodeShapeToAstType(propertyShapeResolve.unsafeCoerce()).chain((astResolveType) => {
+            const astResolveTypeEither = transformShapeToAstType
+                .call(this, propertyShapeResolve.unsafeCoerce(), shapeStack)
+                .chain((astResolveType) => {
                 switch (astResolveType.kind) {
-                    case "ListType":
-                    case "ObjectIntersectionType":
-                        return Left(new Error(`${propertyShape} resolve cannot refer to a ${astResolveType.kind}`));
                     case "ObjectType":
-                    case "ObjectUnionType":
                         return Either.of(astResolveType);
+                    case "UnionType":
+                        if (!astResolveType.isObjectUnionType()) {
+                            return Left(new Error(`${propertyShape} resolve cannot refer to a ${astResolveType.kind} with non-ObjectType members`));
+                        }
+                        return Either.of(astResolveType);
+                    default:
+                        return Left(new Error(`${propertyShape} resolve cannot refer to a ${astResolveType.kind}`));
                 }
             });
             if (astResolveTypeEither.isLeft()) {
@@ -130,18 +178,29 @@ export function transformPropertyShapeToAstObjectTypeProperty({ objectType, prop
                     });
                     break;
                 case "ObjectType":
-                case "ObjectUnionType":
+                    astPartialItemType = astItemType;
+                    break;
+                case "UnionType":
+                    if (!astItemType.isObjectUnionType()) {
+                        return Left(new Error(`${propertyShape} partial type cannot be a ${astItemType.kind} with non-ObjectType members`));
+                    }
                     astPartialItemType = astItemType;
                     break;
                 default:
                     return Left(new Error(`${propertyShape} has a resolve with an incompatible partial type ${astItemType.kind}`));
             }
+            const astAbstractTypeProperties = {
+                comment: Maybe.empty(),
+                label: Maybe.empty(),
+                name: Maybe.empty(),
+                shapeIdentifier: propertyShape.identifier,
+            };
             switch (astType.kind) {
                 case "BlankNodeType":
                 case "IdentifierType":
                 case "IriType":
                 case "ObjectType":
-                case "ObjectUnionType":
+                case "UnionType":
                     astType = new ast.LazyObjectType({
                         ...astAbstractTypeProperties,
                         partialType: astPartialItemType,
@@ -183,15 +242,11 @@ export function transformPropertyShapeToAstObjectTypeProperty({ objectType, prop
             description: propertyShape.description,
             label: propertyShape.label,
             mutable: propertyShape.mutable.orDefault(false),
-            name: propertyShape.shaclmateName.alt(propertyShape.name),
+            name: propertyName.call(this, objectType, propertyShape),
             objectType,
             order: propertyShape.order.orDefault(0),
-            path: (propertyShape.path.termType === "NamedNode"
-                ? this.curieFactory.create(propertyShape.path).extract()
-                : undefined) ?? propertyShape.path,
-            shapeIdentifier: (propertyShape.identifier.termType === "NamedNode"
-                ? this.curieFactory.create(propertyShape.identifier).extract()
-                : undefined) ?? propertyShape.identifier,
+            path: propertyShape.path,
+            shapeIdentifier: propertyShape.identifier,
             type: astType,
             visibility: propertyShape.visibility,
         }));

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

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstCompoundType.js

@@ -2,25 +2,28 @@ 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 { transformShapeToAstAbstractTypeProperties } from "./transformShapeToAstAbstractTypeProperties.js";
+import { nodeShapeTsFeatures } from "./nodeShapeTsFeatures.js";
+import { shapeAstTypeName } from "./shapeAstTypeName.js";
+import { transformShapeToAstType } from "./transformShapeToAstType.js";
 /**
  * Try to convert a shape to a compound type (intersection or union) using some heuristics.
  */
 export function transformShapeToAstCompoundType(shape, shapeStack) {
     shapeStack.push(shape);
     try {
-        return Eithers.chain3(shape.constraints.and, shape.constraints.nodes, shape.constraints.xone).chain(([andConstraintShapes, nodeConstraintShapes, xoneConstraintShapes]) => {
+        return Eithers.chain4(shape.constraints.and, shape.constraints.nodes, shape.kind === "NodeShape"
+            ? nodeShapeTsFeatures.call(this, shape)
+            : Either.of(new Set()), shape.constraints.xone).chain(([andConstraintShapes, nodeConstraintShapes, tsFeatures, xoneConstraintShapes,]) => {
             let compoundTypeKind;
             // Distinguish constraints that take arbitrary shapes from those that only take node shapes
             // With the latter we'll do special transformations.
             let memberShapes;
-            let memberNodeShapes;
             if (andConstraintShapes.length > 0) {
                 memberShapes = andConstraintShapes;
                 compoundTypeKind = "IntersectionType";
             }
             else if (nodeConstraintShapes.length > 0) {
-                memberNodeShapes = nodeConstraintShapes;
+                memberShapes = nodeConstraintShapes;
                 compoundTypeKind = "IntersectionType";
             }
             else if (xoneConstraintShapes.length > 0) {
@@ -30,107 +33,58 @@ export function transformShapeToAstCompoundType(shape, shapeStack) {
             else {
                 return Either.of(Maybe.empty());
             }
-            const memberDiscriminantValues = [];
-            const memberTypes = [];
-            if (memberNodeShapes) {
-                invariant(memberNodeShapes.length > 0);
-                invariant(!memberShapes);
-                for (const memberNodeShape of memberNodeShapes) {
-                    const memberTypeEither = this.transformNodeShapeToAstType(memberNodeShape);
-                    if (memberTypeEither.isLeft()) {
-                        return memberTypeEither;
-                    }
-                    memberTypes.push(memberTypeEither.unsafeCoerce());
-                    if (compoundTypeKind === "UnionType") {
-                        const memberDiscriminantValue = memberNodeShape.discriminantValue.extract();
-                        if (memberDiscriminantValue) {
-                            memberDiscriminantValues.push(memberDiscriminantValue);
-                        }
-                        else if (memberDiscriminantValues.length > 0) {
-                            return Left(new Error(`${shape} does not have a discriminant value while the other members of the compound type do`));
-                        }
-                    }
-                }
+            invariant(memberShapes.length > 0);
+            const memberDiscriminantValues = new Set();
+            const compoundType = new (compoundTypeKind === "IntersectionType"
+                ? ast.IntersectionType
+                : ast.UnionType)({
+                comment: shape.comment,
+                label: shape.label,
+                name: shapeAstTypeName(shape),
+                shapeIdentifier: shape.identifier,
+                tsFeatures,
+            });
+            if (memberShapes.length === 1) {
+                return transformShapeToAstType
+                    .call(this, memberShapes[0], shapeStack)
+                    .map(Maybe.of);
             }
-            else if (memberShapes) {
-                invariant(memberShapes.length > 0);
-                for (const memberShape of memberShapes) {
-                    const memberTypeEither = this.transformShapeToAstType(memberShape, shapeStack);
-                    if (memberTypeEither.isLeft()) {
-                        return memberTypeEither;
+            // Put a placeholder in the cache to deal with cyclic references
+            this.cachedAstTypesByShapeIdentifier.set(shape.identifier, compoundType);
+            return Either.sequence(memberShapes.map((memberShape) => transformShapeToAstType.call(this, memberShape, shapeStack)))
+                .chain((memberShapeTypes) => {
+                for (let memberI = 0; memberI < memberShapes.length; memberI++) {
+                    const memberShape = memberShapes[memberI];
+                    const memberType = memberShapeTypes[memberI];
+                    if (!ast.IntersectionType.isMemberType(memberType)) {
+                        return Left(new Error(`${shape} has an invalid member type kind "${memberType.kind}"`));
                     }
-                    memberTypes.push(memberTypeEither.unsafeCoerce());
+                    if (memberI > 0 &&
+                        compoundType.members.some((existingMember) => ast.Type.equals(memberType, existingMember.type))) {
+                        return Left(new Error(`${shape} has duplicate ${compoundTypeKind} member type: ${memberType}`));
+                    }
+                    let memberDiscriminantValue;
                     if (compoundTypeKind === "UnionType") {
-                        let memberDiscriminantValue;
                         if (memberShape.kind === "NodeShape") {
                             memberDiscriminantValue =
                                 memberShape.discriminantValue.extract();
                         }
                         if (memberDiscriminantValue) {
-                            if (memberDiscriminantValues.includes(memberDiscriminantValue)) {
+                            if (memberDiscriminantValues.has(memberDiscriminantValue)) {
                                 return Left(new Error(`${shape} member ${memberShape} has a duplicate discriminant value: ${memberDiscriminantValue}`));
                             }
-                            memberDiscriminantValues.push(memberDiscriminantValue);
-                        }
-                        else if (memberDiscriminantValues.length > 0) {
-                            return Left(new Error(`${shape} member ${memberShape} does not have a discriminant value while the other members of the compound type do`));
+                            memberDiscriminantValues.add(memberDiscriminantValue);
                         }
                     }
-                }
-            }
-            else {
-                invariant(false);
-            }
-            if (memberTypes.length === 1) {
-                return Either.of(Maybe.of(memberTypes[0]));
-            }
-            return transformShapeToAstAbstractTypeProperties(shape).chain((astAbstractTypeProperties) => {
-                // If every member type is an ObjectType, ObjectIntersectionType, or ObjectUnionType (the latter of which can be flattened to ObjectTypes),
-                // produce a different AST type (ObjectIntersectionType or ObjectUnionType).
-                if (memberTypes.every((memberType) => {
-                    switch (memberType.kind) {
-                        case "ObjectType":
-                        case "ObjectIntersectionType":
-                        case "ObjectUnionType":
-                            return true;
-                        default:
-                            return false;
-                    }
-                })) {
-                    const compoundType = new (compoundTypeKind === "IntersectionType"
-                        ? ast.ObjectIntersectionType
-                        : ast.ObjectUnionType)({
-                        ...astAbstractTypeProperties,
-                        export_: true,
-                        name: shape.shaclmateName,
-                        shapeIdentifier: this.shapeIdentifier(shape),
-                        tsFeatures: this.tsFeaturesDefault,
+                    compoundType.addMember({
+                        discriminantValue: Maybe.fromNullable(memberDiscriminantValue),
+                        type: memberType,
                     });
-                    for (const memberType of memberTypes) {
-                        const addMemberTypeResult = compoundType.addMemberType(memberType);
-                        if (addMemberTypeResult.isLeft()) {
-                            return addMemberTypeResult;
-                        }
-                    }
-                }
-                // Compound type doesn't solely consist of ObjectTypes
-                switch (compoundTypeKind) {
-                    case "IntersectionType":
-                        return Either.of(Maybe.of(new ast.IntersectionType({
-                            ...astAbstractTypeProperties,
-                            memberTypes,
-                        })));
-                    case "UnionType":
-                        if (memberDiscriminantValues.length > 0 &&
-                            memberDiscriminantValues.length !== memberTypes.length) {
-                            return Left(new Error(`${shape} has members without discriminant values`));
-                        }
-                        return Either.of(Maybe.of(new ast.UnionType({
-                            ...astAbstractTypeProperties,
-                            memberDiscriminantValues,
-                            memberTypes,
-                        })));
                 }
+                return Either.of(Maybe.of(compoundType));
+            })
+                .ifLeft(() => {
+                this.cachedAstTypesByShapeIdentifier.delete(shape.identifier);
             });
         });
     }

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstListType.d.ts

@@ -0,0 +1,11 @@
+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";
+import type { ShapeStack } from "./ShapeStack.js";
+/**
+ * Is an ast.ObjectType 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>>;
+//# sourceMappingURL=transformShapeToAstListType.d.ts.map