@shaclmate/compiler 2.0.13 → 2.0.15

package/_ShapesGraphToAstTransformer/shapeAstName.d.ts

@@ -0,0 +1,5 @@
+import type { ShapesGraphToAstTransformer } from "../ShapesGraphToAstTransformer.js";
+import type * as ast from "../ast/index.js";
+import * as input from "../input/index.js";
+export declare function shapeAstName(this: ShapesGraphToAstTransformer, shape: input.Shape): ast.Name;
+//# sourceMappingURL=shapeAstName.d.ts.map

package/_ShapesGraphToAstTransformer/shapeAstName.js

@@ -0,0 +1,28 @@
+import { Maybe } from "purify-ts";
+import * as input from "../input/index.js";
+import { pickLiteral } from "./pickLiteral.js";
+export function shapeAstName(shape) {
+    let propertyPath = Maybe.empty();
+    let shName = Maybe.empty();
+    if (shape instanceof input.PropertyShape) {
+        if (shape.path.kind === "PredicatePath") {
+            const pathIri = shape.path.iri;
+            propertyPath = Maybe.of({
+                curie: Maybe.fromNullable(this.iriPrefixMap.shrink(pathIri)?.value),
+                identifier: pathIri,
+            });
+        }
+        shName = pickLiteral(shape.names).map((literal) => literal.value);
+    }
+    return {
+        curie: shape.identifier.termType === "NamedNode"
+            ? Maybe.fromNullable(this.iriPrefixMap.shrink(shape.identifier)?.value)
+            : Maybe.empty(),
+        identifier: shape.identifier,
+        label: pickLiteral(shape.labels).map((literal) => literal.value),
+        propertyPath,
+        shName: shName,
+        shaclmateName: shape.shaclmateName,
+    };
+}
+//# sourceMappingURL=shapeAstName.js.map

package/_ShapesGraphToAstTransformer/transformNodeShapeToAstType.d.ts

@@ -0,0 +1,6 @@
+import { Either } from "purify-ts";
+import type { ShapesGraphToAstTransformer } from "../ShapesGraphToAstTransformer.js";
+import * as input from "../input/index.js";
+import type { NodeShapeAstType } from "./NodeShapeAstType.js";
+export declare function transformNodeShapeToAstType(this: ShapesGraphToAstTransformer, nodeShape: input.NodeShape): Either<Error, NodeShapeAstType>;
+//# sourceMappingURL=transformNodeShapeToAstType.d.ts.map

package/_ShapesGraphToAstTransformer/transformNodeShapeToAstType.js

@@ -0,0 +1,178 @@
+import { rdf } from "@tpluscode/rdf-ns-builders";
+import { Either, Left } from "purify-ts";
+import { invariant } from "ts-invariant";
+import { TsFeature } from "../enums/index.js";
+import * as input from "../input/index.js";
+import { logger } from "../logger.js";
+import { pickLiteral } from "./pickLiteral.js";
+/**
+ * Is an ast.ObjectType actually the shape of an RDF list?
+ * If so, return the type of its rdf:first.
+ */
+function transformNodeShapeToListType(nodeShape) {
+    invariant(nodeShape.isList);
+    // Put a placeholder in the cache to deal with cyclic references
+    const listType = {
+        comment: pickLiteral(nodeShape.comments).map((literal) => literal.value),
+        identifierNodeKind: nodeShape.nodeKinds.has("BlankNode")
+            ? "BlankNode"
+            : "NamedNode",
+        itemType: {
+            kind: "PlaceholderType",
+        },
+        kind: "ListType",
+        label: pickLiteral(nodeShape.labels).map((literal) => literal.value),
+        mutable: nodeShape.mutable,
+        name: this.shapeAstName(nodeShape),
+        mintingStrategy: nodeShape.mintingStrategy,
+        toRdfTypes: nodeShape.toRdfTypes,
+    };
+    this.nodeShapeAstTypesByIdentifier.set(nodeShape.identifier, listType);
+    const properties = [];
+    for (const propertyShape of nodeShape.constraints.properties) {
+        const propertyEither = this.transformPropertyShapeToAstObjectTypeProperty(propertyShape);
+        if (propertyEither.isLeft()) {
+            logger.warn("error transforming %s %s: %s", nodeShape, propertyShape, propertyEither.extract().message);
+            continue;
+            // return property;
+        }
+        properties.push(propertyEither.unsafeCoerce());
+    }
+    if (properties.length !== 2) {
+        return Left(new Error(`${nodeShape} does not have exactly two properties`));
+    }
+    // rdf:first can have any type
+    // The type of the rdf:first property is the list item type.
+    const firstProperty = properties.find((property) => property.path.iri.equals(rdf.first));
+    if (!firstProperty) {
+        return Left(new Error(`${nodeShape} does not have an rdf:first property`));
+    }
+    const restProperty = properties.find((property) => property.path.iri.equals(rdf.rest));
+    if (!restProperty) {
+        return Left(new Error(`${nodeShape} does not have an rdf:rest property`));
+    }
+    if (restProperty.type.kind !== "UnionType") {
+        return Left(new Error(`${nodeShape} rdf:rest property is not sh:xone`));
+    }
+    if (restProperty.type.memberTypes.length !== 2) {
+        return Left(new Error(`${nodeShape} rdf:rest property sh:xone does not have exactly two member types`));
+    }
+    // rdf:rest should be sh:xone ( [ sh:class nodeShape ] [ sh:hasValue rdf:nil ] )
+    if (!restProperty.type.memberTypes.find((type) => type.kind === "ListType" &&
+        type.name.identifier.equals(nodeShape.identifier))) {
+        return Left(new Error(`${nodeShape} rdf:rest property sh:xone is not recursive into the node shape`));
+    }
+    if (!restProperty.type.memberTypes.find((type) => type.kind === "IdentifierType")) {
+        return Left(new Error(`${nodeShape} rdf:rest property sh:xone does not include sh:hasValue rdf:nil`));
+    }
+    listType.itemType = firstProperty.type;
+    return Either.of(listType);
+}
+export function transformNodeShapeToAstType(nodeShape) {
+    {
+        const type = this.nodeShapeAstTypesByIdentifier.get(nodeShape.identifier);
+        if (type) {
+            return Either.of(type);
+        }
+    }
+    if (nodeShape.isList) {
+        return transformNodeShapeToListType.bind(this)(nodeShape);
+    }
+    const export_ = nodeShape.export.orDefault(true);
+    if (nodeShape.constraints.and.length > 0 ||
+        nodeShape.constraints.xone.length > 0) {
+        let compositeTypeShapes;
+        let compositeTypeKind;
+        if (nodeShape.constraints.and.length > 0) {
+            compositeTypeShapes = nodeShape.constraints.and;
+            compositeTypeKind = "ObjectIntersectionType";
+        }
+        else {
+            compositeTypeShapes = nodeShape.constraints.xone;
+            compositeTypeKind = "ObjectUnionType";
+        }
+        const compositeTypeNodeShapes = compositeTypeShapes.filter((shape) => shape instanceof input.NodeShape);
+        if (compositeTypeNodeShapes.length === 0) {
+            return Left(new Error(`${nodeShape} has no node shapes in its logical constraint`));
+        }
+        // Put a placeholder in the cache to deal with cyclic references
+        const compositeType = {
+            comment: pickLiteral(nodeShape.comments).map((literal) => literal.value),
+            export: export_,
+            kind: compositeTypeKind,
+            label: pickLiteral(nodeShape.labels).map((literal) => literal.value),
+            memberTypes: [],
+            name: this.shapeAstName(nodeShape),
+            tsFeatures: nodeShape.tsFeatures.orDefault(new Set(TsFeature.MEMBERS)),
+        };
+        this.nodeShapeAstTypesByIdentifier.set(nodeShape.identifier, compositeType);
+        for (const memberNodeShape of compositeTypeNodeShapes) {
+            const memberAstTypeEither = this.transformNodeShapeToAstType(memberNodeShape);
+            if (memberAstTypeEither.isLeft()) {
+                return memberAstTypeEither;
+            }
+            const memberAstType = memberAstTypeEither.unsafeCoerce();
+            switch (memberAstType.kind) {
+                case "ObjectType":
+                    compositeType.memberTypes.push(memberAstType);
+                    break;
+                case "ObjectUnionType":
+                    compositeType.memberTypes.push(...memberAstType.memberTypes);
+                    break;
+                default:
+                    return Left(new Error(`${nodeShape} has one or more non-ObjectType node shapes in its logical constraint`));
+            }
+        }
+        return Either.of(compositeType);
+    }
+    // Put a placeholder in the cache to deal with cyclic references
+    // If this node shape's properties (directly or indirectly) refer to the node shape itself,
+    // we'll return this placeholder.
+    const objectType = {
+        abstract: nodeShape.abstract.orDefault(false),
+        ancestorObjectTypes: [],
+        childObjectTypes: [],
+        comment: pickLiteral(nodeShape.comments).map((literal) => literal.value),
+        descendantObjectTypes: [],
+        export: export_,
+        extern: nodeShape.extern.orDefault(false),
+        fromRdfType: nodeShape.fromRdfType,
+        label: pickLiteral(nodeShape.labels).map((literal) => literal.value),
+        kind: "ObjectType",
+        mintingStrategy: nodeShape.mintingStrategy,
+        name: this.shapeAstName(nodeShape),
+        nodeKinds: nodeShape.nodeKinds,
+        properties: [], // This is mutable, we'll populate it below.
+        parentObjectTypes: [], // This is mutable, we'll populate it below
+        toRdfTypes: nodeShape.toRdfTypes,
+        tsFeatures: nodeShape.tsFeatures.orDefault(new Set(TsFeature.MEMBERS)),
+        tsIdentifierPropertyName: nodeShape.tsObjectIdentifierPropertyName.orDefault("identifier"),
+        tsImports: nodeShape.tsImports,
+        tsObjectDeclarationType: nodeShape.tsObjectDeclarationType.orDefault("class"),
+        tsTypeDiscriminatorPropertyName: nodeShape.tsObjectTypeDiscriminatorPropertyName.orDefault("type"),
+    };
+    this.nodeShapeAstTypesByIdentifier.set(nodeShape.identifier, objectType);
+    // Populate ancestor and descendant object types
+    const relatedObjectTypes = (relatedNodeShapes) => {
+        return relatedNodeShapes.flatMap((relatedNodeShape) => this.transformNodeShapeToAstType(relatedNodeShape)
+            .toMaybe()
+            .filter((astType) => astType.kind === "ObjectType")
+            .toList());
+    };
+    objectType.ancestorObjectTypes.push(...relatedObjectTypes(nodeShape.ancestorNodeShapes));
+    objectType.childObjectTypes.push(...relatedObjectTypes(nodeShape.childNodeShapes));
+    objectType.descendantObjectTypes.push(...relatedObjectTypes(nodeShape.descendantNodeShapes));
+    objectType.parentObjectTypes.push(...relatedObjectTypes(nodeShape.parentNodeShapes));
+    // Populate properties
+    for (const propertyShape of nodeShape.constraints.properties) {
+        const propertyEither = this.transformPropertyShapeToAstObjectTypeProperty(propertyShape);
+        if (propertyEither.isLeft()) {
+            logger.warn("error transforming %s %s: %s", nodeShape, propertyShape, propertyEither.extract().message);
+            continue;
+            // return property;
+        }
+        objectType.properties.push(propertyEither.unsafeCoerce());
+    }
+    return Either.of(objectType);
+}
+//# sourceMappingURL=transformNodeShapeToAstType.js.map

package/_ShapesGraphToAstTransformer/transformPropertyShapeToAstCompositeType.d.ts

@@ -0,0 +1,13 @@
+import type { BlankNode, Literal, NamedNode } from "@rdfjs/types";
+import { Either, Maybe } from "purify-ts";
+import type { ShapesGraphToAstTransformer } from "../ShapesGraphToAstTransformer.js";
+import type * as ast from "../ast/index.js";
+import * as input from "../input/index.js";
+/**
+ * Try to convert a property shape to a composite type (intersection or union) using some heuristics.
+ */
+export declare function transformPropertyShapeToAstCompositeType(this: ShapesGraphToAstTransformer, shape: input.Shape, inherited: {
+    defaultValue: Maybe<BlankNode | Literal | NamedNode>;
+    extern: Maybe<boolean>;
+} | null): Either<Error, ast.Type>;
+//# sourceMappingURL=transformPropertyShapeToAstCompositeType.d.ts.map

package/_ShapesGraphToAstTransformer/transformPropertyShapeToAstCompositeType.js

@@ -0,0 +1,200 @@
+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";
+/**
+ * Try to convert a property shape to a composite type (intersection or union) using some heuristics.
+ */
+export function transformPropertyShapeToAstCompositeType(shape, inherited) {
+    const defaultValue = (shape instanceof input.PropertyShape ? shape.defaultValue : Maybe.empty()).alt(inherited !== null ? inherited.defaultValue : Maybe.empty());
+    const hasValues = shape.constraints.hasValues;
+    const extern = shape.extern.alt(inherited !== null ? inherited.extern : Maybe.empty());
+    let memberTypeEithers;
+    let compositeTypeKind;
+    const transformNodeShapeToAstCompositeMemberType = (nodeShape) => {
+        const astTypeEither = this.transformNodeShapeToAstType(nodeShape);
+        if (astTypeEither.isLeft()) {
+            return astTypeEither;
+        }
+        const astType = astTypeEither.unsafeCoerce();
+        if (extern.orDefault(false)) {
+            // Use the identifier type instead
+            let nodeKinds;
+            switch (astType.kind) {
+                case "ListType":
+                    nodeKinds = new Set();
+                    nodeKinds.add(astType.identifierNodeKind);
+                    break;
+                case "ObjectType":
+                    nodeKinds = astType.nodeKinds;
+                    break;
+                case "ObjectIntersectionType":
+                case "ObjectUnionType":
+                    nodeKinds = new Set();
+                    for (const memberType of astType.memberTypes) {
+                        for (const nodeKind of memberType.nodeKinds) {
+                            nodeKinds.add(nodeKind);
+                        }
+                    }
+            }
+            return Either.of({
+                defaultValue: defaultValue.filter((term) => term.termType === "NamedNode"),
+                hasValues: [],
+                in_: [],
+                kind: "IdentifierType",
+                nodeKinds,
+            });
+        }
+        // Not extern, use the type
+        return Either.of(astType);
+    };
+    if (shape.constraints.and.length > 0) {
+        memberTypeEithers = shape.constraints.and.map((memberShape) => this.transformPropertyShapeToAstType(memberShape, {
+            defaultValue,
+            extern: extern,
+        }));
+        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 transformNodeShapeToAstCompositeMemberType(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) => transformNodeShapeToAstCompositeMemberType(nodeShape));
+        compositeTypeKind = "IntersectionType";
+    }
+    else if (shape.constraints.xone.length > 0) {
+        memberTypeEithers = shape.constraints.xone.map((memberShape) => this.transformPropertyShapeToAstType(memberShape, {
+            defaultValue,
+            extern: extern,
+        }));
+        compositeTypeKind = "UnionType";
+    }
+    else {
+        return Left(new Error(`unable to transform ${shape} into an AST type`));
+    }
+    invariant(memberTypeEithers.length > 0);
+    const memberTypes = Either.rights(memberTypeEithers);
+    if (memberTypes.length !== memberTypeEithers.length) {
+        logger.warn("shape %s composition did not map all member types successfully: %s", shape, Either.lefts(memberTypeEithers)
+            .map((left) => left.message)
+            .join("; "));
+        return memberTypeEithers[0];
+    }
+    invariant(memberTypes.length > 0);
+    if (memberTypes.length === 1) {
+        return Either.of(memberTypes[0]);
+    }
+    // Get the type underlying a set or option
+    const memberItemTypes = memberTypes.map((memberType) => {
+        switch (memberType.kind) {
+            case "SetType":
+                return memberType.itemType;
+            case "OptionType":
+                return memberType.itemType;
+            default:
+                return memberType;
+        }
+    });
+    if (hasValues.length === 0) {
+        // Can't handle hasValues when coalescing types
+        const canCoalesce = (memberItemType) => {
+            if (memberItemType.in_.length > 0) {
+                return false;
+            }
+            switch (memberItemType.kind) {
+                case "LiteralType": {
+                    if (memberItemType.maxExclusive.isJust()) {
+                        return false;
+                    }
+                    if (memberItemType.maxInclusive.isJust()) {
+                        return false;
+                    }
+                    if (memberItemType.minExclusive.isJust()) {
+                        return false;
+                    }
+                    if (memberItemType.minInclusive.isJust()) {
+                        return false;
+                    }
+                }
+            }
+            return true;
+        };
+        if (memberItemTypes.every((memberItemType) => memberItemType.kind === "IdentifierType" &&
+            canCoalesce(memberItemType))) {
+            // 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(memberItemTypes
+                    .filter((memberItemType) => memberItemType.kind === "IdentifierType")
+                    .flatMap((memberItemType) => [
+                    ...memberItemType.nodeKinds,
+                ])),
+            });
+        }
+        if (memberItemTypes.every((memberItemType) => memberItemType.kind === "LiteralType" && canCoalesce(memberItemType))) {
+            // Special case: all the member types are Literals without further constraints,
+            // like dash:StringOrLangString
+            // Don't try to coalesce 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 (memberItemTypes.every((memberItemType) => (memberItemType.kind === "IdentifierType" ||
+            memberItemType.kind === "LiteralType" ||
+            memberItemType.kind === "TermType") &&
+            canCoalesce(memberItemType))) {
+            // Special case: all member types are terms without further constraints
+            const nodeKinds = new Set(memberItemTypes.flatMap((memberItemType) => [
+                ...memberItemType
+                    .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 Either.of({
+        kind: compositeTypeKind,
+        memberTypes: memberTypes,
+    });
+}
+//# sourceMappingURL=transformPropertyShapeToAstCompositeType.js.map

package/_ShapesGraphToAstTransformer/transformPropertyShapeToAstIdentifierType.d.ts

@@ -0,0 +1,12 @@
+import type { BlankNode, Literal, NamedNode } from "@rdfjs/types";
+import { Either, Maybe } from "purify-ts";
+import type { ShapesGraphToAstTransformer } from "../ShapesGraphToAstTransformer.js";
+import type * as ast from "../ast/index.js";
+import * as input from "../input/index.js";
+/**
+ * Try to convert a property shape to an AST IdentifierType using some heuristics.
+ */
+export declare function transformPropertyShapeToAstIdentifierType(this: ShapesGraphToAstTransformer, shape: input.Shape, inherited: {
+    defaultValue: Maybe<BlankNode | Literal | NamedNode>;
+} | null): Either<Error, ast.IdentifierType>;
+//# sourceMappingURL=transformPropertyShapeToAstIdentifierType.d.ts.map

package/_ShapesGraphToAstTransformer/transformPropertyShapeToAstIdentifierType.js

@@ -0,0 +1,29 @@
+import { Either, Left, Maybe } from "purify-ts";
+import * as input from "../input/index.js";
+import { propertyShapeNodeKinds } from "./propertyShapeNodeKinds.js";
+/**
+ * Try to convert a property shape to an AST IdentifierType using some heuristics.
+ */
+export function transformPropertyShapeToAstIdentifierType(shape, inherited) {
+    // defaultValue / hasValue / in only makes sense with IRIs
+    const identifierDefaultValue = (shape instanceof input.PropertyShape ? shape.defaultValue : Maybe.empty())
+        .alt(inherited !== null ? inherited.defaultValue : Maybe.empty())
+        .filter((value) => value.termType === "NamedNode");
+    const identifierHasValues = shape.constraints.hasValues.filter((term) => term.termType === "NamedNode");
+    const identifierIn = shape.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`));
+}
+//# sourceMappingURL=transformPropertyShapeToAstIdentifierType.js.map

package/_ShapesGraphToAstTransformer/transformPropertyShapeToAstLiteralType.d.ts

@@ -0,0 +1,12 @@
+import type { BlankNode, Literal, NamedNode } from "@rdfjs/types";
+import { Either, Maybe } from "purify-ts";
+import type { ShapesGraphToAstTransformer } from "../ShapesGraphToAstTransformer.js";
+import type * as ast from "../ast/index.js";
+import * as input from "../input/index.js";
+/**
+ * Try to convert a property shape to an AST LiteralType using some heuristics.
+ */
+export declare function transformPropertyShapeToAstLiteralType(this: ShapesGraphToAstTransformer, shape: input.Shape, inherited: {
+    defaultValue: Maybe<BlankNode | Literal | NamedNode>;
+} | null): Either<Error, ast.LiteralType>;
+//# sourceMappingURL=transformPropertyShapeToAstLiteralType.d.ts.map

package/_ShapesGraphToAstTransformer/transformPropertyShapeToAstLiteralType.js

@@ -0,0 +1,43 @@
+import { Either, Left, Maybe } from "purify-ts";
+import * as input from "../input/index.js";
+import { propertyShapeNodeKinds } from "./propertyShapeNodeKinds.js";
+/**
+ * Try to convert a property shape to an AST LiteralType using some heuristics.
+ */
+export function transformPropertyShapeToAstLiteralType(shape, inherited) {
+    const literalDefaultValue = (shape instanceof input.PropertyShape ? shape.defaultValue : Maybe.empty())
+        .alt(inherited !== null ? inherited.defaultValue : Maybe.empty())
+        .filter((term) => term.termType === "Literal");
+    const literalHasValues = shape.constraints.hasValues.filter((term) => term.termType === "Literal");
+    const literalIn = shape.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: 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`));
+}
+//# sourceMappingURL=transformPropertyShapeToAstLiteralType.js.map

package/_ShapesGraphToAstTransformer/transformPropertyShapeToAstObjectTypeProperty.d.ts

@@ -0,0 +1,6 @@
+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";
+export declare function transformPropertyShapeToAstObjectTypeProperty(this: ShapesGraphToAstTransformer, propertyShape: input.PropertyShape): Either<Error, ast.ObjectType.Property>;
+//# sourceMappingURL=transformPropertyShapeToAstObjectTypeProperty.d.ts.map

package/_ShapesGraphToAstTransformer/transformPropertyShapeToAstObjectTypeProperty.js

@@ -0,0 +1,31 @@
+import { Either, Left } from "purify-ts";
+import { pickLiteral } from "./pickLiteral.js";
+export function transformPropertyShapeToAstObjectTypeProperty(propertyShape) {
+    {
+        const property = this.astObjectTypePropertiesByIdentifier.get(propertyShape.identifier);
+        if (property) {
+            return Either.of(property);
+        }
+    }
+    const type = this.transformPropertyShapeToAstType(propertyShape, null);
+    if (type.isLeft()) {
+        return type;
+    }
+    const path = propertyShape.path;
+    if (path.kind !== "PredicatePath") {
+        return Left(new Error(`${propertyShape} has non-predicate path, unsupported`));
+    }
+    const property = {
+        comment: pickLiteral(propertyShape.comments).map((literal) => literal.value),
+        description: pickLiteral(propertyShape.descriptions).map((literal) => literal.value),
+        label: pickLiteral(propertyShape.labels).map((literal) => literal.value),
+        mutable: propertyShape.mutable,
+        name: this.shapeAstName(propertyShape),
+        path,
+        type: type.extract(),
+        visibility: propertyShape.visibility,
+    };
+    this.astObjectTypePropertiesByIdentifier.set(propertyShape.identifier, property);
+    return Either.of(property);
+}
+//# sourceMappingURL=transformPropertyShapeToAstObjectTypeProperty.js.map

package/_ShapesGraphToAstTransformer/transformPropertyShapeToAstTermType.d.ts

@@ -0,0 +1,14 @@
+import type { BlankNode, Literal, NamedNode } from "@rdfjs/types";
+import { Either, Maybe } from "purify-ts";
+import type { ShapesGraphToAstTransformer } from "../ShapesGraphToAstTransformer.js";
+import type * as ast from "../ast/index.js";
+import * as input from "../input/index.js";
+/**
+ * Try to convert a property shape to an AST TermType using some heuristics.
+ */
+export declare function transformPropertyShapeToAstTermType(this: ShapesGraphToAstTransformer, shape: input.Shape, inherited: {
+    defaultValue: Maybe<BlankNode | Literal | NamedNode>;
+} | null): Either<Error, Omit<ast.TermType<BlankNode | Literal | NamedNode>, "kind"> & {
+    readonly kind: "TermType";
+}>;
+//# sourceMappingURL=transformPropertyShapeToAstTermType.d.ts.map

package/_ShapesGraphToAstTransformer/transformPropertyShapeToAstTermType.js

@@ -0,0 +1,21 @@
+import { Either, Maybe } from "purify-ts";
+import * as input from "../input/index.js";
+import { propertyShapeNodeKinds } from "./propertyShapeNodeKinds.js";
+/**
+ * Try to convert a property shape to an AST TermType using some heuristics.
+ */
+export function transformPropertyShapeToAstTermType(shape, inherited) {
+    const nodeKinds = propertyShapeNodeKinds(shape);
+    return Either.of({
+        defaultValue: (shape instanceof input.PropertyShape
+            ? shape.defaultValue
+            : Maybe.empty()).alt(inherited !== null ? inherited.defaultValue : Maybe.empty()),
+        hasValues: shape.constraints.hasValues,
+        in_: shape.constraints.in_,
+        kind: "TermType",
+        nodeKinds: nodeKinds.size > 0
+            ? nodeKinds
+            : new Set(["BlankNode", "NamedNode", "Literal"]),
+    });
+}
+//# sourceMappingURL=transformPropertyShapeToAstTermType.js.map

package/_ShapesGraphToAstTransformer/transformPropertyShapeToAstType.d.ts

@@ -0,0 +1,16 @@
+import type { BlankNode, Literal, NamedNode } from "@rdfjs/types";
+import type { Either, Maybe } from "purify-ts";
+import type { ShapesGraphToAstTransformer } from "../ShapesGraphToAstTransformer.js";
+import type * as ast from "../ast/index.js";
+import * as input from "../input/index.js";
+/**
+ * Try to convert a property 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 transformPropertyShapeToAstType(this: ShapesGraphToAstTransformer, shape: input.Shape, inherited: {
+    defaultValue: Maybe<BlankNode | Literal | NamedNode>;
+    extern: Maybe<boolean>;
+} | null): Either<Error, ast.Type>;
+//# sourceMappingURL=transformPropertyShapeToAstType.d.ts.map