@shaclmate/compiler 2.0.22 → 2.0.24

package/dist/_ShapesGraphToAstTransformer/transformPropertyShapeToAstObjectTypeProperty.js

@@ -1,5 +1,109 @@
-import { Either, Left } from "purify-ts";
+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) {
+        case "ObjectType":
+            return type.identifierNodeKinds;
+        case "ObjectUnionType":
+            return new Set(type.memberTypes.flatMap((memberType) => [
+                ...memberType.identifierNodeKinds,
+            ]));
+    }
+}
+function synthesizeStubAstObjectType({ identifierNodeKinds, tsFeatures, }) {
+    let syntheticName;
+    switch (identifierNodeKinds.size) {
+        case 1:
+            invariant(identifierNodeKinds.has("NamedNode"));
+            syntheticName = "NamedDefaultStub";
+            break;
+        case 2:
+            syntheticName = "DefaultStub";
+            break;
+        default:
+            throw new Error("should never happen");
+    }
+    return {
+        abstract: false,
+        ancestorObjectTypes: [],
+        childObjectTypes: [],
+        comment: Maybe.empty(),
+        descendantObjectTypes: [],
+        export: true,
+        extern: false,
+        fromRdfType: Maybe.empty(),
+        identifierIn: [],
+        identifierNodeKinds,
+        identifierMintingStrategy: Maybe.empty(),
+        kind: "ObjectType",
+        label: Maybe.empty(),
+        name: {
+            identifier: N3.DataFactory.blankNode(),
+            label: Maybe.empty(),
+            propertyPath: Maybe.empty(),
+            shName: Maybe.empty(),
+            shaclmateName: Maybe.empty(),
+            syntheticName: Maybe.of(syntheticName),
+        },
+        parentObjectTypes: [],
+        properties: [],
+        synthetic: true,
+        toRdfTypes: [],
+        tsFeatures,
+        tsImports: [],
+        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);
@@ -7,9 +111,74 @@ export function transformPropertyShapeToAstObjectTypeProperty(propertyShape) {
             return Either.of(property);
         }
     }
-    const type = this.transformPropertyShapeToAstType(propertyShape, null);
-    if (type.isLeft()) {
-        return type;
+    const typeEither = transformPropertyShapeToAstType.bind(this)(propertyShape);
+    if (typeEither.isLeft()) {
+        return typeEither;
+    }
+    const type = typeEither.unsafeCoerce();
+    let stubType = Maybe.empty();
+    let propertyShapeStubItemType;
+    if (propertyShape.stub.isJust()) {
+        const propertyShapeStubTypeEither = this.transformNodeShapeToAstType(propertyShape.stub.unsafeCoerce()).chain((propertyShapeStubType) => {
+            switch (propertyShapeStubType.kind) {
+                case "ListType":
+                case "ObjectIntersectionType":
+                    return Left(new Error(`${propertyShape} stub cannot refer to a ${propertyShapeStubType.kind}`));
+                case "ObjectType":
+                case "ObjectUnionType":
+                    return Either.of(propertyShapeStubType);
+            }
+        });
+        if (propertyShapeStubTypeEither.isLeft()) {
+            return propertyShapeStubTypeEither;
+        }
+        propertyShapeStubItemType = propertyShapeStubTypeEither.unsafeCoerce();
+    }
+    if (propertyShapeStubItemType || propertyShape.lazy.orDefault(false)) {
+        switch (type.kind) {
+            case "ObjectType":
+            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":
+                        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:
+                return Left(new Error(`${propertyShape} marked lazy but has ${type.kind}`));
+        }
     }
     const path = propertyShape.path;
     if (path.kind !== "PredicatePath") {
@@ -23,7 +192,8 @@ export function transformPropertyShapeToAstObjectTypeProperty(propertyShape) {
         name: this.shapeAstName(propertyShape),
         order: propertyShape.order.orDefault(0),
         path,
-        type: type.extract(),
+        stubType,
+        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: 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

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstType.js

@@ -0,0 +1,14 @@
+/**
+ * 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 function transformShapeToAstType(shape, shapeStack) {
+    // Try to transform the property shape into an AST type without cardinality constraints
+    return this.transformShapeToAstCompositeType(shape, shapeStack)
+        .altLazy(() => this.transformShapeToAstIdentifierType(shape, shapeStack))
+        .altLazy(() => this.transformShapeToAstLiteralType(shape, shapeStack))
+        .altLazy(() => this.transformShapeToAstTermType(shape, shapeStack));
+}
+//# sourceMappingURL=transformShapeToAstType.js.map

package/dist/ast/Ast.d.ts

@@ -5,6 +5,5 @@ export interface Ast {
     readonly objectIntersectionTypes: readonly ObjectIntersectionType[];
     readonly objectTypes: readonly ObjectType[];
     readonly objectUnionTypes: readonly ObjectUnionType[];
-    readonly tsDataFactoryVariable: string;
 }
 //# sourceMappingURL=Ast.d.ts.map

package/dist/ast/Curie.d.ts

@@ -0,0 +1,14 @@
+/**
+ * A Compact URI (https://www.w3.org/TR/curie)
+ */
+export declare class Curie {
+    readonly prefix: string;
+    readonly reference: string;
+    constructor({ prefix, reference, }: {
+        prefix: string;
+        reference: string;
+    });
+    static parse(curie: string): Curie;
+    toString(): string;
+}
+//# sourceMappingURL=Curie.d.ts.map

package/dist/ast/Curie.js

@@ -0,0 +1,21 @@
+import { invariant } from "ts-invariant";
+/**
+ * A Compact URI (https://www.w3.org/TR/curie)
+ */
+export class Curie {
+    prefix;
+    reference;
+    constructor({ prefix, reference, }) {
+        this.prefix = prefix;
+        this.reference = reference;
+    }
+    static parse(curie) {
+        const split = curie.split(":", 2);
+        invariant(split.length === 2);
+        return new Curie({ prefix: split[0], reference: split[1] });
+    }
+    toString() {
+        return `${this.prefix}:${this.reference}`;
+    }
+}
+//# sourceMappingURL=Curie.js.map

package/dist/ast/IdentifierType.d.ts

@@ -1,10 +1,11 @@
 import type { BlankNode, NamedNode } from "@rdfjs/types";
+import type { IdentifierNodeKind } from "@shaclmate/shacl-ast";
 import type { TermType } from "./TermType.js";
 /**
  * A type corresponding to sh:nodeKind of a blank node or IRI, and not corresponding to a node shape.
  */
-export interface IdentifierType extends TermType<BlankNode | NamedNode> {
+export interface IdentifierType extends TermType<NamedNode, BlankNode | NamedNode> {
     readonly kind: "IdentifierType";
-    readonly nodeKinds: Set<"BlankNode" | "NamedNode">;
+    readonly nodeKinds: Set<IdentifierNodeKind>;
 }
 //# sourceMappingURL=IdentifierType.d.ts.map

package/dist/ast/ListType.d.ts

@@ -1,4 +1,5 @@
 import type { NamedNode } from "@rdfjs/types";
+import type { IdentifierNodeKind } from "@shaclmate/shacl-ast";
 import type { Maybe } from "purify-ts";
 import type { IdentifierMintingStrategy } from "../enums/IdentifierMintingStrategy.js";
 import type { Name } from "./Name.js";
@@ -18,7 +19,7 @@ export interface ListType {
     /**
      * Type of identifier (blank or named node) to use for lists and sub-lists.
      */
-    readonly identifierNodeKind: "BlankNode" | "NamedNode";
+    readonly identifierNodeKind: IdentifierNodeKind;
     /**
      * List item type.
      *

package/dist/ast/LiteralType.d.ts

@@ -1,7 +1,7 @@
 import type { Literal, NamedNode } from "@rdfjs/types";
 import type { Maybe } from "purify-ts";
 import type { TermType } from "./TermType.js";
-export interface LiteralType extends TermType<Literal> {
+export interface LiteralType extends TermType<Literal, Literal> {
     readonly datatype: Maybe<NamedNode>;
     readonly kind: "LiteralType";
     readonly languageIn: readonly string[];