@shaclmate/compiler 3.0.3 → 4.0.0

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstTermType.js

@@ -1,20 +1,101 @@
-import { Either } from "purify-ts";
-import { propertyShapeNodeKinds } from "./propertyShapeNodeKinds.js";
+import { Either, Left } 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 {
-        const nodeKinds = propertyShapeNodeKinds(shape);
-        return Either.of({
-            defaultValue: shapeStack.defaultValue,
-            hasValues: shapeStack.constraints.hasValues,
-            in_: shapeStack.constraints.in_,
-            kind: "TermType",
-            nodeKinds: nodeKinds.size > 0
-                ? nodeKinds
-                : new Set(["BlankNode", "NamedNode", "Literal"]),
+        return Eithers.chain2(transformShapeToAstAbstractTypeProperties(shape), shapeNodeKinds(shape)).chain(([astAbstractTypeProperties, nodeKinds]) => {
+            const hasValues = shapeStack.constraints.hasValues;
+            const in_ = shapeStack.constraints.in_;
+            let termType;
+            if (nodeKinds.size === 1) {
+                const nodeKind = [...nodeKinds][0];
+                switch (nodeKind) {
+                    case "BlankNode":
+                        invariant(in_.length === 0);
+                        termType = new ast.BlankNodeType({
+                            ...astAbstractTypeProperties,
+                        });
+                        break;
+                    case "IRI":
+                        termType = new ast.IriType({
+                            ...astAbstractTypeProperties,
+                            hasValues: hasValues.filter((_) => _.termType === "NamedNode"),
+                            in_: in_.filter((_) => _.termType === "NamedNode"),
+                        });
+                        break;
+                    case "Literal":
+                        termType = new ast.LiteralType({
+                            ...astAbstractTypeProperties,
+                            datatype: shape.constraints.datatype,
+                            hasValues: hasValues.filter((_) => _.termType === "Literal"),
+                            in_: in_.filter((_) => _.termType === "Literal"),
+                            languageIn: [...new Set(shape.constraints.languageIn)],
+                            maxExclusive: shape.constraints.maxExclusive,
+                            maxInclusive: shape.constraints.maxInclusive,
+                            minExclusive: shape.constraints.minExclusive,
+                            minInclusive: shape.constraints.minInclusive,
+                        });
+                        break;
+                }
+            }
+            else if (nodeKinds.size === 2 &&
+                nodeKinds.has("BlankNode") &&
+                nodeKinds.has("IRI")) {
+                invariant(in_.length === 0);
+                termType = new ast.IdentifierType({
+                    ...astAbstractTypeProperties,
+                });
+            }
+            else {
+                invariant(nodeKinds.size >= 2 && nodeKinds.has("Literal"));
+                termType = new ast.TermType({
+                    ...astAbstractTypeProperties,
+                    hasValues,
+                    in_,
+                    nodeKinds,
+                });
+            }
+            if (termType.in_.length > 0) {
+                for (const hasValue of termType.hasValues) {
+                    if (!termType.in_.some((in_) => hasValue.equals(in_))) {
+                        return Left(new Error(`${shape}: has-value conflicts with in`));
+                    }
+                }
+            }
+            return shapeStack.defaultValue
+                .map((defaultValue) => {
+                switch (termType.kind) {
+                    case "BlankNodeType":
+                        return Left(new Error(`${shape}: blank node identifier types cannot have default values`));
+                }
+                switch (termType.hasValues.length) {
+                    case 0:
+                        break;
+                    case 1:
+                        if (!termType.hasValues[0].equals(defaultValue)) {
+                            return Left(new Error(`${shape}: default value conflicts with has-value`));
+                        }
+                        break;
+                    default:
+                        return Left(new Error(`${shape}: has a default value and multiple has-values`));
+                }
+                if (termType.in_.length > 0 &&
+                    !termType.in_.some((in_) => in_.equals(defaultValue))) {
+                    return Left(new Error(`${shape}: default value conflicts with in value`));
+                }
+                return Either.of(new ast.DefaultValueType({
+                    defaultValue,
+                    itemType: termType,
+                }));
+            })
+                .orDefault(Either.of(termType));
         });
     }
     finally {

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstType.d.ts

@@ -1,7 +1,7 @@
-import type { Either } from "purify-ts";
-import type { ShapesGraphToAstTransformer } from "../ShapesGraphToAstTransformer.js";
+import { Either } 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";
 /**
  * Try to convert a shape to a type using some heuristics.
@@ -9,5 +9,5 @@ import type { ShapeStack } from "./ShapeStack.js";
  * 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.
  */
-export declare function transformShapeToAstType(this: ShapesGraphToAstTransformer, shape: input.Shape, shapeStack: ShapeStack): Either<Error, ast.Type>;
+export declare function transformShapeToAstType(this: ShapesGraphToAstTransformer, shape: input.Shape, shapeStack: ShapeStack): Either<Error, Exclude<ast.Type, ast.PlaceholderType>>;
 //# sourceMappingURL=transformShapeToAstType.d.ts.map

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstType.js

@@ -1,3 +1,6 @@
+import { Either } from "purify-ts";
+import { transformShapeToAstCompoundType } from "./transformShapeToAstCompoundType.js";
+import { transformShapeToAstTermType } from "./transformShapeToAstTermType.js";
 /**
  * Try to convert a shape to a type using some heuristics.
  *
@@ -6,9 +9,10 @@
  */
 export function transformShapeToAstType(shape, shapeStack) {
     // Try to transform the property shape into an AST type without cardinality constraints
-    return this.transformShapeToAstCompositeType(shape, shapeStack)
-        .altLazy(() => this.transformShapeToAstIdentifierType(shape, shapeStack))
-        .altLazy(() => this.transformShapeToAstLiteralType(shape, shapeStack))
-        .altLazy(() => this.transformShapeToAstTermType(shape, shapeStack));
+    return transformShapeToAstCompoundType
+        .bind(this)(shape, shapeStack)
+        .chain((astType) => astType
+        .map((_) => Either.of(_))
+        .orDefaultLazy(() => transformShapeToAstTermType.bind(this)(shape, shapeStack)));
 }
 //# sourceMappingURL=transformShapeToAstType.js.map

package/dist/ast/AbstractCollectionType.d.ts

@@ -0,0 +1,20 @@
+import { AbstractContainerType } from "./AbstractContainerType.js";
+/**
+ * Abstract base class for a collection of items of a single type. This is the parent of ListType and SetType.
+ */
+export declare abstract class AbstractCollectionType<ItemTypeT extends AbstractCollectionType.ItemType = AbstractCollectionType.ItemType> extends AbstractContainerType<ItemTypeT> {
+    abstract readonly kind: "ListType" | "SetType";
+    /**
+     * The collection should be mutable in generated code.
+     */
+    readonly mutable: boolean;
+    constructor({ mutable, ...superParameters }: {
+        mutable: boolean;
+    } & ConstructorParameters<typeof AbstractContainerType<ItemTypeT>>[0]);
+    equals(other: AbstractCollectionType<ItemTypeT>): boolean;
+}
+export declare namespace AbstractCollectionType {
+    type ItemType = AbstractContainerType.ItemType;
+    const isItemType: typeof AbstractContainerType.isItemType;
+}
+//# sourceMappingURL=AbstractCollectionType.d.ts.map

package/dist/ast/AbstractCollectionType.js

@@ -0,0 +1,27 @@
+import { AbstractContainerType } from "./AbstractContainerType.js";
+/**
+ * Abstract base class for a collection of items of a single type. This is the parent of ListType and SetType.
+ */
+export class AbstractCollectionType extends AbstractContainerType {
+    /**
+     * The collection should be mutable in generated code.
+     */
+    mutable;
+    constructor({ mutable, ...superParameters }) {
+        super(superParameters);
+        this.mutable = mutable;
+    }
+    equals(other) {
+        if (!super.equals(other)) {
+            return false;
+        }
+        if (this.mutable !== other.mutable) {
+            return false;
+        }
+        return true;
+    }
+}
+(function (AbstractCollectionType) {
+    AbstractCollectionType.isItemType = AbstractContainerType.isItemType;
+})(AbstractCollectionType || (AbstractCollectionType = {}));
+//# sourceMappingURL=AbstractCollectionType.js.map

package/dist/ast/AbstractCompoundType.d.ts

@@ -0,0 +1,23 @@
+import { AbstractType } from "./AbstractType.js";
+import { Type } from "./Type.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 {
+    #private;
+    /**
+     * Type discriminant
+     */
+    abstract readonly kind: "IntersectionType" | "ObjectIntersectionType" | "ObjectUnionType" | "UnionType";
+    constructor({ memberTypes, ...superParameters }: {
+        memberTypes?: readonly MemberTypeT[];
+    } & ConstructorParameters<typeof AbstractType>[0]);
+    addMemberType(memberType: MemberTypeT): void;
+    equals(other: AbstractCompoundType<MemberTypeT>): boolean;
+    get memberTypes(): readonly MemberTypeT[];
+    toString(): string;
+}
+//# sourceMappingURL=AbstractCompoundType.d.ts.map

package/dist/ast/AbstractCompoundType.js

@@ -0,0 +1,39 @@
+import { invariant } from "ts-invariant";
+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.
+ *
+ * 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 class AbstractCompoundType extends AbstractType {
+    /**
+     * Member types.
+     *
+     * Mutable to support cycle-handling logic in the compiler.
+     */
+    #memberTypes;
+    constructor({ memberTypes, ...superParameters }) {
+        super(superParameters);
+        this.#memberTypes = memberTypes?.concat() ?? [];
+    }
+    addMemberType(memberType) {
+        this.#memberTypes.push(memberType);
+    }
+    equals(other) {
+        if (!super.equals(other)) {
+            return false;
+        }
+        return arrayEquals(Type.equals)(this.memberTypes, other.memberTypes);
+    }
+    get memberTypes() {
+        invariant(this.#memberTypes.length > 0);
+        return this.#memberTypes;
+    }
+    toString() {
+        return `${this.kind}(memberTypes=[${this.memberTypes.map((memberType) => memberType.toString()).join(", ")}])`;
+    }
+}
+//# sourceMappingURL=AbstractCompoundType.js.map

package/dist/ast/AbstractContainerType.d.ts

@@ -0,0 +1,36 @@
+import { AbstractType } from "./AbstractType.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 { 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";
+/**
+ * Abstract base class for types that contain other types e.g., ListType, OptionType, SetType.
+ */
+export declare abstract class AbstractContainerType<ItemTypeT extends AbstractContainerType.ItemType = AbstractContainerType.ItemType> extends AbstractType {
+    abstract readonly kind: "DefaultValueType" | "ListType" | "OptionType" | "SetType";
+    /**
+     * Container item type.
+     *
+     * Mutable to support cycle-handling logic in the compiler.
+     */
+    itemType: ItemTypeT;
+    constructor({ itemType, ...superParameters }: {
+        itemType: ItemTypeT;
+    } & ConstructorParameters<typeof AbstractType>[0]);
+    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;
+    function isItemType(type: Type): type is ItemType;
+}
+//# sourceMappingURL=AbstractContainerType.d.ts.map

package/dist/ast/AbstractContainerType.js

@@ -0,0 +1,58 @@
+import { AbstractType } from "./AbstractType.js";
+import { Type } from "./Type.js";
+/**
+ * Abstract base class for types that contain other types e.g., ListType, OptionType, SetType.
+ */
+export class AbstractContainerType extends AbstractType {
+    /**
+     * Container item type.
+     *
+     * Mutable to support cycle-handling logic in the compiler.
+     */
+    itemType;
+    constructor({ itemType, ...superParameters }) {
+        super(superParameters);
+        this.itemType = itemType;
+    }
+    equals(other) {
+        if (!super.equals(other)) {
+            return false;
+        }
+        if (!Type.equals(this.itemType, other.itemType)) {
+            return false;
+        }
+        return true;
+    }
+    toString() {
+        return `${this.kind}(itemType=${this.itemType})`;
+    }
+}
+(function (AbstractContainerType) {
+    function isItemType(type) {
+        switch (type.kind) {
+            case "BlankNodeType":
+            case "IdentifierType":
+            case "IntersectionType":
+            case "IriType":
+            case "ListType":
+            case "LiteralType":
+            case "ObjectIntersectionType":
+            case "ObjectType":
+            case "ObjectUnionType":
+            case "TermType":
+            case "UnionType":
+                return true;
+            case "DefaultValueType":
+            case "LazyObjectOptionType":
+            case "LazyObjectSetType":
+            case "LazyObjectType":
+            case "OptionType":
+            case "SetType":
+                return false;
+            case "PlaceholderType":
+                throw new Error("should never happen");
+        }
+    }
+    AbstractContainerType.isItemType = isItemType;
+})(AbstractContainerType || (AbstractContainerType = {}));
+//# sourceMappingURL=AbstractContainerType.js.map

package/dist/ast/AbstractLazyObjectType.d.ts

@@ -0,0 +1,25 @@
+import { AbstractType } from "./AbstractType.js";
+import type { ObjectType } from "./ObjectType.js";
+import type { ObjectUnionType } from "./ObjectUnionType.js";
+import type { OptionType } from "./OptionType.js";
+import type { SetType } from "./SetType.js";
+/**
+ * Abstract base class of LazyObjectOptionType, LazyObjectSetType, and LazyObjectType.
+ */
+export declare abstract class AbstractLazyObjectType<PartialTypeT extends AbstractLazyObjectType.PartialTypeConstraint, ResolveTypeT extends AbstractLazyObjectType.ResolveTypeConstraint> extends AbstractType {
+    abstract readonly kind: "LazyObjectOptionType" | "LazyObjectSetType" | "LazyObjectType";
+    readonly partialType: PartialTypeT;
+    readonly resolveType: ResolveTypeT;
+    constructor({ partialType, resolveType, ...superParameters }: {
+        partialType: PartialTypeT;
+        resolveType: ResolveTypeT;
+    } & ConstructorParameters<typeof AbstractType>[0]);
+    equals(other: AbstractLazyObjectType<PartialTypeT, ResolveTypeT>): boolean;
+    toString(): string;
+}
+export declare namespace AbstractLazyObjectType {
+    type ObjectTypeConstraint = ObjectType | ObjectUnionType;
+    type PartialTypeConstraint = ObjectTypeConstraint | OptionType<ObjectTypeConstraint> | SetType<ObjectTypeConstraint>;
+    type ResolveTypeConstraint = PartialTypeConstraint;
+}
+//# sourceMappingURL=AbstractLazyObjectType.d.ts.map

package/dist/ast/AbstractLazyObjectType.js

@@ -0,0 +1,30 @@
+import { AbstractType } from "./AbstractType.js";
+import { Type } from "./Type.js";
+/**
+ * Abstract base class of LazyObjectOptionType, LazyObjectSetType, and LazyObjectType.
+ */
+export class AbstractLazyObjectType extends AbstractType {
+    partialType;
+    resolveType;
+    constructor({ partialType, resolveType, ...superParameters }) {
+        super(superParameters);
+        this.partialType = partialType;
+        this.resolveType = resolveType;
+    }
+    equals(other) {
+        if (!super.equals(other)) {
+            return false;
+        }
+        if (!Type.equals(this.partialType, other.partialType)) {
+            return false;
+        }
+        if (!Type.equals(this.resolveType, other.resolveType)) {
+            return false;
+        }
+        return true;
+    }
+    toString() {
+        return `${this.kind}(partialType=${this.partialType}, resolveType=${this.resolveType})`;
+    }
+}
+//# sourceMappingURL=AbstractLazyObjectType.js.map

package/dist/ast/AbstractObjectCompoundType.d.ts

@@ -0,0 +1,45 @@
+import type { BlankNode, NamedNode } from "@rdfjs/types";
+import { Either, Maybe } from "purify-ts";
+import type { TsFeature } from "../enums/TsFeature.js";
+import { AbstractCompoundType } from "./AbstractCompoundType.js";
+import { BlankNodeType } from "./BlankNodeType.js";
+import { IdentifierType } from "./IdentifierType.js";
+import { IriType } from "./IriType.js";
+import type { ObjectIntersectionType } from "./ObjectIntersectionType.js";
+import type { ObjectType } from "./ObjectType.js";
+import type { ObjectUnionType } from "./ObjectUnionType.js";
+import type { Type } from "./Type.js";
+/**
+ * Abstract base class for a compound of object types, such as an intersection or union.
+ */
+export declare abstract class AbstractObjectCompoundType<ObjectCompoundTypeT extends ObjectIntersectionType | ObjectUnionType> extends AbstractCompoundType<ObjectCompoundTypeT | ObjectType> {
+    #private;
+    /**
+     * Should generated code derived from this type be visible outside its module?
+     *
+     * Defaults to true.
+     */
+    readonly export: boolean;
+    abstract readonly kind: "ObjectIntersectionType" | "ObjectUnionType";
+    /**
+     * Name of this type, from shaclmate:name.
+     */
+    readonly name: Maybe<string>;
+    /**
+     * Identifier of the shape this ObjectType was derived from.
+     */
+    readonly shapeIdentifier: BlankNode | NamedNode;
+    constructor({ export_, name, shapeIdentifier, tsFeatures, ...superParameters }: {
+        export_: boolean;
+        name: Maybe<string>;
+        shapeIdentifier: BlankNode | NamedNode;
+        tsFeatures: Maybe<ReadonlySet<TsFeature>>;
+    } & ConstructorParameters<typeof AbstractCompoundType<ObjectCompoundTypeT | ObjectType>>[0]);
+    equals(other: AbstractObjectCompoundType<ObjectCompoundTypeT>): boolean;
+    get identifierType(): BlankNodeType | IdentifierType | IriType;
+    get memberObjectTypes(): readonly ObjectType[];
+    get tsFeatures(): ReadonlySet<TsFeature>;
+    addMemberType(memberType: Type): Either<Error, void>;
+    toString(): string;
+}
+//# sourceMappingURL=AbstractObjectCompoundType.d.ts.map

package/dist/ast/AbstractObjectCompoundType.js

@@ -0,0 +1,180 @@
+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 TermSet from "@rdfjs/term-set";
+import { Either, Maybe } from "purify-ts";
+import { Resource } from "rdfjs-resource";
+import { invariant } from "ts-invariant";
+import { Memoize } from "typescript-memoize";
+import { AbstractCompoundType } from "./AbstractCompoundType.js";
+import { BlankNodeType } from "./BlankNodeType.js";
+import { IdentifierType } from "./IdentifierType.js";
+import { IriType } from "./IriType.js";
+/**
+ * Abstract base class for a compound of object types, such as an intersection or union.
+ */
+export class AbstractObjectCompoundType extends AbstractCompoundType {
+    /**
+     * Should generated code derived from this type be visible outside its module?
+     *
+     * Defaults to true.
+     */
+    export;
+    /**
+     * Name of this type, from shaclmate:name.
+     */
+    name;
+    /**
+     * Identifier of the shape this ObjectType was derived from.
+     */
+    shapeIdentifier;
+    /**
+     * TypeScript features to generate.
+     */
+    #tsFeatures;
+    constructor({ export_, name, shapeIdentifier, tsFeatures, ...superParameters }) {
+        super(superParameters);
+        this.export = export_;
+        this.name = name;
+        this.shapeIdentifier = shapeIdentifier;
+        this.#tsFeatures = tsFeatures;
+    }
+    equals(other) {
+        // Don't recurse
+        return this.shapeIdentifier.equals(other.shapeIdentifier);
+    }
+    get identifierType() {
+        const memberIdentifierTypeNodeKinds = new Set();
+        const memberIdentifierTypesIn = new TermSet();
+        for (const memberType of this.memberTypes) {
+            for (const nodeKind of memberType.identifierType.nodeKinds) {
+                memberIdentifierTypeNodeKinds.add(nodeKind);
+            }
+            for (const in_ of memberType.identifierType.in_) {
+                memberIdentifierTypesIn.add(in_);
+            }
+        }
+        invariant(memberIdentifierTypeNodeKinds.size > 0);
+        if (memberIdentifierTypeNodeKinds.size === 2) {
+            return new IdentifierType({
+                comment: Maybe.empty(),
+                label: Maybe.empty(),
+            });
+        }
+        const memberIdentifierTypeNodeKind = [...memberIdentifierTypeNodeKinds][0];
+        switch (memberIdentifierTypeNodeKind) {
+            case "BlankNode":
+                return new BlankNodeType({
+                    comment: Maybe.empty(),
+                    label: Maybe.empty(),
+                });
+            case "IRI":
+                return new IriType({
+                    comment: Maybe.empty(),
+                    hasValues: [],
+                    in_: [...memberIdentifierTypesIn],
+                    label: Maybe.empty(),
+                });
+            default:
+                memberIdentifierTypeNodeKind;
+                throw new Error("should never reach here");
+        }
+    }
+    get memberObjectTypes() {
+        const memberObjectTypes = [];
+        for (const memberType of this.memberTypes) {
+            switch (memberType.kind) {
+                case "ObjectType":
+                    memberObjectTypes.push(memberType);
+                    break;
+                case "ObjectIntersectionType":
+                case "ObjectUnionType": {
+                    invariant(memberType.kind === this.kind);
+                    memberObjectTypes.push(...memberType.memberObjectTypes);
+                    break;
+                }
+            }
+        }
+        invariant(memberObjectTypes.length >= this.memberTypes.length);
+        // Member object types must have distinct RDF types or no RDF types at all.
+        const fromRdfTypes = new TermSet();
+        let expectUniqueFromRdfTypesCount = 0;
+        for (const memberObjectType of memberObjectTypes) {
+            if (memberObjectType.extern) {
+                continue;
+            }
+            expectUniqueFromRdfTypesCount++;
+            memberObjectType.fromRdfType.ifJust((fromRdfType) => fromRdfTypes.add(fromRdfType));
+        }
+        if (fromRdfTypes.size > 0 &&
+            fromRdfTypes.size !== expectUniqueFromRdfTypesCount) {
+            throw new Error(`one or more ${this} members ([${memberObjectTypes.map((memberType) => memberType.toString()).join(", ")}]) lack distinguishing fromRdfType's ({${[...fromRdfTypes].map((fromRdfType) => Resource.Identifier.toString(fromRdfType)).join(", ")}})`);
+        }
+        return memberObjectTypes;
+    }
+    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 memberTypeI = 0; memberTypeI < this.memberObjectTypes.length; memberTypeI++) {
+            const memberType = this.memberObjectTypes[memberTypeI];
+            if (memberTypeI === 0) {
+                for (const tsFeature of memberType.tsFeatures) {
+                    mergedMemberTsFeatures.add(tsFeature);
+                }
+            }
+            if (memberType.tsFeatures.size !== mergedMemberTsFeatures.size) {
+                throw new Error(`${this} has a member ObjectType (${memberType}) with different tsFeatures than the other member ObjectType's`);
+            }
+            for (const tsFeature of memberType.tsFeatures) {
+                if (!mergedMemberTsFeatures.has(tsFeature)) {
+                    throw new Error(`${this} has a member ObjectType (${memberType}) with different tsFeatures than the other member ObjectType's`);
+                }
+            }
+        }
+        return this.#tsFeatures.orDefault(mergedMemberTsFeatures);
+    }
+    addMemberType(memberType) {
+        return Either.encase(() => {
+            switch (memberType.kind) {
+                case "ObjectType":
+                    super.addMemberType(memberType);
+                    break;
+                case "ObjectIntersectionType":
+                    if (this.kind === memberType.kind) {
+                        super.addMemberType(memberType);
+                    }
+                    else {
+                        throw new Error(`${this}: has incompatible compound type composition (has-a ${memberType})`);
+                    }
+                    break;
+                case "ObjectUnionType":
+                    if (this.kind === memberType.kind) {
+                        super.addMemberType(memberType);
+                    }
+                    else {
+                        throw new Error(`${this}: has incompatible compound type composition (has-a ${memberType})`);
+                    }
+                    break;
+                default:
+                    throw new Error(`${this} has one or more non-(ObjectIntersectionType | ObjectType | ObjectUnionType) node shapes in its logical constraint`);
+            }
+        });
+    }
+    toString() {
+        return `${this.kind}(shapeIdentifier=${Resource.Identifier.toString(this.shapeIdentifier)})`;
+    }
+}
+__decorate([
+    Memoize()
+], AbstractObjectCompoundType.prototype, "identifierType", null);
+__decorate([
+    Memoize()
+], AbstractObjectCompoundType.prototype, "memberObjectTypes", null);
+__decorate([
+    Memoize()
+], AbstractObjectCompoundType.prototype, "tsFeatures", null);
+//# sourceMappingURL=AbstractObjectCompoundType.js.map