@shaclmate/compiler 4.0.50 → 4.0.52

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstStructType.js

@@ -0,0 +1,171 @@
+import { owl, rdfs } 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 { defaultNodeShapeNodeKinds } from "./defaultNodeShapeNodeKinds.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.type.kind) {
+        case "DefaultValue":
+            return false;
+        case "LazyOption":
+            return false;
+        case "LazySet":
+            return field.type.partialType.minCount > 0n;
+        case "Option":
+            return false;
+        case "Set":
+            return field.type.minCount > 0;
+        case "Union":
+            return field.type.members.every((member) => isStructTypeFieldRequired({ type: member.type }));
+        case "BlankNode":
+        case "Identifier":
+        case "Iri":
+        case "Lazy":
+        case "List":
+        case "Literal":
+        case "Struct":
+        case "Term":
+            return true;
+        case "Intersection":
+            throw new Error("unsupported");
+        default:
+            field.type;
+            throw new Error("should never reach this point");
+    }
+}
+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 (shape.$type !== "NodeShape") {
+            return Either.of(Maybe.empty());
+        }
+        const nodeShape = shape;
+        if (nodeShape.and.orDefault([]).length > 0 ||
+            nodeShape.xone.orDefault([]).length > 0) {
+            return Either.of(Maybe.empty());
+        }
+        if (!nodeShape.extern.orDefault(false)) {
+            if (nodeShape.properties.length === 0) {
+                // A node shape must have sh:property to be considered a StructType
+                return Either.of(Maybe.empty());
+            }
+        } // else assume all extern node shapes are structs
+        return Eithers.chain2(shapeNodeKinds.call(this, nodeShape, { defaultNodeShapeNodeKinds }), Either.sequence(nodeShape.properties.map((propertyShapeIdentifier) => this.shapesGraph.propertyShape(propertyShapeIdentifier)))).chain(([nodeKinds, propertyShapes]) => {
+            const nodeShapeIdentifier = nodeShape.$identifier();
+            const isClass = nodeShape.subClassOf.length > 0 ||
+                nodeShape.types.some((type) => type.equals(owl.Class) || type.equals(rdfs.Class));
+            let fromRdfType = nodeShape.fromRdfType.alt(nodeShape.rdfType);
+            if (isClass) {
+                if (nodeShapeIdentifier.termType === "NamedNode") {
+                    fromRdfType = fromRdfType.alt(Maybe.of(nodeShapeIdentifier));
+                }
+            }
+            else if (nodeShape.targetClasses.length > 0) {
+                fromRdfType = fromRdfType.alt(Maybe.of(nodeShape.targetClasses[0]));
+            }
+            const 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);
+                }
+            });
+            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.in_.isNothing());
+                identifierType = new ast.IdentifierType(identifierTypeProperties);
+            }
+            else {
+                switch ([...nodeKinds][0]) {
+                    case "BlankNode":
+                        invariant(nodeShape.in_.isNothing());
+                        identifierType = new ast.BlankNodeType(identifierTypeProperties);
+                        break;
+                    case "IRI":
+                        identifierType = new ast.IriType({
+                            ...identifierTypeProperties,
+                            hasValues: [],
+                            in_: nodeShape.in_
+                                .orDefault([])
+                                .filter((_) => _.termType === "NamedNode"),
+                        });
+                        break;
+                    default:
+                        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 structType = new ast.StructType({
+                comment: nodeShape.comment,
+                extern: nodeShape.extern.orDefault(false),
+                fromRdfType,
+                label: nodeShape.label,
+                identifierType,
+                name: shapeAstTypeName(nodeShape),
+                shapeIdentifier: nodeShape.$identifier(),
+                synthetic: false,
+                toRdfTypes,
+                tsImports: nodeShape.tsImports,
+            });
+            this.cachedAstTypesByShapeIdentifier.set(nodeShape.$identifier(), structType);
+            return (() => {
+                // Populate properties
+                for (const propertyShape of propertyShapes) {
+                    const fieldEither = transformPropertyShapeToAstStructTypeField.call(this, {
+                        propertyShape,
+                        structType,
+                    });
+                    if (fieldEither.isLeft()) {
+                        return fieldEither;
+                    }
+                    fieldEither.ifRight((property) => {
+                        property.ifJust((property) => {
+                            structType.addFields(property);
+                        });
+                    });
+                }
+                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(() => {
+                this.cachedAstTypesByShapeIdentifier.delete(nodeShape.$identifier());
+            });
+        });
+    }
+    finally {
+        shapeStack.pop(shape);
+    }
+}
+//# sourceMappingURL=transformShapeToAstStructType.js.map

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstTermType.d.ts

@@ -0,0 +1,12 @@
+import { Either } 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";
+type AstTermType = ast.BlankNodeType | ast.DefaultValueType<ast.IdentifierType | ast.LiteralType | ast.IriType | ast.TermType> | ast.IdentifierType | ast.IriType | ast.LiteralType | ast.TermType;
+/**
+ * Try to convert a shape to an AST TermType using some heuristics.
+ */
+export declare function transformShapeToAstTermType(this: ShapesGraphToAstTransformer, shape: input.Shape, shapeStack: ShapeStack): Either<Error, AstTermType>;
+export {};
+//# sourceMappingURL=transformShapeToAstTermType.d.ts.map

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstTermType.js

@@ -0,0 +1,110 @@
+import { Either, Left, Maybe } from "purify-ts";
+import { invariant } from "ts-invariant";
+import * as ast from "../ast/index.js";
+import { shapeAstTypeName } from "./shapeAstTypeName.js";
+import { shapeNodeKinds } from "./shapeNodeKinds.js";
+/**
+ * Try to convert a shape to an AST TermType using some heuristics.
+ */
+export function transformShapeToAstTermType(shape, shapeStack) {
+    shapeStack.push(shape);
+    try {
+        return shapeNodeKinds.call(this, shape).chain((nodeKinds) => {
+            const hasValues = shapeStack.constraints.hasValues;
+            const in_ = shapeStack.constraints.in_;
+            const astAbstractTypeProperties = {
+                comment: Maybe.empty(),
+                name: shapeAstTypeName(shape),
+                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);
+                        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.datatype,
+                            hasValues: hasValues.filter((_) => _.termType === "Literal"),
+                            in_: in_.filter((_) => _.termType === "Literal"),
+                            languageIn: shape.languageIn
+                                .map((languageIn) => [...new Set(languageIn)])
+                                .orDefault([]),
+                            maxExclusive: shape.maxExclusive,
+                            maxInclusive: shape.maxInclusive,
+                            minExclusive: shape.minExclusive,
+                            minInclusive: shape.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 "BlankNode":
+                        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 {
+        shapeStack.pop(shape);
+    }
+}
+//# sourceMappingURL=transformShapeToAstTermType.js.map

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstType.d.ts

@@ -0,0 +1,11 @@
+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 transform a shape to an AST type using some heuristics. All shape -> AST type transformation calls should go through this function,
+ * not the other transformShapeToAst*Type functions directly.
+ */
+export declare function transformShapeToAstType(this: ShapesGraphToAstTransformer, shape: input.Shape, shapeStack: ShapeStack): Either<Error, ast.Type>;
+//# sourceMappingURL=transformShapeToAstType.d.ts.map

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstType.js

@@ -0,0 +1,46 @@
+import { Either, Left } from "purify-ts";
+import { transformShapeToAstCompoundType } from "./transformShapeToAstCompoundType.js";
+import { transformShapeToAstListType } from "./transformShapeToAstListType.js";
+import { transformShapeToAstStructType } from "./transformShapeToAstStructType.js";
+import { transformShapeToAstTermType } from "./transformShapeToAstTermType.js";
+const tryTransformShapeToAstTypeMethods = [
+    transformShapeToAstListType, // List type must be before compound type since a list shape uses sh:xone
+    transformShapeToAstCompoundType,
+    transformShapeToAstStructType,
+];
+/**
+ * Try to transform a shape to an AST type using some heuristics. All shape -> AST type transformation calls should go through this function,
+ * not the other transformShapeToAst*Type functions directly.
+ */
+export function transformShapeToAstType(shape, shapeStack) {
+    if (shape.ignore) {
+        // ShapesGraphToAstTransformer and the property shape -> property transformation code skip shapes with .igniroe,
+        // so any call to this method with a shape that has .ignore=true is a reference to an ignored shape.
+        return Left(new Error(`reference to ignored ${shape}`));
+    }
+    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/AbstractCollectionType.d.ts

@@ -0,0 +1,30 @@
+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: "List" | "Set";
+    /**
+     * 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;
+    toJSON(): {
+        mutable: boolean | undefined;
+        itemType: any;
+        comment: string | undefined;
+        kind: string;
+        label: string | undefined;
+        name: string | undefined;
+        recursive: boolean | undefined;
+        shapeIdentifier: import("@rdfjs/types").BlankNode | import("@rdfjs/types").NamedNode<string>;
+    };
+}
+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,33 @@
+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;
+    }
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            mutable: this.mutable ? true : undefined,
+        };
+    }
+}
+(function (AbstractCollectionType) {
+    AbstractCollectionType.isItemType = AbstractContainerType.isItemType;
+})(AbstractCollectionType || (AbstractCollectionType = {}));
+//# sourceMappingURL=AbstractCollectionType.js.map

package/dist/ast/AbstractCompoundType.d.ts

@@ -0,0 +1,45 @@
+import type { NodeKind } from "@shaclmate/shacl-ast";
+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 { StructType } from "./StructType.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<MemberT extends AbstractCompoundType.Member<MemberTypeT>, MemberTypeT extends AbstractCompoundType.MemberType> extends AbstractType {
+    #private;
+    /**
+     * Type discriminant
+     */
+    abstract readonly kind: "Intersection" | "Union";
+    /**
+     * Was this type synthesized or did it come from SHACL?
+     */
+    readonly synthetic: boolean;
+    constructor({ synthetic, ...superParameters }: {
+        synthetic: boolean;
+    } & ConstructorParameters<typeof AbstractType>[0]);
+    get members(): readonly MemberT[];
+    get nodeKinds(): ReadonlySet<NodeKind>;
+    get recursive(): boolean;
+    addMember(member: MemberT): void;
+    equals(other: AbstractCompoundType<MemberT, MemberTypeT>): boolean;
+}
+export declare namespace AbstractCompoundType {
+    interface Member<TypeT extends MemberType> {
+        readonly type: TypeT;
+    }
+    type MemberType = BlankNodeType | IdentifierType | IntersectionType | IriType | ListType | LiteralType | StructType | TermType | UnionType;
+    function isMemberType(type: Type): type is MemberType;
+}
+//# sourceMappingURL=AbstractCompoundType.d.ts.map

package/dist/ast/AbstractCompoundType.js

@@ -0,0 +1,81 @@
+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 { Memoize } from "typescript-memoize";
+import { AbstractType } from "./AbstractType.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 {
+    /**
+     * Members.
+     *
+     * Mutable to support cycle-handling logic in the compiler.
+     */
+    #members = [];
+    /**
+     * Was this type synthesized or did it come from SHACL?
+     */
+    synthetic;
+    constructor({ synthetic, ...superParameters }) {
+        super(superParameters);
+        this.synthetic = synthetic;
+    }
+    get members() {
+        return this.#members;
+    }
+    get nodeKinds() {
+        const nodeKinds = new Set();
+        for (const member of this.members) {
+            for (const nodeKind of member.type.nodeKinds) {
+                nodeKinds.add(nodeKind);
+            }
+        }
+        return nodeKinds;
+    }
+    get recursive() {
+        return this.members.some((member) => member.type.recursive);
+    }
+    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);
+    }
+}
+__decorate([
+    Memoize()
+], AbstractCompoundType.prototype, "nodeKinds", null);
+(function (AbstractCompoundType) {
+    function isMemberType(type) {
+        switch (type.kind) {
+            case "BlankNode":
+            case "Identifier":
+            case "Intersection":
+            case "Iri":
+            case "List":
+            case "Literal":
+            case "Struct":
+            case "Term":
+            case "Union":
+                return true;
+            case "DefaultValue":
+            case "LazyOption":
+            case "LazySet":
+            case "Lazy":
+            case "Option":
+            case "Set":
+                return false;
+        }
+    }
+    AbstractCompoundType.isMemberType = isMemberType;
+})(AbstractCompoundType || (AbstractCompoundType = {}));
+//# sourceMappingURL=AbstractCompoundType.js.map

package/dist/ast/AbstractContainerType.d.ts

@@ -0,0 +1,44 @@
+import type { NodeKind } from "@shaclmate/shacl-ast";
+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 { StructType } from "./StructType.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: "DefaultValue" | "List" | "Option" | "Set";
+    /**
+     * Container item type.
+     *
+     * Mutable to support cycle-handling logic in the compiler.
+     */
+    itemType: ItemTypeT;
+    constructor({ itemType, ...superParameters }: {
+        itemType: ItemTypeT;
+    } & ConstructorParameters<typeof AbstractType>[0]);
+    get nodeKinds(): ReadonlySet<NodeKind>;
+    get recursive(): boolean;
+    equals(other: AbstractContainerType<ItemTypeT>): boolean;
+    toJSON(): {
+        itemType: any;
+        comment: string | undefined;
+        kind: string;
+        label: string | undefined;
+        name: string | undefined;
+        recursive: boolean | undefined;
+        shapeIdentifier: import("@rdfjs/types").BlankNode | import("@rdfjs/types").NamedNode<string>;
+    };
+}
+export declare namespace AbstractContainerType {
+    type ItemType = BlankNodeType | IdentifierType | IntersectionType | IriType | ListType | LiteralType | StructType | TermType | UnionType;
+    function isItemType(type: Type): type is ItemType;
+}
+//# sourceMappingURL=AbstractContainerType.d.ts.map

package/dist/ast/AbstractContainerType.js

@@ -0,0 +1,63 @@
+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;
+    }
+    get nodeKinds() {
+        return this.itemType.nodeKinds;
+    }
+    get recursive() {
+        return this.itemType.recursive;
+    }
+    equals(other) {
+        if (!super.equals(other)) {
+            return false;
+        }
+        if (!Type.equals(this.itemType, other.itemType)) {
+            return false;
+        }
+        return true;
+    }
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            itemType: this.itemType.toJSON(),
+        };
+    }
+}
+(function (AbstractContainerType) {
+    function isItemType(type) {
+        switch (type.kind) {
+            case "BlankNode":
+            case "Identifier":
+            case "Intersection":
+            case "Iri":
+            case "List":
+            case "Literal":
+            case "Struct":
+            case "Term":
+            case "Union":
+                return true;
+            case "DefaultValue":
+            case "LazyOption":
+            case "LazySet":
+            case "Lazy":
+            case "Option":
+            case "Set":
+                return false;
+        }
+    }
+    AbstractContainerType.isItemType = isItemType;
+})(AbstractContainerType || (AbstractContainerType = {}));
+//# sourceMappingURL=AbstractContainerType.js.map