@shaclmate/compiler 4.0.48 → 4.0.50

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstStructType.js

@@ -1,166 +0,0 @@
-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 && nodeShapeIdentifier.termType === "NamedNode") {
-                fromRdfType = fromRdfType.alt(Maybe.of(nodeShapeIdentifier));
-            }
-            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

@@ -1,12 +0,0 @@
-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

@@ -1,110 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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

@@ -1,46 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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

@@ -1,45 +0,0 @@
-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

@@ -1,81 +0,0 @@
-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

@@ -1,44 +0,0 @@
-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

@@ -1,63 +0,0 @@
-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