@shaclmate/compiler 2.0.23 → 3.0.0

package/dist/ShapesGraphToAstTransformer.d.ts

@@ -13,12 +13,12 @@ export declare class ShapesGraphToAstTransformer {
     protected shapeAstName: typeof _ShapesGraphToAstTransformer.shapeAstName;
     protected readonly shapesGraph: input.ShapesGraph;
     protected transformNodeShapeToAstType: typeof _ShapesGraphToAstTransformer.transformNodeShapeToAstType;
-    protected transformPropertyShapeToAstCompositeType: typeof _ShapesGraphToAstTransformer.transformPropertyShapeToAstCompositeType;
-    protected transformPropertyShapeToAstIdentifierType: typeof _ShapesGraphToAstTransformer.transformPropertyShapeToAstIdentifierType;
-    protected transformPropertyShapeToAstLiteralType: typeof _ShapesGraphToAstTransformer.transformPropertyShapeToAstLiteralType;
     protected transformPropertyShapeToAstObjectTypeProperty: typeof _ShapesGraphToAstTransformer.transformPropertyShapeToAstObjectTypeProperty;
-    protected transformPropertyShapeToAstTermType: typeof _ShapesGraphToAstTransformer.transformPropertyShapeToAstTermType;
-    protected transformPropertyShapeToAstType: typeof _ShapesGraphToAstTransformer.transformPropertyShapeToAstType;
+    protected transformShapeToAstCompositeType: typeof _ShapesGraphToAstTransformer.transformShapeToAstCompositeType;
+    protected transformShapeToAstIdentifierType: typeof _ShapesGraphToAstTransformer.transformShapeToAstIdentifierType;
+    protected transformShapeToAstLiteralType: typeof _ShapesGraphToAstTransformer.transformShapeToAstLiteralType;
+    protected transformShapeToAstTermType: typeof _ShapesGraphToAstTransformer.transformShapeToAstTermType;
+    protected transformShapeToAstType: typeof _ShapesGraphToAstTransformer.transformShapeToAstType;
     constructor({ iriPrefixMap, shapesGraph, }: {
         iriPrefixMap: PrefixMap;
         shapesGraph: input.ShapesGraph;

package/dist/ShapesGraphToAstTransformer.js

@@ -11,12 +11,12 @@ export class ShapesGraphToAstTransformer {
     shapeAstName = _ShapesGraphToAstTransformer.shapeAstName;
     shapesGraph;
     transformNodeShapeToAstType = _ShapesGraphToAstTransformer.transformNodeShapeToAstType;
-    transformPropertyShapeToAstCompositeType = _ShapesGraphToAstTransformer.transformPropertyShapeToAstCompositeType;
-    transformPropertyShapeToAstIdentifierType = _ShapesGraphToAstTransformer.transformPropertyShapeToAstIdentifierType;
-    transformPropertyShapeToAstLiteralType = _ShapesGraphToAstTransformer.transformPropertyShapeToAstLiteralType;
     transformPropertyShapeToAstObjectTypeProperty = _ShapesGraphToAstTransformer.transformPropertyShapeToAstObjectTypeProperty;
-    transformPropertyShapeToAstTermType = _ShapesGraphToAstTransformer.transformPropertyShapeToAstTermType;
-    transformPropertyShapeToAstType = _ShapesGraphToAstTransformer.transformPropertyShapeToAstType;
+    transformShapeToAstCompositeType = _ShapesGraphToAstTransformer.transformShapeToAstCompositeType;
+    transformShapeToAstIdentifierType = _ShapesGraphToAstTransformer.transformShapeToAstIdentifierType;
+    transformShapeToAstLiteralType = _ShapesGraphToAstTransformer.transformShapeToAstLiteralType;
+    transformShapeToAstTermType = _ShapesGraphToAstTransformer.transformShapeToAstTermType;
+    transformShapeToAstType = _ShapesGraphToAstTransformer.transformShapeToAstType;
     constructor({ iriPrefixMap, shapesGraph, }) {
         this.iriPrefixMap = iriPrefixMap;
         this.shapesGraph = shapesGraph;

package/dist/_ShapesGraphToAstTransformer/InheritableShapeConstraints.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=InheritableShapeConstraints.d.ts.map

package/dist/_ShapesGraphToAstTransformer/InheritableShapeConstraints.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=InheritableShapeConstraints.js.map

package/dist/_ShapesGraphToAstTransformer/ShapeStack.d.ts

@@ -0,0 +1,15 @@
+import type { Literal, NamedNode } from "@rdfjs/types";
+import { Maybe } from "purify-ts";
+import * as input from "../input/index.js";
+export declare class ShapeStack {
+    private readonly stack;
+    constructor();
+    readonly constraints: {
+        readonly hasValues: readonly (Literal | NamedNode)[];
+        readonly in_: readonly (Literal | NamedNode)[];
+    };
+    get defaultValue(): Maybe<Literal | NamedNode>;
+    pop(shape: input.Shape): this;
+    push(shape: input.Shape): this;
+}
+//# sourceMappingURL=ShapeStack.d.ts.map

package/dist/_ShapesGraphToAstTransformer/ShapeStack.js

@@ -0,0 +1,51 @@
+import { Maybe } from "purify-ts";
+import { invariant } from "ts-invariant";
+import * as input from "../input/index.js";
+export class ShapeStack {
+    stack = [];
+    constructor() {
+        const stack = this.stack;
+        this.constraints = {
+            get hasValues() {
+                for (const shape of stack.toReversed()) {
+                    if (shape.constraints.hasValues.length > 0) {
+                        return shape.constraints.hasValues;
+                    }
+                }
+                return [];
+            },
+            get in_() {
+                for (const shape of stack.toReversed()) {
+                    if (shape.constraints.in_.length > 0) {
+                        return shape.constraints.in_;
+                    }
+                }
+                return [];
+            },
+        };
+    }
+    constraints;
+    get defaultValue() {
+        for (const shape of this.stack.toReversed()) {
+            if (!(shape instanceof input.PropertyShape)) {
+                continue;
+            }
+            if (shape.defaultValue.isJust()) {
+                return shape.defaultValue;
+            }
+        }
+        return Maybe.empty();
+    }
+    pop(shape) {
+        const poppedShape = this.stack.pop();
+        invariant(poppedShape, "stack is empty");
+        invariant(Object.is(poppedShape, shape), "tried to pop wrong shape from stack");
+        return this;
+    }
+    push(shape) {
+        invariant(!this.stack.some((stackShape) => Object.is(stackShape, shape)), "shape already on stack");
+        this.stack.push(shape);
+        return this;
+    }
+}
+//# sourceMappingURL=ShapeStack.js.map

package/dist/_ShapesGraphToAstTransformer/index.d.ts

@@ -2,9 +2,9 @@ export * from "./NodeShapeAstType.js";
 export * from "./shapeAstName.js";
 export * from "./transformNodeShapeToAstType.js";
 export * from "./transformPropertyShapeToAstObjectTypeProperty.js";
-export * from "./transformPropertyShapeToAstCompositeType.js";
-export * from "./transformPropertyShapeToAstIdentifierType.js";
-export * from "./transformPropertyShapeToAstLiteralType.js";
-export * from "./transformPropertyShapeToAstType.js";
-export * from "./transformPropertyShapeToAstTermType.js";
+export * from "./transformShapeToAstCompositeType.js";
+export * from "./transformShapeToAstIdentifierType.js";
+export * from "./transformShapeToAstLiteralType.js";
+export * from "./transformShapeToAstType.js";
+export * from "./transformShapeToAstTermType.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/_ShapesGraphToAstTransformer/index.js

@@ -2,9 +2,9 @@ export * from "./NodeShapeAstType.js";
 export * from "./shapeAstName.js";
 export * from "./transformNodeShapeToAstType.js";
 export * from "./transformPropertyShapeToAstObjectTypeProperty.js";
-export * from "./transformPropertyShapeToAstCompositeType.js";
-export * from "./transformPropertyShapeToAstIdentifierType.js";
-export * from "./transformPropertyShapeToAstLiteralType.js";
-export * from "./transformPropertyShapeToAstType.js";
-export * from "./transformPropertyShapeToAstTermType.js";
+export * from "./transformShapeToAstCompositeType.js";
+export * from "./transformShapeToAstIdentifierType.js";
+export * from "./transformShapeToAstLiteralType.js";
+export * from "./transformShapeToAstType.js";
+export * from "./transformShapeToAstTermType.js";
 //# sourceMappingURL=index.js.map

package/dist/_ShapesGraphToAstTransformer/transformPropertyShapeToAstObjectTypeProperty.js

@@ -1,6 +1,7 @@
 import N3 from "n3";
 import { Either, Left, Maybe } from "purify-ts";
 import { invariant } from "ts-invariant";
+import { ShapeStack } from "./ShapeStack.js";
 import { pickLiteral } from "./pickLiteral.js";
 function identifierNodeKinds(type) {
     switch (type.kind) {
@@ -56,6 +57,53 @@ function synthesizeStubAstObjectType({ identifierNodeKinds, tsFeatures, }) {
         tsObjectDeclarationType: "class",
     };
 }
+function transformPropertyShapeToAstType(propertyShape) {
+    const itemTypeEither = this.transformShapeToAstType(propertyShape, new ShapeStack());
+    if (itemTypeEither.isLeft()) {
+        return itemTypeEither;
+    }
+    const itemType = itemTypeEither.unsafeCoerce();
+    if (propertyShape.defaultValue.isJust()) {
+        return Either.of(itemType);
+    }
+    if (propertyShape.constraints.maxCount.isNothing() &&
+        propertyShape.constraints.minCount.isNothing()) {
+        return Either.of({
+            itemType,
+            kind: "SetType",
+            mutable: propertyShape.mutable,
+            minCount: 0,
+        });
+    }
+    let maxCount = propertyShape.constraints.maxCount.orDefault(Number.MAX_SAFE_INTEGER);
+    let minCount = propertyShape.constraints.minCount.orDefault(0);
+    if (minCount < 0) {
+        minCount = 0;
+    }
+    if (propertyShape.constraints.hasValues.length > minCount) {
+        minCount = propertyShape.constraints.hasValues.length;
+    }
+    if (maxCount < minCount) {
+        maxCount = minCount;
+    }
+    if (minCount === 0 && maxCount === 1) {
+        return Either.of({
+            itemType,
+            kind: "OptionType",
+        });
+    }
+    if (minCount === 1 && maxCount === 1) {
+        return Either.of(itemType);
+    }
+    invariant(propertyShape.constraints.minCount.isJust() ||
+        propertyShape.constraints.maxCount.isJust());
+    return Either.of({
+        itemType,
+        kind: "SetType",
+        minCount,
+        mutable: propertyShape.mutable,
+    });
+}
 export function transformPropertyShapeToAstObjectTypeProperty(propertyShape) {
     {
         const property = this.astObjectTypePropertiesByIdentifier.get(propertyShape.identifier);
@@ -63,13 +111,13 @@ export function transformPropertyShapeToAstObjectTypeProperty(propertyShape) {
             return Either.of(property);
         }
     }
-    const typeEither = this.transformPropertyShapeToAstType(propertyShape, null);
+    const typeEither = transformPropertyShapeToAstType.bind(this)(propertyShape);
     if (typeEither.isLeft()) {
         return typeEither;
     }
     const type = typeEither.unsafeCoerce();
     let stubType = Maybe.empty();
-    let propertyShapeStubType;
+    let propertyShapeStubItemType;
     if (propertyShape.stub.isJust()) {
         const propertyShapeStubTypeEither = this.transformNodeShapeToAstType(propertyShape.stub.unsafeCoerce()).chain((propertyShapeStubType) => {
             switch (propertyShapeStubType.kind) {
@@ -84,48 +132,48 @@ export function transformPropertyShapeToAstObjectTypeProperty(propertyShape) {
         if (propertyShapeStubTypeEither.isLeft()) {
             return propertyShapeStubTypeEither;
         }
-        propertyShapeStubType = propertyShapeStubTypeEither.unsafeCoerce();
+        propertyShapeStubItemType = propertyShapeStubTypeEither.unsafeCoerce();
     }
-    if (propertyShapeStubType || propertyShape.lazy.orDefault(false)) {
+    if (propertyShapeStubItemType || propertyShape.lazy.orDefault(false)) {
         switch (type.kind) {
             case "ObjectType":
-            case "ObjectUnionType": {
-                stubType = Maybe.of(propertyShapeStubType ??
+            case "ObjectUnionType":
+                stubType = Maybe.of(propertyShapeStubItemType ??
                     synthesizeStubAstObjectType({
                         identifierNodeKinds: identifierNodeKinds(type),
                         tsFeatures: type.tsFeatures,
                     }));
                 break;
-            }
             case "OptionType":
             case "SetType": {
                 switch (type.itemType.kind) {
                     case "ObjectType":
-                    case "ObjectUnionType": {
-                        const stubItemType = propertyShapeStubType ??
-                            synthesizeStubAstObjectType({
-                                identifierNodeKinds: identifierNodeKinds(type.itemType),
-                                tsFeatures: type.itemType.tsFeatures,
-                            });
-                        if (type.kind === "OptionType") {
-                            stubType = Maybe.of({
-                                kind: "OptionType",
-                                itemType: stubItemType,
-                            });
-                        }
-                        else {
-                            stubType = Maybe.of({
-                                kind: "SetType",
-                                itemType: stubItemType,
-                                minCount: 0,
-                                mutable: Maybe.empty(),
-                            });
-                        }
+                    case "ObjectUnionType":
                         break;
-                    }
                     default:
                         return Left(new Error(`${propertyShape} marked lazy but has ${type.kind} of ${type.itemType.kind}`));
                 }
+                const stubItemType = propertyShapeStubItemType ??
+                    synthesizeStubAstObjectType({
+                        identifierNodeKinds: identifierNodeKinds(type.itemType),
+                        tsFeatures: type.itemType.tsFeatures,
+                    });
+                switch (type.kind) {
+                    case "OptionType":
+                        stubType = Maybe.of({
+                            kind: "OptionType",
+                            itemType: stubItemType,
+                        });
+                        break;
+                    case "SetType":
+                        stubType = Maybe.of({
+                            kind: "SetType",
+                            itemType: stubItemType,
+                            minCount: 0,
+                            mutable: Maybe.empty(),
+                        });
+                        break;
+                }
                 break;
             }
             default:
@@ -145,7 +193,7 @@ export function transformPropertyShapeToAstObjectTypeProperty(propertyShape) {
         order: propertyShape.order.orDefault(0),
         path,
         stubType,
-        type,
+        type: type,
         visibility: propertyShape.visibility,
     };
     this.astObjectTypePropertiesByIdentifier.set(propertyShape.identifier, property);

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstCompositeType.d.ts

@@ -0,0 +1,10 @@
+import { Either } from "purify-ts";
+import type { ShapesGraphToAstTransformer } from "../ShapesGraphToAstTransformer.js";
+import type * as ast from "../ast/index.js";
+import * as input from "../input/index.js";
+import type { ShapeStack } from "./ShapeStack.js";
+/**
+ * Try to convert a shape to a composite type (intersection or union) using some heuristics.
+ */
+export declare function transformShapeToAstCompositeType(this: ShapesGraphToAstTransformer, shape: input.Shape, shapeStack: ShapeStack): Either<Error, ast.Type>;
+//# sourceMappingURL=transformShapeToAstCompositeType.d.ts.map

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstCompositeType.js

@@ -0,0 +1,185 @@
+import { owl, rdfs } from "@tpluscode/rdf-ns-builders";
+import { Either, Left, Maybe } from "purify-ts";
+import { invariant } from "ts-invariant";
+import * as input from "../input/index.js";
+import { logger } from "../logger.js";
+import { flattenAstObjectCompositeTypeMemberTypes } from "./flattenAstObjectCompositeTypeMemberTypes.js";
+/**
+ * Try to convert a shape to a composite type (intersection or union) using some heuristics.
+ */
+export function transformShapeToAstCompositeType(shape, shapeStack) {
+    shapeStack.push(shape);
+    try {
+        let memberTypeEithers;
+        let compositeTypeKind;
+        if (shape.constraints.and.length > 0) {
+            memberTypeEithers = shape.constraints.and.map((memberShape) => this.transformShapeToAstType(memberShape, shapeStack));
+            compositeTypeKind = "IntersectionType";
+        }
+        else if (shape.constraints.classes.length > 0) {
+            memberTypeEithers = shape.constraints.classes.map((classIri) => {
+                if (classIri.equals(owl.Class) ||
+                    classIri.equals(owl.Thing) ||
+                    classIri.equals(rdfs.Class)) {
+                    return Left(new Error(`class ${classIri.value} is not transformable`));
+                }
+                const classNodeShape = this.shapesGraph
+                    .nodeShapeByIdentifier(classIri)
+                    .extractNullable();
+                if (classNodeShape === null) {
+                    return Left(new Error(`class ${classIri.value} did not resolve to a node shape`));
+                }
+                return this.transformNodeShapeToAstType(classNodeShape);
+            });
+            compositeTypeKind = "IntersectionType";
+            if (Either.rights(memberTypeEithers).length === 0) {
+                // This frequently happens with e.g., sh:class skos:Concept
+                logger.debug("shape %s sh:class(es) did not map to any node shapes", shape);
+                return memberTypeEithers[0];
+            }
+        }
+        else if (shape.constraints.nodes.length > 0) {
+            memberTypeEithers = shape.constraints.nodes.map((nodeShape) => this.transformNodeShapeToAstType(nodeShape));
+            compositeTypeKind = "IntersectionType";
+        }
+        else if (shape.constraints.xone.length > 0) {
+            memberTypeEithers = shape.constraints.xone.map((memberShape) => this.transformShapeToAstType(memberShape, shapeStack));
+            compositeTypeKind = "UnionType";
+        }
+        else {
+            return Left(new Error(`unable to transform ${shape} into an AST type`));
+        }
+        invariant(memberTypeEithers.length > 0);
+        const memberObjectTypes = [];
+        let memberTypes = [];
+        for (const memberTypeEither of memberTypeEithers) {
+            if (memberTypeEither.isLeft()) {
+                return memberTypeEither;
+            }
+            const memberType = memberTypeEither.unsafeCoerce();
+            memberTypes.push(memberType);
+            switch (memberType.kind) {
+                case "ObjectType":
+                case "ObjectIntersectionType":
+                case "ObjectUnionType":
+                    memberObjectTypes.push(memberType);
+                    break;
+            }
+        }
+        if (memberTypes.length === 1) {
+            return Either.of(memberTypes[0]);
+        }
+        if (memberTypes.length === memberObjectTypes.length) {
+            // If all the member types are ast.ObjectType, flatten them.
+            const flattenedMemberObjectTypesEither = flattenAstObjectCompositeTypeMemberTypes({
+                objectCompositeTypeKind: compositeTypeKind === "IntersectionType"
+                    ? "ObjectIntersectionType"
+                    : "ObjectUnionType",
+                memberTypes: memberObjectTypes,
+                shape,
+            });
+            if (flattenedMemberObjectTypesEither.isLeft()) {
+                return flattenedMemberObjectTypesEither;
+            }
+            const { memberTypes: flattenedMemberTypes } = flattenedMemberObjectTypesEither.unsafeCoerce();
+            memberTypes = flattenedMemberTypes.concat();
+        }
+        return widenAstCompositeTypeToSingleType({
+            memberTypes,
+            shape,
+            shapeStack,
+        }).altLazy(() => 
+        // True composite type
+        Either.of({
+            kind: compositeTypeKind,
+            memberTypes,
+        }));
+    }
+    finally {
+        shapeStack.pop(shape);
+    }
+}
+function widenAstCompositeTypeToSingleType({ memberTypes, shape, shapeStack, }) {
+    const defaultValue = shapeStack.defaultValue;
+    const hasValues = shapeStack.constraints.hasValues;
+    if (hasValues.length > 0) {
+        return Left(new Error(`shape ${shape} hasValues, not attempting to widen composite type into a single type`));
+    }
+    if (shape instanceof input.PropertyShape && !shape.widen.orDefault(true)) {
+        return Left(new Error(`shape ${shape} has widening disabled`));
+    }
+    const canWiden = (memberType) => {
+        if (memberType.in_.length > 0) {
+            return false;
+        }
+        switch (memberType.kind) {
+            case "LiteralType": {
+                if (memberType.maxExclusive.isJust()) {
+                    return false;
+                }
+                if (memberType.maxInclusive.isJust()) {
+                    return false;
+                }
+                if (memberType.minExclusive.isJust()) {
+                    return false;
+                }
+                if (memberType.minInclusive.isJust()) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    };
+    if (memberTypes.every((memberType) => memberType.kind === "IdentifierType" && canWiden(memberType))) {
+        // Special case: all member types are identifiers without further constraints
+        return Either.of({
+            defaultValue: defaultValue.filter((term) => term.termType === "NamedNode"),
+            hasValues: [],
+            in_: [],
+            kind: "IdentifierType",
+            nodeKinds: new Set(memberTypes
+                .filter((memberType) => memberType.kind === "IdentifierType")
+                .flatMap((memberType) => [
+                ...memberType.nodeKinds,
+            ])),
+        });
+    }
+    if (memberTypes.every((memberType) => memberType.kind === "LiteralType" && canWiden(memberType))) {
+        // Special case: all the member types are Literals without further constraints,
+        // like dash:StringOrLangString
+        // Don't try to widen range constraints.
+        return Either.of({
+            datatype: Maybe.empty(),
+            defaultValue: defaultValue.filter((term) => term.termType === "Literal"),
+            hasValues: [],
+            in_: [],
+            kind: "LiteralType",
+            languageIn: [],
+            maxExclusive: Maybe.empty(),
+            maxInclusive: Maybe.empty(),
+            minExclusive: Maybe.empty(),
+            minInclusive: Maybe.empty(),
+            nodeKinds: new Set(["Literal"]),
+        });
+    }
+    if (memberTypes.every((memberType) => (memberType.kind === "IdentifierType" ||
+        memberType.kind === "LiteralType" ||
+        memberType.kind === "TermType") &&
+        canWiden(memberType))) {
+        // Special case: all member types are terms without further constraints
+        const nodeKinds = new Set(memberTypes.flatMap((memberType) => [
+            ...memberType.nodeKinds,
+        ]));
+        invariant(nodeKinds.has("Literal") &&
+            (nodeKinds.has("BlankNode") || nodeKinds.has("NamedNode"))); // The identifier-identifier and literal-literal cases should have been caught above
+        return Either.of({
+            defaultValue,
+            hasValues: [],
+            in_: [],
+            kind: "TermType",
+            nodeKinds,
+        });
+    }
+    return Left(new Error(`shape ${shape} member types could not be widened into a single type`));
+}
+//# sourceMappingURL=transformShapeToAstCompositeType.js.map

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstIdentifierType.d.ts

@@ -0,0 +1,10 @@
+import { Either } from "purify-ts";
+import type { ShapesGraphToAstTransformer } from "../ShapesGraphToAstTransformer.js";
+import type * as ast from "../ast/index.js";
+import type * as input from "../input/index.js";
+import type { ShapeStack } from "./ShapeStack.js";
+/**
+ * Try to convert a property shape to an AST IdentifierType using some heuristics.
+ */
+export declare function transformShapeToAstIdentifierType(this: ShapesGraphToAstTransformer, shape: input.Shape, shapeStack: ShapeStack): Either<Error, ast.IdentifierType>;
+//# sourceMappingURL=transformShapeToAstIdentifierType.d.ts.map

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstIdentifierType.js

@@ -0,0 +1,32 @@
+import { Either, Left } from "purify-ts";
+import { propertyShapeNodeKinds } from "./propertyShapeNodeKinds.js";
+/**
+ * Try to convert a property shape to an AST IdentifierType using some heuristics.
+ */
+export function transformShapeToAstIdentifierType(shape, shapeStack) {
+    shapeStack.push(shape);
+    try {
+        // defaultValue / hasValue / in only makes sense with IRIs
+        const identifierDefaultValue = shapeStack.defaultValue.filter((value) => value.termType === "NamedNode");
+        const identifierHasValues = shapeStack.constraints.hasValues.filter((term) => term.termType === "NamedNode");
+        const identifierIn = shapeStack.constraints.in_.filter((term) => term.termType === "NamedNode");
+        const nodeKinds = propertyShapeNodeKinds(shape);
+        if (identifierHasValues.length > 0 ||
+            identifierDefaultValue.isJust() ||
+            identifierIn.length > 0 ||
+            (nodeKinds.size > 0 && nodeKinds.size <= 2 && !nodeKinds.has("Literal"))) {
+            return Either.of({
+                defaultValue: identifierDefaultValue,
+                hasValues: identifierHasValues,
+                in_: identifierIn,
+                kind: "IdentifierType",
+                nodeKinds: nodeKinds,
+            });
+        }
+        return Left(new Error(`unable to transform ${shape} into an AST type`));
+    }
+    finally {
+        shapeStack.pop(shape);
+    }
+}
+//# sourceMappingURL=transformShapeToAstIdentifierType.js.map

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstLiteralType.d.ts

@@ -0,0 +1,10 @@
+import { Either } from "purify-ts";
+import type { ShapesGraphToAstTransformer } from "../ShapesGraphToAstTransformer.js";
+import type * as ast from "../ast/index.js";
+import type * as input from "../input/index.js";
+import type { ShapeStack } from "./ShapeStack.js";
+/**
+ * Try to convert a property shape to an AST LiteralType using some heuristics.
+ */
+export declare function transformShapeToAstLiteralType(this: ShapesGraphToAstTransformer, shape: input.Shape, shapeStack: ShapeStack): Either<Error, ast.LiteralType>;
+//# sourceMappingURL=transformShapeToAstLiteralType.d.ts.map

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstLiteralType.js

@@ -0,0 +1,46 @@
+import { Either, Left } from "purify-ts";
+import { propertyShapeNodeKinds } from "./propertyShapeNodeKinds.js";
+/**
+ * Try to convert a property shape to an AST LiteralType using some heuristics.
+ */
+export function transformShapeToAstLiteralType(shape, shapeStack) {
+    shapeStack.push(shape);
+    try {
+        const literalDefaultValue = shapeStack.defaultValue.filter((term) => term.termType === "Literal");
+        const literalHasValues = shapeStack.constraints.hasValues.filter((term) => term.termType === "Literal");
+        const literalIn = shapeStack.constraints.in_.filter((term) => term.termType === "Literal");
+        const nodeKinds = propertyShapeNodeKinds(shape);
+        if ([
+            // Treat any shape with the constraints in the list as a literal type
+            shape.constraints.datatype,
+            shape.constraints.maxExclusive,
+            shape.constraints.maxInclusive,
+            shape.constraints.minExclusive,
+            shape.constraints.minInclusive,
+        ].some((constraint) => constraint.isJust()) ||
+            shape.constraints.languageIn.length > 0 ||
+            literalDefaultValue.isJust() ||
+            literalHasValues.length > 0 ||
+            literalIn.length > 0 ||
+            // Treat any shape with a single sh:nodeKind of sh:Literal as a literal type
+            (nodeKinds.size === 1 && nodeKinds.has("Literal")))
+            return Either.of({
+                datatype: shape.constraints.datatype,
+                defaultValue: literalDefaultValue,
+                hasValues: literalHasValues,
+                in_: literalIn,
+                kind: "LiteralType",
+                languageIn: [...new Set(shape.constraints.languageIn)],
+                maxExclusive: shape.constraints.maxExclusive,
+                maxInclusive: shape.constraints.maxInclusive,
+                minExclusive: shape.constraints.minExclusive,
+                minInclusive: shape.constraints.minInclusive,
+                nodeKinds: new Set(["Literal"]),
+            });
+        return Left(new Error(`unable to transform ${shape} into an AST type`));
+    }
+    finally {
+        shapeStack.pop(shape);
+    }
+}
+//# sourceMappingURL=transformShapeToAstLiteralType.js.map

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstTermType.d.ts

@@ -0,0 +1,12 @@
+import { Either } from "purify-ts";
+import type { ShapesGraphToAstTransformer } from "../ShapesGraphToAstTransformer.js";
+import type * as ast from "../ast/index.js";
+import type * as input from "../input/index.js";
+import type { ShapeStack } from "./ShapeStack.js";
+/**
+ * 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, Omit<ast.TermType, "kind"> & {
+    readonly kind: "TermType";
+}>;
+//# sourceMappingURL=transformShapeToAstTermType.d.ts.map

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstTermType.js

@@ -0,0 +1,24 @@
+import { Either } from "purify-ts";
+import { propertyShapeNodeKinds } from "./propertyShapeNodeKinds.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"]),
+        });
+    }
+    finally {
+        shapeStack.pop(shape);
+    }
+}
+//# sourceMappingURL=transformShapeToAstTermType.js.map

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstType.d.ts

@@ -0,0 +1,13 @@
+import type { Either } from "purify-ts";
+import type { ShapesGraphToAstTransformer } from "../ShapesGraphToAstTransformer.js";
+import type * as ast from "../ast/index.js";
+import type * as input from "../input/index.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.
+ */
+export declare function transformShapeToAstType(this: ShapesGraphToAstTransformer, shape: input.Shape, shapeStack: ShapeStack): Either<Error, ast.Type>;
+//# sourceMappingURL=transformShapeToAstType.d.ts.map