@shaclmate/compiler 4.0.8 → 4.0.10

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstListType.js

@@ -0,0 +1,146 @@
+import dataFactory from "@rdfjs/data-model";
+import { rdf } from "@tpluscode/rdf-ns-builders";
+import { Either, Left, Maybe } from "purify-ts";
+import * as ast from "../ast/index.js";
+import { Eithers } from "../Eithers.js";
+import { defaultNodeShapeNodeKinds } from "./defaultNodeShapeNodeKinds.js";
+import { nodeShapeIdentifierMintingStrategy } from "./nodeShapeIdentifierMintingStrategy.js";
+import { shapeAstTypeName } from "./shapeAstTypeName.js";
+import { shapeNodeKinds } from "./shapeNodeKinds.js";
+import { transformPropertyShapeToAstObjectTypeProperty } from "./transformPropertyShapeToAstObjectTypeProperty.js";
+const listPropertiesObjectType = new ast.ObjectType({
+    abstract: false,
+    extern: false,
+    comment: Maybe.empty(),
+    label: Maybe.empty(),
+    identifierMintingStrategy: Maybe.empty(),
+    identifierType: new ast.IdentifierType({
+        comment: Maybe.empty(),
+        label: Maybe.empty(),
+        name: Maybe.empty(),
+        shapeIdentifier: dataFactory.blankNode(),
+    }),
+    fromRdfType: Maybe.empty(),
+    name: Maybe.empty(),
+    toRdfTypes: [],
+    tsFeatures: new Set([]),
+    tsObjectDeclarationType: "class",
+    shapeIdentifier: dataFactory.blankNode(),
+    synthetic: true,
+    tsImports: [],
+});
+const astListTypePlaceholderItemType = new ast.BlankNodeType({
+    comment: Maybe.empty(),
+    label: Maybe.empty(),
+    name: Maybe.empty(),
+    shapeIdentifier: dataFactory.blankNode(),
+});
+/**
+ * Is an ast.ObjectType actually the shape of an RDF list?
+ * If so, return the type of its rdf:first.
+ */
+export function transformShapeToAstListType(shape, shapeStack) {
+    shapeStack.push(shape);
+    try {
+        if (shape.kind !== "NodeShape") {
+            return Either.of(Maybe.empty());
+        }
+        const nodeShape = shape;
+        if (!nodeShape.isList) {
+            return Either.of(Maybe.empty());
+        }
+        return Eithers.chain3(nodeShapeIdentifierMintingStrategy(nodeShape), shapeNodeKinds(nodeShape, { defaultNodeShapeNodeKinds }), nodeShape.constraints.xone).chain(([identifierMintingStrategy, nodeKinds, xone]) => {
+            // Put a placeholder in the cache to deal with cyclic references
+            // Remove the placeholder if the transformation fails.
+            const listType = new ast.ListType({
+                comment: nodeShape.comment,
+                identifierNodeKind: nodeKinds.has("BlankNode") ? "BlankNode" : "IRI",
+                itemType: astListTypePlaceholderItemType,
+                label: nodeShape.label,
+                mutable: nodeShape.mutable.orDefault(false),
+                name: shapeAstTypeName(nodeShape),
+                identifierMintingStrategy,
+                shapeIdentifier: nodeShape.identifier,
+                toRdfTypes: nodeShape.toRdfTypes,
+            });
+            this.cachedAstTypesByShapeIdentifier.set(nodeShape.identifier, listType);
+            return (() => {
+                let emptyListShape;
+                let nonEmptyListShape;
+                for (const shape of xone) {
+                    if (shape.constraints.hasValues.length === 1 &&
+                        shape.constraints.hasValues[0].equals(rdf.nil)) {
+                        emptyListShape = shape;
+                    }
+                    else if (shape.kind === "NodeShape" &&
+                        shape.constraints.properties.orDefault([]).length >= 2) {
+                        nonEmptyListShape = shape;
+                    }
+                }
+                if (!emptyListShape || !nonEmptyListShape) {
+                    return Left(new Error(`${nodeShape} does not have an sh:xone with exactly two shapes, one for the empty list and one for the non-empty list`));
+                }
+                return nonEmptyListShape.constraints.properties.chain((nonEmptyListShapeProperties) => {
+                    let firstPropertyShape;
+                    let restPropertyShape;
+                    for (const propertyShape of nonEmptyListShapeProperties) {
+                        if (propertyShape.path.termType !== "NamedNode") {
+                            continue;
+                        }
+                        if (propertyShape.path.equals(rdf.first)) {
+                            firstPropertyShape = propertyShape;
+                        }
+                        else if (propertyShape.path.equals(rdf.rest)) {
+                            restPropertyShape = propertyShape;
+                        }
+                    }
+                    if (!firstPropertyShape) {
+                        return Left(new Error(`${nodeShape} has a non-empty list shape without an sh:property shape whose sh:path is rdf:first`));
+                    }
+                    if (firstPropertyShape.constraints.maxCount.extract() !== 1 ||
+                        firstPropertyShape.constraints.minCount.extract() !== 1) {
+                        return Left(new Error(`${nodeShape} non-empty list shape rdf:first property shape does not have sh:maxCount=1 and/or sh:minCount=1`));
+                    }
+                    if (!restPropertyShape) {
+                        return Left(new Error(`${nodeShape} has a non-empty list shape without an sh:property shape whose sh:path is rdf:rest`));
+                    }
+                    if (restPropertyShape.constraints.maxCount.extract() !== 1 ||
+                        restPropertyShape.constraints.minCount.extract() !== 1) {
+                        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
+                        .call(this, {
+                        // Just need a dummy ast.ObjectType here to get the properties transformed.
+                        objectType: listPropertiesObjectType,
+                        propertyShape: firstPropertyShape,
+                    })
+                        .chain((firstProperty) => {
+                        if (!ast.ListType.isItemType(firstProperty.type)) {
+                            return Left(new Error(`${nodeShape}: ${firstProperty.type.kind} is not a valid list item type`));
+                        }
+                        listType.itemType = firstProperty.type;
+                        return transformPropertyShapeToAstObjectTypeProperty
+                            .call(this, {
+                            // Just need a dummy ast.ObjectType here to get the properties transformed.
+                            objectType: listPropertiesObjectType,
+                            propertyShape: restPropertyShape,
+                        })
+                            .chain((restProperty) => {
+                            if (restProperty.type.kind !== "ListType" ||
+                                !restProperty.type.shapeIdentifier.equals(nodeShape.identifier)) {
+                                return Left(new Error(`${nodeShape} rdf:rest property is not recursive into the node shape`));
+                            }
+                            return Either.of(Maybe.of(listType));
+                        });
+                    });
+                });
+            })().ifLeft(() => {
+                this.cachedAstTypesByShapeIdentifier.delete(nodeShape.identifier);
+            });
+        });
+    }
+    finally {
+        shapeStack.pop(shape);
+    }
+}
+//# sourceMappingURL=transformShapeToAstListType.js.map

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstObjectType.d.ts

@@ -0,0 +1,7 @@
+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 { ShapeStack } from "./ShapeStack.js";
+export declare function transformShapeToAstObjectType(this: ShapesGraphToAstTransformer, shape: input.Shape, shapeStack: ShapeStack): Either<Error, Maybe<ast.ObjectType>>;
+//# sourceMappingURL=transformShapeToAstObjectType.d.ts.map

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstObjectType.js

@@ -0,0 +1,182 @@
+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 { defaultNodeShapeNodeKinds } from "./defaultNodeShapeNodeKinds.js";
+import { nodeShapeIdentifierMintingStrategy } from "./nodeShapeIdentifierMintingStrategy.js";
+import { nodeShapeTsFeatures } from "./nodeShapeTsFeatures.js";
+import { ShapeStack } from "./ShapeStack.js";
+import { shapeAstTypeName } from "./shapeAstTypeName.js";
+import { shapeNodeKinds } from "./shapeNodeKinds.js";
+import { transformPropertyShapeToAstObjectTypeProperty } from "./transformPropertyShapeToAstObjectTypeProperty.js";
+import { transformShapeToAstType } from "./transformShapeToAstType.js";
+function isObjectTypePropertyRequired(property) {
+    switch (property.type.kind) {
+        case "DefaultValueType":
+            return false;
+        case "LazyObjectOptionType":
+            return false;
+        case "LazyObjectSetType":
+            return property.type.partialType.minCount > 0;
+        case "OptionType":
+            return false;
+        case "SetType":
+            return property.type.minCount > 0;
+        case "UnionType":
+            return property.type.members.every((member) => isObjectTypePropertyRequired({ type: member.type }));
+        case "BlankNodeType":
+        case "IdentifierType":
+        case "IriType":
+        case "LazyObjectType":
+        case "ListType":
+        case "LiteralType":
+        case "ObjectType":
+        case "TermType":
+            return true;
+        case "IntersectionType":
+            throw new Error("unsupported");
+        default:
+            property.type;
+            throw new Error("should never reach this point");
+    }
+}
+export function transformShapeToAstObjectType(shape, shapeStack) {
+    shapeStack.push(shape);
+    try {
+        if (shape.kind !== "NodeShape") {
+            return Either.of(Maybe.empty());
+        }
+        const nodeShape = shape;
+        if (nodeShape.identifier.termType !== "NamedNode") {
+            return Either.of(Maybe.empty());
+        }
+        return Eithers.chain2(nodeShape.constraints.and, nodeShape.constraints.xone).chain(([andShapes, xoneShapes]) => {
+            if (andShapes.length > 0 || xoneShapes.length > 0) {
+                return Either.of(Maybe.empty());
+            }
+            return Eithers.chain9(nodeShape.ancestorNodeShapes, nodeShape.childNodeShapes, nodeShape.descendantNodeShapes, nodeShape.parentNodeShapes, nodeShapeIdentifierMintingStrategy(nodeShape), shapeNodeKinds(nodeShape, { defaultNodeShapeNodeKinds }), nodeShape.constraints.properties, nodeShapeTsFeatures.call(this, nodeShape), nodeShape.tsObjectDeclarationType.isJust()
+                ? Either.of(nodeShape.tsObjectDeclarationType)
+                : nodeShape.isDefinedBy.map((ontology) => ontology.chain((ontology) => ontology.tsObjectDeclarationType))).chain(([ancestorNodeShapes, childNodeShapes, descendantNodeShapes, parentNodeShapes, identifierMintingStrategy, nodeKinds, propertyShapes, tsFeatures, tsObjectDeclarationType,]) => {
+                const abstract = nodeShape.abstract.orDefault(false);
+                let fromRdfType;
+                let toRdfTypes;
+                if (!abstract) {
+                    fromRdfType = nodeShape.fromRdfType.alt(nodeShape.rdfType);
+                    if (nodeShape.isClass &&
+                        nodeShape.identifier.termType === "NamedNode") {
+                        fromRdfType = fromRdfType.alt(Maybe.of(nodeShape.identifier));
+                    }
+                    toRdfTypes = nodeShape.toRdfTypes.concat();
+                    if (toRdfTypes.length === 0) {
+                        toRdfTypes.push(...nodeShape.rdfType.toList());
+                    }
+                    // Ensure toRdfTypes has fromRdfType
+                    fromRdfType.ifJust((fromRdfType) => {
+                        if (!toRdfTypes.some((toRdfType) => toRdfType.equals(fromRdfType))) {
+                            toRdfTypes.push(fromRdfType);
+                        }
+                    });
+                }
+                else {
+                    fromRdfType = Maybe.empty();
+                    toRdfTypes = [];
+                }
+                if (nodeKinds.has("Literal")) {
+                    return Left(new Error(`${nodeShape} should not have a nodeKind "Literal"`));
+                }
+                let identifierType;
+                const identifierTypeProperties = {
+                    comment: Maybe.empty(),
+                    label: Maybe.empty(),
+                    name: Maybe.empty(),
+                    shapeIdentifier: nodeShape.identifier,
+                };
+                if (nodeKinds.size === 2) {
+                    invariant(nodeShape.identifierIn.length === 0);
+                    identifierType = new ast.IdentifierType(identifierTypeProperties);
+                }
+                else {
+                    switch ([...nodeKinds][0]) {
+                        case "BlankNode":
+                            invariant(nodeShape.identifierIn.length === 0);
+                            identifierType = new ast.BlankNodeType(identifierTypeProperties);
+                            break;
+                        case "IRI":
+                            identifierType = new ast.IriType({
+                                ...identifierTypeProperties,
+                                hasValues: [],
+                                in_: nodeShape.identifierIn,
+                            });
+                            break;
+                        case "Literal":
+                            throw new Error("should never happen");
+                    }
+                }
+                invariant(identifierType);
+                // Put a placeholder in the cache to deal with cyclic references
+                // Remove the placeholder if the transformation fails.
+                // If this node shape's properties (directly or indirectly) refer to the node shape itself,
+                // we'll return this placeholder.
+                const objectType = new ast.ObjectType({
+                    abstract,
+                    comment: nodeShape.comment,
+                    extern: nodeShape.extern.orDefault(false),
+                    fromRdfType,
+                    label: nodeShape.label,
+                    identifierType,
+                    identifierMintingStrategy,
+                    name: shapeAstTypeName(nodeShape),
+                    shapeIdentifier: nodeShape.identifier,
+                    synthetic: false,
+                    toRdfTypes,
+                    tsFeatures,
+                    tsImports: nodeShape.tsImports,
+                    tsObjectDeclarationType: tsObjectDeclarationType.orDefault("class"),
+                });
+                this.cachedAstTypesByShapeIdentifier.set(nodeShape.identifier, objectType);
+                return (() => {
+                    // Populate ancestor and descendant object types
+                    const relatedObjectTypes = (relatedNodeShapes) => {
+                        return relatedNodeShapes
+                            .flatMap((relatedNodeShape) => transformShapeToAstType
+                            .call(this, relatedNodeShape, new ShapeStack())
+                            .toMaybe()
+                            .toList())
+                            .filter((astType) => astType.kind === "ObjectType");
+                    };
+                    objectType.addAncestorObjectTypes(...relatedObjectTypes(ancestorNodeShapes));
+                    objectType.addChildObjectTypes(...relatedObjectTypes(childNodeShapes));
+                    objectType.addDescendantObjectTypes(...relatedObjectTypes(descendantNodeShapes));
+                    objectType.addParentObjectTypes(...relatedObjectTypes(parentNodeShapes));
+                    // Populate properties
+                    for (const propertyShape of propertyShapes) {
+                        const propertyEither = transformPropertyShapeToAstObjectTypeProperty.call(this, {
+                            objectType,
+                            propertyShape,
+                        });
+                        if (propertyEither.isLeft()) {
+                            return propertyEither;
+                        }
+                        propertyEither.ifRight((property) => {
+                            objectType.addProperties(property);
+                        });
+                    }
+                    if (!objectType.abstract &&
+                        !objectType.extern &&
+                        objectType.fromRdfType.isNothing() &&
+                        !objectType.properties.some(isObjectTypePropertyRequired)) {
+                        return Left(new Error(`${nodeShape} has no required properties and no implicitly required rdf:type`));
+                    }
+                    objectType.sortProperties();
+                    return Either.of(Maybe.of(objectType));
+                })().ifLeft(() => {
+                    this.cachedAstTypesByShapeIdentifier.delete(nodeShape.identifier);
+                });
+            });
+        });
+    }
+    finally {
+        shapeStack.pop(shape);
+    }
+}
+//# sourceMappingURL=transformShapeToAstObjectType.js.map

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstTermType.js

@@ -1,27 +1,29 @@
-import { Either, Left } from "purify-ts";
+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 { shapeNodeKinds } from "./shapeNodeKinds.js";
-import { transformShapeToAstAbstractTypeProperties } from "./transformShapeToAstAbstractTypeProperties.js";
 /**
  * Try to convert a shape to an AST TermType using some heuristics.
  */
 export function transformShapeToAstTermType(shape, shapeStack) {
     shapeStack.push(shape);
     try {
-        return Eithers.chain2(transformShapeToAstAbstractTypeProperties(shape), shapeNodeKinds(shape)).chain(([astAbstractTypeProperties, nodeKinds]) => {
+        return shapeNodeKinds(shape).chain((nodeKinds) => {
             const hasValues = shapeStack.constraints.hasValues;
             const in_ = shapeStack.constraints.in_;
+            const astAbstractTypeProperties = {
+                comment: Maybe.empty(),
+                name: Maybe.empty(),
+                label: Maybe.empty(),
+                shapeIdentifier: shape.identifier,
+            };
             let termType;
             if (nodeKinds.size === 1) {
                 const nodeKind = [...nodeKinds][0];
                 switch (nodeKind) {
                     case "BlankNode":
                         invariant(in_.length === 0);
-                        termType = new ast.BlankNodeType({
-                            ...astAbstractTypeProperties,
-                        });
+                        termType = new ast.BlankNodeType(astAbstractTypeProperties);
                         break;
                     case "IRI":
                         termType = new ast.IriType({

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstType.d.ts

@@ -4,10 +4,8 @@ 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.
- *
- * We don't try to handle exotic cases allowed by the SHACL spec, such as combinations of sh:in and sh:node. Instead we assume
- * a shape has one type.
+ * Try to convert a shape to a 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, Exclude<ast.Type, ast.PlaceholderType>>;
+export declare function transformShapeToAstType(this: ShapesGraphToAstTransformer, shape: input.Shape, shapeStack: ShapeStack): Either<Error, ast.Type>;
 //# sourceMappingURL=transformShapeToAstType.d.ts.map

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstType.js

@@ -1,18 +1,41 @@
 import { Either } from "purify-ts";
 import { transformShapeToAstCompoundType } from "./transformShapeToAstCompoundType.js";
+import { transformShapeToAstListType } from "./transformShapeToAstListType.js";
+import { transformShapeToAstObjectType } from "./transformShapeToAstObjectType.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,
+];
 /**
- * Try to convert a shape to a type using some heuristics.
- *
- * We don't try to handle exotic cases allowed by the SHACL spec, such as combinations of sh:in and sh:node. Instead we assume
- * a shape has one type.
+ * Try to convert a shape to a 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) {
-    // Try to transform the property shape into an AST type without cardinality constraints
-    return transformShapeToAstCompoundType
-        .bind(this)(shape, shapeStack)
-        .chain((astType) => astType
-        .map((_) => Either.of(_))
-        .orDefaultLazy(() => transformShapeToAstTermType.bind(this)(shape, shapeStack)));
+    const astType = this.cachedAstTypesByShapeIdentifier.get(shape.identifier);
+    if (astType) {
+        return Either.of(astType);
+    }
+    // Every transformShapeToAst*Type returns Either<Error, Maybe<ast.Type>>:
+    //   * Left/Error: the shape was the expected type but the transformation failed
+    //   * Right+Nothing = the shape wasn't the expected type
+    //   * Right+Some = the shape was the expected type and the transformation succeeded
+    for (const tryTransformAstTypeToShapeMethod of tryTransformShapeToAstTypeMethods) {
+        const either = tryTransformAstTypeToShapeMethod.call(this, shape, shapeStack);
+        if (either.isLeft()) {
+            return either;
+        }
+        const astType = either.unsafeCoerce().extract();
+        if (astType) {
+            this.cachedAstTypesByShapeIdentifier.set(shape.identifier, astType);
+            return Either.of(astType);
+        }
+    }
+    return transformShapeToAstTermType
+        .call(this, shape, shapeStack)
+        .ifRight((astType) => {
+        this.cachedAstTypesByShapeIdentifier.set(shape.identifier, astType);
+    });
 }
 //# sourceMappingURL=transformShapeToAstType.js.map

package/dist/ast/AbstractCompoundType.d.ts

@@ -1,23 +1,41 @@
+import type { TsFeature } from "../enums/TsFeature.js";
 import { AbstractType } from "./AbstractType.js";
-import { Type } from "./Type.js";
+import type { BlankNodeType } from "./BlankNodeType.js";
+import type { IdentifierType } from "./IdentifierType.js";
+import type { IntersectionType } from "./IntersectionType.js";
+import type { IriType } from "./IriType.js";
+import type { LiteralType } from "./LiteralType.js";
+import type { ObjectType } from "./ObjectType.js";
+import type { TermType } from "./TermType.js";
+import type { Type } from "./Type.js";
+import type { UnionType } from "./UnionType.js";
 /**
  * A compound of types, such as an intersection or union.
  *
  * Compound = combining types at the type level e.g., functions, intersections, unions
  * Composite = combining values at runtime (e.g., arrays, structs whose members have the same type)
  */
-export declare abstract class AbstractCompoundType<MemberTypeT extends Type> extends AbstractType {
+export declare abstract class AbstractCompoundType<MemberT extends AbstractCompoundType.Member<MemberTypeT>, MemberTypeT extends AbstractCompoundType.MemberType> extends AbstractType {
     #private;
     /**
      * Type discriminant
      */
-    abstract readonly kind: "IntersectionType" | "ObjectIntersectionType" | "ObjectUnionType" | "UnionType";
-    constructor({ memberTypes, ...superParameters }: {
-        memberTypes?: readonly MemberTypeT[];
+    abstract readonly kind: "IntersectionType" | "UnionType";
+    constructor({ tsFeatures, ...superParameters }: {
+        tsFeatures: ReadonlySet<TsFeature>;
     } & ConstructorParameters<typeof AbstractType>[0]);
-    addMemberType(memberType: MemberTypeT): void;
-    equals(other: AbstractCompoundType<MemberTypeT>): boolean;
-    get memberTypes(): readonly MemberTypeT[];
+    get members(): readonly MemberT[];
+    get recursive(): boolean;
+    get tsFeatures(): ReadonlySet<TsFeature>;
+    addMember(member: MemberT): void;
+    equals(other: AbstractCompoundType<MemberT, MemberTypeT>): boolean;
     toString(): string;
 }
+export declare namespace AbstractCompoundType {
+    interface Member<TypeT extends MemberType> {
+        readonly type: TypeT;
+    }
+    type MemberType = BlankNodeType | IdentifierType | IntersectionType | IriType | LiteralType | ObjectType | TermType | UnionType;
+    function isMemberType(type: Type): type is MemberType;
+}
 //# sourceMappingURL=AbstractCompoundType.d.ts.map

package/dist/ast/AbstractCompoundType.js

@@ -1,7 +1,12 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
 import { invariant } from "ts-invariant";
+import { Memoize } from "typescript-memoize";
 import { AbstractType } from "./AbstractType.js";
-import { arrayEquals } from "./equals.js";
-import { Type } from "./Type.js";
 /**
  * A compound of types, such as an intersection or union.
  *
@@ -10,30 +15,93 @@ import { Type } from "./Type.js";
  */
 export class AbstractCompoundType extends AbstractType {
     /**
-     * Member types.
+     * Members.
      *
      * Mutable to support cycle-handling logic in the compiler.
      */
-    #memberTypes;
-    constructor({ memberTypes, ...superParameters }) {
+    #members = [];
+    /**
+     * TypeScript features to generate.
+     */
+    #tsFeatures;
+    constructor({ tsFeatures, ...superParameters }) {
         super(superParameters);
-        this.#memberTypes = memberTypes?.concat() ?? [];
+        this.#tsFeatures = tsFeatures;
     }
-    addMemberType(memberType) {
-        this.#memberTypes.push(memberType);
+    get members() {
+        invariant(this.#members.length > 0);
+        return this.#members;
     }
-    equals(other) {
-        if (!super.equals(other)) {
-            return false;
+    get recursive() {
+        return this.members.some((member) => member.type.recursive);
+    }
+    get tsFeatures() {
+        // Members of the compound type must have the same tsFeatures.
+        // They must also have distinct RDF types or no RDF types at all.
+        const mergedMemberTsFeatures = new Set();
+        for (let memberI = 0; memberI < this.members.length; memberI++) {
+            const member = this.members[memberI];
+            switch (member.type.kind) {
+                case "IntersectionType":
+                case "ObjectType":
+                case "UnionType":
+                    break;
+                default:
+                    continue;
+            }
+            if (memberI === 0) {
+                for (const tsFeature of member.type.tsFeatures) {
+                    mergedMemberTsFeatures.add(tsFeature);
+                }
+            }
+            if (member.type.tsFeatures.size !== mergedMemberTsFeatures.size) {
+                throw new Error(`${this} has a member (${member}) with different tsFeatures than the other members`);
+            }
+            for (const tsFeature of member.type.tsFeatures) {
+                if (!mergedMemberTsFeatures.has(tsFeature)) {
+                    throw new Error(`${this} has a member (${member}) with different tsFeatures than the other members`);
+                }
+            }
         }
-        return arrayEquals(Type.equals)(this.memberTypes, other.memberTypes);
+        return this.#tsFeatures;
     }
-    get memberTypes() {
-        invariant(this.#memberTypes.length > 0);
-        return this.#memberTypes;
+    addMember(member) {
+        this.#members.push(member);
+    }
+    equals(other) {
+        // return arrayEquals(Type.equals)(this.memberTypes, other.memberTypes);
+        // Don't recurse
+        return this.shapeIdentifier.equals(other.shapeIdentifier);
     }
     toString() {
-        return `${this.kind}(memberTypes=[${this.memberTypes.map((memberType) => memberType.toString()).join(", ")}])`;
+        return `${this.kind}(memberTypes=[${this.members.map((memberType) => memberType.toString()).join(", ")}])`;
     }
 }
+__decorate([
+    Memoize()
+], AbstractCompoundType.prototype, "tsFeatures", null);
+(function (AbstractCompoundType) {
+    function isMemberType(type) {
+        switch (type.kind) {
+            case "BlankNodeType":
+            case "IdentifierType":
+            case "IntersectionType":
+            case "IriType":
+            case "LiteralType":
+            case "ObjectType":
+            case "TermType":
+            case "UnionType":
+                return true;
+            case "DefaultValueType":
+            case "LazyObjectOptionType":
+            case "LazyObjectSetType":
+            case "LazyObjectType":
+            case "ListType":
+            case "OptionType":
+            case "SetType":
+                return false;
+        }
+    }
+    AbstractCompoundType.isMemberType = isMemberType;
+})(AbstractCompoundType || (AbstractCompoundType = {}));
 //# sourceMappingURL=AbstractCompoundType.js.map

package/dist/ast/AbstractContainerType.d.ts

@@ -5,10 +5,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 { ObjectIntersectionType } from "./ObjectIntersectionType.js";
 import type { ObjectType } from "./ObjectType.js";
-import type { ObjectUnionType } from "./ObjectUnionType.js";
-import type { PlaceholderType } from "./PlaceholderType.js";
 import type { TermType } from "./TermType.js";
 import { Type } from "./Type.js";
 import type { UnionType } from "./UnionType.js";
@@ -26,11 +23,12 @@ export declare abstract class AbstractContainerType<ItemTypeT extends AbstractCo
     constructor({ itemType, ...superParameters }: {
         itemType: ItemTypeT;
     } & ConstructorParameters<typeof AbstractType>[0]);
+    get recursive(): boolean;
     equals(other: AbstractContainerType<ItemTypeT>): boolean;
     toString(): string;
 }
 export declare namespace AbstractContainerType {
-    type ItemType = BlankNodeType | IdentifierType | IntersectionType | IriType | ListType | LiteralType | ObjectIntersectionType | ObjectType | ObjectUnionType | PlaceholderType | TermType | UnionType;
+    type ItemType = BlankNodeType | IdentifierType | IntersectionType | IriType | ListType | LiteralType | ObjectType | TermType | UnionType;
     function isItemType(type: Type): type is ItemType;
 }
 //# sourceMappingURL=AbstractContainerType.d.ts.map