@shaclmate/compiler 2.0.12

package/ShapesGraphToAstTransformer.d.ts

@@ -0,0 +1,32 @@
+import type PrefixMap from "@rdfjs/prefix-map/PrefixMap.js";
+import { Either } from "purify-ts";
+import * as shaclAst from "shacl-ast";
+import type * as ast from "./ast";
+export declare class ShapesGraphToAstTransformer {
+    private readonly astObjectTypePropertiesByIdentifier;
+    private readonly iriPrefixMap;
+    private readonly nodeShapeAstTypesByIdentifier;
+    private readonly shapesGraph;
+    constructor({ iriPrefixMap, shapesGraph, }: {
+        iriPrefixMap: PrefixMap;
+        shapesGraph: shaclAst.ShapesGraph;
+    });
+    transform(): Either<Error, ast.Ast>;
+    /**
+     * Is an ast.ObjectType actually the shape of an RDF list?
+     * If so, return the type of its rdf:first.
+     */
+    private astObjectTypeListItemType;
+    private nodeShapeAstType;
+    private propertyShapeAstObjectTypeProperty;
+    /**
+     * 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.
+     */
+    private propertyShapeAstType;
+    private resolveClassAstObjectType;
+    private shapeName;
+}
+//# sourceMappingURL=ShapesGraphToAstTransformer.d.ts.map

package/ShapesGraphToAstTransformer.js

@@ -0,0 +1,461 @@
+import TermMap from "@rdfjs/term-map";
+import TermSet from "@rdfjs/term-set";
+import { dash, owl, rdf, rdfs } from "@tpluscode/rdf-ns-builders";
+import { Either, Left, Maybe } from "purify-ts";
+import * as shaclAst from "shacl-ast";
+import { invariant } from "ts-invariant";
+import { MintingStrategy } from "./ast/MintingStrategy";
+import { logger } from "./logger.js";
+import { shaclmate } from "./vocabularies/";
+function ancestorClassIris(classResource, maxDepth) {
+    const ancestorClassIris = new TermSet();
+    function ancestorClassIrisRecursive(classResource, depth) {
+        for (const parentClassValue of classResource.values(rdfs.subClassOf)) {
+            parentClassValue.toNamedResource().ifRight((parentClassResource) => {
+                if (ancestorClassIris.has(parentClassResource.identifier)) {
+                    return;
+                }
+                ancestorClassIris.add(parentClassResource.identifier);
+                if (depth < maxDepth) {
+                    ancestorClassIrisRecursive(parentClassResource, depth + 1);
+                }
+            });
+        }
+    }
+    ancestorClassIrisRecursive(classResource, 1);
+    return [...ancestorClassIris];
+}
+function descendantClassIris(classResource, maxDepth) {
+    const descendantClassIris = new TermSet();
+    function descendantClassIrisRecursive(classResource, depth) {
+        for (const childClassValue of classResource.valuesOf(rdfs.subClassOf)) {
+            childClassValue.toNamedResource().ifRight((childClassResource) => {
+                if (descendantClassIris.has(childClassResource.identifier)) {
+                    return;
+                }
+                descendantClassIris.add(childClassResource.identifier);
+                if (depth < maxDepth) {
+                    descendantClassIrisRecursive(childClassResource, depth + 1);
+                }
+            });
+        }
+    }
+    descendantClassIrisRecursive(classResource, 1);
+    return [...descendantClassIris];
+}
+function shaclmateInline(shape) {
+    return shape.resource
+        .value(shaclmate.inline)
+        .chain((value) => value.toBoolean())
+        .toMaybe();
+}
+function shaclmateName(shape) {
+    return shape.resource
+        .value(shaclmate.name)
+        .chain((value) => value.toString())
+        .toMaybe();
+}
+export class ShapesGraphToAstTransformer {
+    constructor({ iriPrefixMap, shapesGraph, }) {
+        this.astObjectTypePropertiesByIdentifier = new TermMap();
+        this.nodeShapeAstTypesByIdentifier = new TermMap();
+        this.iriPrefixMap = iriPrefixMap;
+        this.shapesGraph = shapesGraph;
+    }
+    transform() {
+        return Either.sequence(this.shapesGraph.nodeShapes
+            .filter((nodeShape) => nodeShape.resource.identifier.termType === "NamedNode" &&
+            !nodeShape.resource.identifier.value.startsWith(dash[""].value))
+            .map((nodeShape) => this.nodeShapeAstType(nodeShape))).map((nodeShapeTypes) => ({
+            objectTypes: nodeShapeTypes.filter((nodeShapeType) => nodeShapeType.kind === "ObjectType"),
+        }));
+    }
+    /**
+     * Is an ast.ObjectType actually the shape of an RDF list?
+     * If so, return the type of its rdf:first.
+     */
+    astObjectTypeListItemType(astObjectType, nodeShape) {
+        if (!nodeShape.resource.isSubClassOf(rdf.List)) {
+            return Left(new Error(`${nodeShape} is not an rdfs:subClassOf rdf:List`));
+        }
+        if (astObjectType.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 = astObjectType.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 = astObjectType.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:or`));
+        }
+        if (restProperty.type.memberTypes.length !== 2) {
+            return Left(new Error(`${nodeShape} rdf:rest property sh:or does not have exactly two member types`));
+        }
+        // rdf:rest should be sh:or ( [ sh:class nodeShape ] [ sh:hasValue rdf:nil ] )
+        if (!restProperty.type.memberTypes.find((type) => type.kind === "ObjectType" &&
+            type.name.identifier.equals(nodeShape.resource.identifier))) {
+            return Left(new Error(`${nodeShape} rdf:rest property sh:or 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:or does not include sh:hasValue rdf:nil`));
+        }
+        return Either.of(firstProperty.type);
+    }
+    nodeShapeAstType(nodeShape) {
+        {
+            const type = this.nodeShapeAstTypesByIdentifier.get(nodeShape.resource.identifier);
+            if (type) {
+                return Either.of(type);
+            }
+        }
+        // https://www.w3.org/TR/shacl/#implicit-targetClass
+        // If the node shape is an owl:class or rdfs:Class, make the ObjectType have an rdf:type of the NodeShape.
+        const rdfType = nodeShape.resource.isInstanceOf(owl.Class) ||
+            nodeShape.resource.isInstanceOf(rdfs.Class)
+            ? Maybe.of(nodeShape.resource.identifier)
+            : Maybe.empty();
+        const nodeKinds = new Set([...nodeShape.constraints.nodeKinds].filter((nodeKind) => nodeKind !== shaclAst.NodeKind.LITERAL));
+        if (nodeKinds.size === 0) {
+            return Left(new Error(`${nodeShape} has no non-Literal node kinds`));
+        }
+        // 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.resource
+                .value(shaclmate.abstract)
+                .chain((value) => value.toBoolean())
+                .orDefault(false),
+            ancestorObjectTypes: [],
+            childObjectTypes: [],
+            descendantObjectTypes: [],
+            export: nodeShape.resource
+                .value(shaclmate.export)
+                .chain((value) => value.toBoolean())
+                .orDefault(true),
+            kind: "ObjectType",
+            listItemType: Maybe.empty(),
+            mintingStrategy: nodeShape.resource
+                .value(shaclmate.mintingStrategy)
+                .chain((value) => value.toIri())
+                .chain((iri) => {
+                if (iri.equals(shaclmate.SHA256)) {
+                    return Either.of(MintingStrategy.SHA256);
+                }
+                if (iri.equals(shaclmate.UUIDv4)) {
+                    return Either.of(MintingStrategy.UUIDv4);
+                }
+                return Left(new Error(`unrecognizing minting strategy: ${iri.value}`));
+            })
+                .toMaybe(),
+            name: this.shapeName(nodeShape),
+            nodeKinds,
+            properties: [], // This is mutable, we'll populate it below.
+            rdfType,
+            parentObjectTypes: [], // This is mutable, we'll populate it below
+        };
+        this.nodeShapeAstTypesByIdentifier.set(nodeShape.resource.identifier, objectType);
+        // Populate ancestor and descendant object types
+        // Ancestors
+        for (const classIri of ancestorClassIris(nodeShape.resource, Number.MAX_SAFE_INTEGER)) {
+            this.resolveClassAstObjectType(classIri).ifRight((ancestorObjectType) => objectType.ancestorObjectTypes.push(ancestorObjectType));
+        }
+        // Parents
+        for (const classIri of ancestorClassIris(nodeShape.resource, 1)) {
+            this.resolveClassAstObjectType(classIri).ifRight((parentObjectType) => objectType.parentObjectTypes.push(parentObjectType));
+        }
+        // Descendants
+        for (const classIri of descendantClassIris(nodeShape.resource, Number.MAX_SAFE_INTEGER)) {
+            this.resolveClassAstObjectType(classIri).ifRight((descendantObjectType) => objectType.descendantObjectTypes.push(descendantObjectType));
+        }
+        // Children
+        for (const classIri of descendantClassIris(nodeShape.resource, 1)) {
+            this.resolveClassAstObjectType(classIri).ifRight((childObjectType) => objectType.childObjectTypes.push(childObjectType));
+        }
+        // Populate properties
+        for (const propertyShape of nodeShape.constraints.properties) {
+            const propertyEither = this.propertyShapeAstObjectTypeProperty(propertyShape);
+            if (propertyEither.isLeft()) {
+                logger.warn("error transforming %s %s: %s", nodeShape, propertyShape, propertyEither.extract().message);
+                continue;
+                // return property;
+            }
+            objectType.properties.push(propertyEither.unsafeCoerce());
+        }
+        // Is the object type an RDF list?
+        objectType.listItemType = this.astObjectTypeListItemType(objectType, nodeShape).toMaybe();
+        return Either.of(objectType);
+    }
+    propertyShapeAstObjectTypeProperty(propertyShape) {
+        {
+            const property = this.astObjectTypePropertiesByIdentifier.get(propertyShape.resource.identifier);
+            if (property) {
+                return Either.of(property);
+            }
+        }
+        const type = this.propertyShapeAstType(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 = {
+            inline: shaclmateInline(propertyShape).orDefault(false),
+            name: this.shapeName(propertyShape),
+            path,
+            type: type.extract(),
+        };
+        this.astObjectTypePropertiesByIdentifier.set(propertyShape.resource.identifier, property);
+        return Either.of(property);
+    }
+    /**
+     * 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.
+     */
+    propertyShapeAstType(shape, inherited) {
+        const defaultValue = (shape instanceof shaclAst.PropertyShape
+            ? shape.defaultValue
+            : Maybe.empty()).alt(inherited !== null ? inherited.defaultValue : Maybe.empty());
+        const hasValue = shape.constraints.hasValue;
+        const inline = shaclmateInline(shape).alt(inherited !== null ? inherited.inline : Maybe.empty());
+        return (() => {
+            // Conjunctions/disjunctions of multiple types
+            if (shape.constraints.and.length > 0 ||
+                shape.constraints.classes.length > 0 ||
+                shape.constraints.nodes.length > 0 ||
+                shape.constraints.or.length > 0) {
+                let memberTypeEithers;
+                let compositeTypeKind;
+                if (shape.constraints.and.length > 0) {
+                    memberTypeEithers = shape.constraints.and.map((memberShape) => this.propertyShapeAstType(memberShape, {
+                        defaultValue,
+                        inline,
+                    }));
+                    compositeTypeKind = "IntersectionType";
+                }
+                else if (shape.constraints.classes.length > 0) {
+                    memberTypeEithers = shape.constraints.classes.map((classIri) => this.resolveClassAstObjectType(classIri).map((classObjectType) => inline.orDefault(false)
+                        ? classObjectType
+                        : {
+                            defaultValue: defaultValue.filter((term) => term.termType !== "Literal"),
+                            hasValue: Maybe.empty(),
+                            kind: "IdentifierType",
+                            nodeKinds: classObjectType.nodeKinds,
+                        }));
+                    compositeTypeKind = "IntersectionType";
+                }
+                else if (shape.constraints.nodes.length > 0) {
+                    memberTypeEithers = shape.constraints.nodes.map((nodeShape) => this.nodeShapeAstType(nodeShape));
+                    compositeTypeKind = "IntersectionType";
+                }
+                else {
+                    memberTypeEithers = shape.constraints.or.map((memberShape) => this.propertyShapeAstType(memberShape, {
+                        defaultValue,
+                        inline,
+                    }));
+                    compositeTypeKind = "UnionType";
+                }
+                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", shape);
+                    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 (hasValue.isNothing() &&
+                    memberItemTypes.every((memberItemType) => memberItemType.kind === "LiteralType" &&
+                        memberItemType.maxExclusive.isNothing() &&
+                        memberItemType.maxInclusive.isNothing() &&
+                        memberItemType.minExclusive.isNothing() &&
+                        memberItemType.minInclusive.isNothing())) {
+                    // Special case: all the member types are Literals without further constraints,
+                    // like dash:StringOrLangString
+                    return Either.of({
+                        datatype: Maybe.empty(),
+                        defaultValue: defaultValue.filter((term) => term.termType === "Literal"),
+                        hasValue: Maybe.empty(),
+                        kind: "LiteralType",
+                        maxExclusive: Maybe.empty(),
+                        maxInclusive: Maybe.empty(),
+                        minExclusive: Maybe.empty(),
+                        minInclusive: Maybe.empty(),
+                    });
+                }
+                if (hasValue.isNothing() &&
+                    memberItemTypes.every((memberItemType) => memberItemType.kind === "IdentifierType")) {
+                    // Special case: all member types are blank or named nodes without further constraints
+                    return Either.of({
+                        defaultValue: defaultValue.filter((term) => term.termType !== "Literal"),
+                        hasValue: Maybe.empty(),
+                        kind: "IdentifierType",
+                        nodeKinds: new Set(memberItemTypes
+                            .filter((memberItemType) => memberItemType.kind === "IdentifierType")
+                            .flatMap((memberItemType) => [...memberItemType.nodeKinds])),
+                    });
+                }
+                return Either.of({
+                    kind: compositeTypeKind,
+                    memberTypes: memberTypes,
+                });
+            }
+            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()) ||
+                // Treat any shape with a literal value as a literal type
+                hasValue.extractNullable()?.termType === "Literal" ||
+                // Treat any shape with a single sh:nodeKind of sh:Literal as a literal type
+                (shape.constraints.nodeKinds.size === 1 &&
+                    shape.constraints.nodeKinds.has(shaclAst.NodeKind.LITERAL))) {
+                return Either.of({
+                    datatype: shape.constraints.datatype,
+                    defaultValue: defaultValue.filter((term) => term.termType === "Literal"),
+                    hasValue: hasValue.filter((term) => term.termType === "Literal"),
+                    kind: "LiteralType",
+                    maxExclusive: shape.constraints.maxExclusive,
+                    maxInclusive: shape.constraints.maxInclusive,
+                    minExclusive: shape.constraints.minExclusive,
+                    minInclusive: shape.constraints.minInclusive,
+                });
+            }
+            // Treat any shape with sh:nodeKind blank node or IRI as an identifier type
+            const identifierDefaultValue = defaultValue.filter((value) => value.termType !== "Literal");
+            const hasIdentifierValue = hasValue.filter((value) => value.termType !== "Literal");
+            if (hasIdentifierValue.isJust() ||
+                identifierDefaultValue.isJust() ||
+                (shape.constraints.nodeKinds.size > 0 &&
+                    shape.constraints.nodeKinds.size <= 2 &&
+                    !shape.constraints.nodeKinds.has(shaclAst.NodeKind.LITERAL))) {
+                const nodeKinds = hasIdentifierValue
+                    .map((value) => {
+                    const nodeKinds = new Set();
+                    switch (value.termType) {
+                        case "BlankNode":
+                            nodeKinds.add(shaclAst.NodeKind.BLANK_NODE);
+                            break;
+                        case "NamedNode":
+                            nodeKinds.add(shaclAst.NodeKind.IRI);
+                            break;
+                    }
+                    return nodeKinds;
+                })
+                    .orDefaultLazy(() => shape.constraints.nodeKinds);
+                invariant(nodeKinds.size > 0);
+                return Either.of({
+                    defaultValue: identifierDefaultValue,
+                    hasValue: hasIdentifierValue,
+                    kind: "IdentifierType",
+                    nodeKinds,
+                });
+            }
+            return Left(new Error(`unable to transform type on ${shape}`));
+        })().map((itemType) => {
+            // Handle cardinality constraints
+            if (defaultValue.isJust()) {
+                // Ignore other cardinality constraints if there's a default value and treat the type as minCount=maxCount=1
+                return itemType;
+            }
+            const maxCount = shape.constraints.maxCount;
+            const minCount = shape.constraints.minCount;
+            if (maxCount.isNothing() && minCount.isNothing()) {
+                // The shape has no cardinality constraints
+                if (inherited === null) {
+                    // The shape is top-level (not an sh:or/sh:and of a top-level shape)
+                    // Treat it as a Set, the default in RDF.
+                    // We want Set to be the outermost type unless it's explicitly requested with sh:minCount 0.
+                    return {
+                        itemType,
+                        kind: "SetType",
+                        minCount: 0,
+                    };
+                }
+                // else the shape is not top-level
+                // We want Set to be the outermost type, so just return the itemType here
+                return itemType;
+            }
+            if (minCount.orDefault(0) === 0 && maxCount.extractNullable() === 1) {
+                return {
+                    itemType,
+                    kind: "OptionType",
+                };
+            }
+            if (minCount.orDefault(0) === 1 && maxCount.extractNullable() === 1) {
+                return itemType;
+            }
+            invariant(minCount.isJust() || maxCount.isJust());
+            // There are cardinality constraints for a Set. It may be an inner type.
+            return {
+                itemType,
+                kind: "SetType",
+                minCount: minCount.orDefault(0),
+            };
+        });
+    }
+    resolveClassAstObjectType(classIri) {
+        let nodeShape;
+        if (classIri.equals(owl.Class) ||
+            classIri.equals(owl.Thing) ||
+            classIri.equals(rdfs.Class)) {
+            nodeShape = Maybe.empty();
+        }
+        else {
+            nodeShape = this.shapesGraph.nodeShapeByNode(classIri);
+        }
+        return nodeShape
+            .toEither(new Error(`${classIri.value} does not correspond to a node shape`))
+            .chain((nodeShape) => this.nodeShapeAstType(nodeShape))
+            .ifLeft((error) => {
+            logger.debug("class %s did not resolve to an object type: %s", classIri.value, error.message);
+        });
+    }
+    shapeName(shape) {
+        let propertyPath = Maybe.empty();
+        if (shape instanceof shaclAst.PropertyShape &&
+            shape.path.kind === "PredicatePath") {
+            const pathIri = shape.path.iri;
+            propertyPath = Maybe.of({
+                curie: Maybe.fromNullable(this.iriPrefixMap.shrink(pathIri)?.value),
+                identifier: pathIri,
+            });
+        }
+        return {
+            curie: shape.resource.identifier.termType === "NamedNode"
+                ? Maybe.fromNullable(this.iriPrefixMap.shrink(shape.resource.identifier)?.value)
+                : Maybe.empty(),
+            identifier: shape.resource.identifier,
+            propertyPath,
+            shName: shape.name.map((name) => name.value),
+            shaclmateName: shaclmateName(shape),
+        };
+    }
+}
+//# sourceMappingURL=ShapesGraphToAstTransformer.js.map

package/ast/Ast.d.ts

@@ -0,0 +1,5 @@
+import type { ObjectType } from "./ObjectType.js";
+export interface Ast {
+    readonly objectTypes: readonly ObjectType[];
+}
+//# sourceMappingURL=Ast.d.ts.map

package/ast/Ast.js

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

package/ast/IdentifierType.d.ts

@@ -0,0 +1,13 @@
+import type { BlankNode, NamedNode } from "@rdfjs/types";
+import type { Maybe } from "purify-ts";
+import type { NodeKind } from "shacl-ast";
+/**
+ * A type corresponding to sh:nodeKind of a blank node or IRI, and not corresponding to a node shape.
+ */
+export interface IdentifierType {
+    readonly defaultValue: Maybe<BlankNode | NamedNode>;
+    readonly hasValue: Maybe<BlankNode | NamedNode>;
+    readonly kind: "IdentifierType";
+    readonly nodeKinds: Set<NodeKind.BLANK_NODE | NodeKind.IRI>;
+}
+//# sourceMappingURL=IdentifierType.d.ts.map

package/ast/IdentifierType.js

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

package/ast/IntersectionType.d.ts

@@ -0,0 +1,9 @@
+import type { Type } from "./Type.js";
+/**
+ * A conjunction ("and") of types, corresponding to an sh:and.
+ */
+export interface IntersectionType {
+    readonly kind: "IntersectionType";
+    readonly memberTypes: readonly Type[];
+}
+//# sourceMappingURL=IntersectionType.d.ts.map

package/ast/IntersectionType.js

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

package/ast/LiteralType.d.ts

@@ -0,0 +1,13 @@
+import type { Literal, NamedNode } from "@rdfjs/types";
+import type { Maybe } from "purify-ts";
+export interface LiteralType {
+    readonly datatype: Maybe<NamedNode>;
+    readonly defaultValue: Maybe<Literal>;
+    readonly hasValue: Maybe<Literal>;
+    readonly kind: "LiteralType";
+    readonly maxExclusive: Maybe<Literal>;
+    readonly maxInclusive: Maybe<Literal>;
+    readonly minExclusive: Maybe<Literal>;
+    readonly minInclusive: Maybe<Literal>;
+}
+//# sourceMappingURL=LiteralType.d.ts.map

package/ast/LiteralType.js

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

package/ast/MintingStrategy.d.ts

@@ -0,0 +1,8 @@
+/**
+ * TypeScript enum corresponding to shaclmate:mintingStrategy, for simpler manipulation.
+ */
+export declare enum MintingStrategy {
+    SHA256 = 1,
+    UUIDv4 = 2
+}
+//# sourceMappingURL=MintingStrategy.d.ts.map

package/ast/MintingStrategy.js

@@ -0,0 +1,9 @@
+/**
+ * TypeScript enum corresponding to shaclmate:mintingStrategy, for simpler manipulation.
+ */
+export var MintingStrategy;
+(function (MintingStrategy) {
+    MintingStrategy[MintingStrategy["SHA256"] = 1] = "SHA256";
+    MintingStrategy[MintingStrategy["UUIDv4"] = 2] = "UUIDv4";
+})(MintingStrategy || (MintingStrategy = {}));
+//# sourceMappingURL=MintingStrategy.js.map

package/ast/Name.d.ts

@@ -0,0 +1,13 @@
+import type { BlankNode, NamedNode } from "@rdfjs/types";
+import type { Maybe } from "purify-ts";
+export interface Name {
+    readonly curie: Maybe<string>;
+    readonly identifier: BlankNode | NamedNode;
+    readonly propertyPath: Maybe<{
+        curie: Maybe<string>;
+        identifier: NamedNode;
+    }>;
+    readonly shName: Maybe<string>;
+    readonly shaclmateName: Maybe<string>;
+}
+//# sourceMappingURL=Name.d.ts.map

package/ast/Name.js

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