@shaclmate/compiler 2.0.23 → 3.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "dependencies": {
-    "@shaclmate/shacl-ast": "2.0.23",
+    "@shaclmate/shacl-ast": "3.0.0",
     "@rdfjs/prefix-map": "^0.1.2",
     "@rdfjs/term-map": "^2.0.2",
     "@rdfjs/term-set": "^2.0.3",
@@ -22,13 +22,10 @@
     "typescript-memoize": "^1.1.1"
   },
   "devDependencies": {
-    "@shaclmate/kitchen-sink-example": "2.0.23",
-    "@shaclmate/runtime": "2.0.23",
+    "@shaclmate/kitchen-sink-example": "3.0.0",
+    "@shaclmate/runtime": "3.0.0",
     "@kos-kit/sparql-client": "2.0.115",
-    "@types/n3": "^1.21.1",
-    "oxigraph": "0.4.11",
-    "n3": "^1.21.3",
-    "rdfjs-resource": "1.0.20"
+    "oxigraph": "0.4.11"
   },
   "exports": {
     ".": {
@@ -79,5 +76,5 @@
     "unlink": "npm unlink -g @shaclmate/compiler"
   },
   "type": "module",
-  "version": "2.0.23"
+  "version": "3.0.0"
 }

package/dist/_ShapesGraphToAstTransformer/transformPropertyShapeToAstCompositeType.d.ts

@@ -1,12 +0,0 @@
-import type { 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<Literal | NamedNode>;
-} | null): Either<Error, ast.Type>;
-//# sourceMappingURL=transformPropertyShapeToAstCompositeType.d.ts.map

package/dist/_ShapesGraphToAstTransformer/transformPropertyShapeToAstCompositeType.js

@@ -1,193 +0,0 @@
-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 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());
-    let memberTypeEithers;
-    let compositeTypeKind;
-    if (shape.constraints.and.length > 0) {
-        memberTypeEithers = shape.constraints.and.map((memberShape) => this.transformPropertyShapeToAstType(memberShape, {
-            defaultValue,
-        }));
-        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.transformPropertyShapeToAstType(memberShape, {
-            defaultValue,
-        }));
-        compositeTypeKind = "UnionType";
-    }
-    else {
-        return Left(new Error(`unable to transform ${shape} into an AST type`));
-    }
-    invariant(memberTypeEithers.length > 0);
-    let 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 flattenedMemberTypesEither = flattenAstObjectCompositeTypeMemberTypes({
-            objectCompositeTypeKind: compositeTypeKind === "IntersectionType"
-                ? "ObjectIntersectionType"
-                : "ObjectUnionType",
-            memberTypes: memberObjectTypes,
-            shape,
-        });
-        if (flattenedMemberTypesEither.isLeft()) {
-            return flattenedMemberTypesEither;
-        }
-        const { memberTypes: flattenedMemberTypes } = flattenedMemberTypesEither.unsafeCoerce();
-        memberTypes = memberObjectTypes = flattenedMemberTypes.concat();
-    }
-    return widenAstCompositeTypeToSingleType({
-        defaultValue,
-        memberTypes,
-        shape,
-    }).altLazy(() => 
-    // True composite type
-    Either.of({
-        kind: compositeTypeKind,
-        memberTypes,
-    }));
-}
-function widenAstCompositeTypeToSingleType({ defaultValue, memberTypes, shape, }) {
-    if (shape.constraints.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`));
-    }
-    // Get the type underlying a set or option
-    const memberItemTypes = memberTypes.map((memberType) => {
-        switch (memberType.kind) {
-            case "OptionType":
-                return memberType.itemType;
-            case "SetType":
-                return memberType.itemType;
-            default:
-                return memberType;
-        }
-    });
-    const canWiden = (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" && canWiden(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" && canWiden(memberItemType))) {
-        // 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 (memberItemTypes.every((memberItemType) => (memberItemType.kind === "IdentifierType" ||
-        memberItemType.kind === "LiteralType" ||
-        memberItemType.kind === "TermType") &&
-        canWiden(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 Left(new Error(`shape ${shape} member types could not be widened into a single type`));
-}
-//# sourceMappingURL=transformPropertyShapeToAstCompositeType.js.map

package/dist/_ShapesGraphToAstTransformer/transformPropertyShapeToAstIdentifierType.d.ts

@@ -1,12 +0,0 @@
-import type { 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<Literal | NamedNode>;
-} | null): Either<Error, ast.IdentifierType>;
-//# sourceMappingURL=transformPropertyShapeToAstIdentifierType.d.ts.map

package/dist/_ShapesGraphToAstTransformer/transformPropertyShapeToAstIdentifierType.js

@@ -1,29 +0,0 @@
-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/dist/_ShapesGraphToAstTransformer/transformPropertyShapeToAstLiteralType.d.ts

@@ -1,12 +0,0 @@
-import type { 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<Literal | NamedNode>;
-} | null): Either<Error, ast.LiteralType>;
-//# sourceMappingURL=transformPropertyShapeToAstLiteralType.d.ts.map

package/dist/_ShapesGraphToAstTransformer/transformPropertyShapeToAstLiteralType.js

@@ -1,43 +0,0 @@
-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/dist/_ShapesGraphToAstTransformer/transformPropertyShapeToAstTermType.d.ts

@@ -1,14 +0,0 @@
-import type { 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<Literal | NamedNode>;
-} | null): Either<Error, Omit<ast.TermType, "kind"> & {
-    readonly kind: "TermType";
-}>;
-//# sourceMappingURL=transformPropertyShapeToAstTermType.d.ts.map

package/dist/_ShapesGraphToAstTransformer/transformPropertyShapeToAstTermType.js

@@ -1,21 +0,0 @@
-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/dist/_ShapesGraphToAstTransformer/transformPropertyShapeToAstType.d.ts

@@ -1,15 +0,0 @@
-import type { 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<Literal | NamedNode>;
-} | null): Either<Error, ast.Type>;
-//# sourceMappingURL=transformPropertyShapeToAstType.d.ts.map

package/dist/_ShapesGraphToAstTransformer/transformPropertyShapeToAstType.js

@@ -1,60 +0,0 @@
-import { invariant } from "ts-invariant";
-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 function transformPropertyShapeToAstType(shape, inherited) {
-    // Try to transform the property shape into an AST type without cardinality constraints
-    return this.transformPropertyShapeToAstCompositeType(shape, inherited)
-        .altLazy(() => this.transformPropertyShapeToAstIdentifierType(shape, inherited))
-        .altLazy(() => this.transformPropertyShapeToAstLiteralType(shape, inherited))
-        .altLazy(() => this.transformPropertyShapeToAstTermType(shape, inherited))
-        .map((itemType) => {
-        // Handle cardinality constraints
-        if ((shape instanceof input.PropertyShape && shape.defaultValue.isJust()) ||
-            inherited?.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:xone/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",
-                    mutable: shape.mutable,
-                    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),
-            mutable: shape.mutable,
-        };
-    });
-}
-//# sourceMappingURL=transformPropertyShapeToAstType.js.map