@shaclmate/compiler 4.0.10 → 4.0.12

package/dist/_ShapesGraphToAstTransformer/shapeNodeKinds.js

@@ -1,10 +1,6 @@
 import { NodeKind } from "@shaclmate/shacl-ast";
 import { Either, Left } from "purify-ts";
-const defaultNodeShapeNodeKinds = new Set([
-    "BlankNode",
-    "IRI",
-    "Literal",
-]);
+import { defaultNodeShapeNodeKinds } from "./defaultNodeShapeNodeKinds.js";
 const defaultPropertyShapeNodeKinds = new Set([
     "BlankNode",
     "IRI",
@@ -169,7 +165,11 @@ export function shapeNodeKinds(shape, options) {
         if (shape.kind === "NodeShape") {
             return Either.of(options?.defaultNodeShapeNodeKinds ?? defaultNodeShapeNodeKinds);
         }
-        return Either.of(options?.defaultPropertyShapeNodeKinds ?? defaultPropertyShapeNodeKinds);
+        if (shape.path.termType === "InversePath") {
+            // Inverse paths can only have blank nodes and IRIs as values, because the value is the subject of a triple.
+            return Either.of(new Set(["BlankNode", "IRI"]));
+        }
+        return Either.of(defaultPropertyShapeNodeKinds);
     });
 }
 //# sourceMappingURL=shapeNodeKinds.js.map

package/dist/_ShapesGraphToAstTransformer/transformPropertyShapeToAstObjectTypeProperty.js

@@ -137,7 +137,10 @@ export function transformPropertyShapeToAstObjectTypeProperty({ objectType, prop
                     case "ObjectType":
                         return Either.of(astResolveType);
                     case "UnionType":
-                        if (!astResolveType.isObjectUnionType()) {
+                        if (
+                        // This check relies on .members being populated, which may not happen in cycles
+                        astResolveType.members.length > 0 &&
+                            !astResolveType.isObjectUnionType()) {
                             return Left(new Error(`${propertyShape} resolve cannot refer to a ${astResolveType.kind} with non-ObjectType members`));
                         }
                         return Either.of(astResolveType);
@@ -237,6 +240,10 @@ export function transformPropertyShapeToAstObjectTypeProperty({ objectType, prop
                     invariant(false, `unexpected lazy AST type ${astType.kind}`);
             }
         }
+        if (propertyShape.path.termType === "InversePath" &&
+            astType.nodeKinds.has("Literal")) {
+            return Left(new Error(`${propertyShape}: property shapes with inverse paths can only have blank node or IRI node kinds`));
+        }
         return Either.of(new ast.ObjectType.Property({
             comment: propertyShape.comment,
             description: propertyShape.description,

package/dist/ast/AbstractCompoundType.d.ts

@@ -1,3 +1,4 @@
+import type { NodeKind } from "@shaclmate/shacl-ast";
 import type { TsFeature } from "../enums/TsFeature.js";
 import { AbstractType } from "./AbstractType.js";
 import type { BlankNodeType } from "./BlankNodeType.js";
@@ -25,6 +26,7 @@ export declare abstract class AbstractCompoundType<MemberT extends AbstractCompo
         tsFeatures: ReadonlySet<TsFeature>;
     } & ConstructorParameters<typeof AbstractType>[0]);
     get members(): readonly MemberT[];
+    get nodeKinds(): ReadonlySet<NodeKind>;
     get recursive(): boolean;
     get tsFeatures(): ReadonlySet<TsFeature>;
     addMember(member: MemberT): void;

package/dist/ast/AbstractCompoundType.js

@@ -4,7 +4,6 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-import { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
 import { AbstractType } from "./AbstractType.js";
 /**
@@ -29,9 +28,17 @@ export class AbstractCompoundType extends AbstractType {
         this.#tsFeatures = tsFeatures;
     }
     get members() {
-        invariant(this.#members.length > 0);
         return this.#members;
     }
+    get nodeKinds() {
+        const nodeKinds = new Set();
+        for (const member of this.members) {
+            for (const nodeKind of member.type.nodeKinds) {
+                nodeKinds.add(nodeKind);
+            }
+        }
+        return nodeKinds;
+    }
     get recursive() {
         return this.members.some((member) => member.type.recursive);
     }
@@ -77,6 +84,9 @@ export class AbstractCompoundType extends AbstractType {
         return `${this.kind}(memberTypes=[${this.members.map((memberType) => memberType.toString()).join(", ")}])`;
     }
 }
+__decorate([
+    Memoize()
+], AbstractCompoundType.prototype, "nodeKinds", null);
 __decorate([
     Memoize()
 ], AbstractCompoundType.prototype, "tsFeatures", null);

package/dist/ast/AbstractContainerType.d.ts

@@ -1,3 +1,4 @@
+import type { NodeKind } from "@shaclmate/shacl-ast";
 import { AbstractType } from "./AbstractType.js";
 import type { BlankNodeType } from "./BlankNodeType.js";
 import type { IdentifierType } from "./IdentifierType.js";
@@ -23,6 +24,7 @@ export declare abstract class AbstractContainerType<ItemTypeT extends AbstractCo
     constructor({ itemType, ...superParameters }: {
         itemType: ItemTypeT;
     } & ConstructorParameters<typeof AbstractType>[0]);
+    get nodeKinds(): ReadonlySet<NodeKind>;
     get recursive(): boolean;
     equals(other: AbstractContainerType<ItemTypeT>): boolean;
     toString(): string;

package/dist/ast/AbstractContainerType.js

@@ -14,6 +14,9 @@ export class AbstractContainerType extends AbstractType {
         super(superParameters);
         this.itemType = itemType;
     }
+    get nodeKinds() {
+        return this.itemType.nodeKinds;
+    }
     get recursive() {
         return this.itemType.recursive;
     }

package/dist/ast/AbstractLazyObjectType.d.ts

@@ -1,3 +1,4 @@
+import type { NodeKind } from "@shaclmate/shacl-ast";
 import { AbstractType } from "./AbstractType.js";
 import type { ObjectType } from "./ObjectType.js";
 import type { ObjectUnionType } from "./ObjectUnionType.js";
@@ -14,6 +15,7 @@ export declare abstract class AbstractLazyObjectType<PartialTypeT extends Abstra
         partialType: PartialTypeT;
         resolveType: ResolveTypeT;
     } & ConstructorParameters<typeof AbstractType>[0]);
+    get nodeKinds(): ReadonlySet<NodeKind>;
     get recursive(): boolean;
     equals(other: AbstractLazyObjectType<PartialTypeT, ResolveTypeT>): boolean;
     toString(): string;

package/dist/ast/AbstractLazyObjectType.js

@@ -11,6 +11,9 @@ export class AbstractLazyObjectType extends AbstractType {
         this.partialType = partialType;
         this.resolveType = resolveType;
     }
+    get nodeKinds() {
+        return this.partialType.nodeKinds;
+    }
     get recursive() {
         return this.partialType.recursive;
     }

package/dist/ast/AbstractTermType.d.ts

@@ -1,5 +1,4 @@
 import type { BlankNode, Literal, NamedNode } from "@rdfjs/types";
-import type { NodeKind } from "@shaclmate/shacl-ast";
 import { AbstractType } from "./AbstractType.js";
 /**
  * Abstract base class of term types (BlankNodeType, IdentifierType, LiteralType, IriType, TermType).
@@ -13,7 +12,6 @@ export declare abstract class AbstractTermType<ConstantTermT extends Literal | N
     readonly hasValues: readonly ConstantTermT[];
     readonly in_: readonly ConstantTermT[];
     abstract readonly kind: "BlankNodeType" | "IdentifierType" | "IriType" | "LiteralType" | "TermType";
-    abstract readonly nodeKinds: ReadonlySet<NodeKind>;
     readonly recursive = false;
     constructor({ hasValues, in_, ...superParameters }: {
         hasValues: readonly ConstantTermT[];

package/dist/ast/AbstractType.d.ts

@@ -1,4 +1,5 @@
 import type { BlankNode, NamedNode } from "@rdfjs/types";
+import type { NodeKind } from "@shaclmate/shacl-ast";
 import { Maybe } from "purify-ts";
 /**
  * Abstract base class for Types.
@@ -16,6 +17,12 @@ export declare abstract class AbstractType {
      * Name of this type, from shaclmate:name or sh:name.
      */
     readonly name: Maybe<string>;
+    /**
+     * The range of node kinds of this type.
+     *
+     * For example, an object type has blank and IRI node kinds, while a string type has a Literal node kind.
+     */
+    abstract readonly nodeKinds: ReadonlySet<NodeKind>;
     /**
      * Does this type directly or indirectly reference itself?
      */

package/dist/ast/IntersectionType.js

@@ -5,9 +5,10 @@ import { AbstractCompoundType } from "./AbstractCompoundType.js";
 export class IntersectionType extends AbstractCompoundType {
     kind = "IntersectionType";
     isObjectIntersectionType() {
-        return this.members.every((member) => member.type.kind === "ObjectType" ||
-            (member.type.kind === "IntersectionType" &&
-                member.type.isObjectIntersectionType()));
+        return (this.members.length > 0 &&
+            this.members.every((member) => member.type.kind === "ObjectType" ||
+                (member.type.kind === "IntersectionType" &&
+                    member.type.isObjectIntersectionType())));
     }
 }
 (function (IntersectionType) {

package/dist/ast/ObjectType.d.ts

@@ -1,4 +1,5 @@
 import type { BlankNode, NamedNode } from "@rdfjs/types";
+import type { NodeKind } from "@shaclmate/shacl-ast";
 import type { Maybe } from "purify-ts";
 import { PropertyPath } from "rdfjs-resource";
 import type { IdentifierMintingStrategy } from "../enums/IdentifierMintingStrategy.js";
@@ -43,6 +44,7 @@ export declare class ObjectType extends AbstractType {
      * Type discriminant.
      */
     readonly kind = "ObjectType";
+    readonly nodeKinds: ReadonlySet<NodeKind>;
     /**
      * Was this type synthesized or did it come from SHACL?
      */

package/dist/ast/ObjectType.js

@@ -73,6 +73,7 @@ export class ObjectType extends AbstractType {
      * Type discriminant.
      */
     kind = "ObjectType";
+    nodeKinds = nodeKinds;
     /**
      * Was this type synthesized or did it come from SHACL?
      */
@@ -169,6 +170,7 @@ export class ObjectType extends AbstractType {
         return `${this.kind}(shapeIdentifier=${Resource.Identifier.toString(this.shapeIdentifier)})`;
     }
 }
+const nodeKinds = new Set(["BlankNode", "IRI"]);
 (function (ObjectType) {
     class Property {
         /**

package/dist/ast/UnionType.js

@@ -5,8 +5,9 @@ import { AbstractCompoundType } from "./AbstractCompoundType.js";
 export class UnionType extends AbstractCompoundType {
     kind = "UnionType";
     isObjectUnionType() {
-        return this.members.every((member) => member.type.kind === "ObjectType" ||
-            (member.type.kind === "UnionType" && member.type.isObjectUnionType()));
+        return (this.members.length > 0 &&
+            this.members.every((member) => member.type.kind === "ObjectType" ||
+                (member.type.kind === "UnionType" && member.type.isObjectUnionType())));
     }
 }
 (function (UnionType) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "dependencies": {
-    "@shaclmate/shacl-ast": "4.0.10",
+    "@shaclmate/shacl-ast": "4.0.12",
     "@rdfjs/data-model": "~2.1.1",
     "@rdfjs/dataset": "~2.0.2",
     "@rdfjs/prefix-map": "~0.1.2",
@@ -78,5 +78,5 @@
   },
   "type": "module",
   "types": "./dist/index.d.ts",
-  "version": "4.0.10"
+  "version": "4.0.12"
 }