@shaclmate/compiler 3.0.3 → 4.0.0

package/dist/Compiler.d.ts

@@ -1,8 +1,7 @@
 import PrefixMap from "@rdfjs/prefix-map/PrefixMap.js";
-import type { DatasetCore } from "@rdfjs/types";
 import type { Either } from "purify-ts";
 import type { Generator } from "./generators/Generator.js";
-import { ShapesGraph } from "./input/ShapesGraph.js";
+import type { ShapesGraph } from "./input/ShapesGraph.js";
 export declare class Compiler {
     private readonly generator;
     private readonly iriPrefixMap;
@@ -10,6 +9,6 @@ export declare class Compiler {
         generator: Generator;
         iriPrefixMap?: PrefixMap;
     });
-    compile(input: DatasetCore | ShapesGraph): Either<Error, string>;
+    compile(shapesGraph: ShapesGraph): Either<Error, string>;
 }
 //# sourceMappingURL=Compiler.d.ts.map

package/dist/Compiler.js

@@ -1,6 +1,5 @@
 import PrefixMap from "@rdfjs/prefix-map/PrefixMap.js";
 import { ShapesGraphToAstTransformer } from "./ShapesGraphToAstTransformer.js";
-import { ShapesGraph } from "./input/ShapesGraph.js";
 export class Compiler {
     generator;
     iriPrefixMap;
@@ -8,15 +7,13 @@ export class Compiler {
         this.generator = generator;
         this.iriPrefixMap = iriPrefixMap ?? new PrefixMap();
     }
-    compile(input) {
-        const shapesGraph = input instanceof ShapesGraph
-            ? input
-            : new ShapesGraph({ dataset: input });
-        const astEither = new ShapesGraphToAstTransformer({
+    compile(shapesGraph) {
+        return new ShapesGraphToAstTransformer({
             iriPrefixMap: this.iriPrefixMap,
             shapesGraph,
-        }).transform();
-        return astEither.map((ast) => this.generator.generate(ast));
+        })
+            .transform()
+            .map((ast) => this.generator.generate(ast));
     }
 }
 //# sourceMappingURL=Compiler.js.map

package/dist/Eithers.d.ts

@@ -0,0 +1,14 @@
+import type { Either } from "purify-ts";
+export declare namespace Eithers {
+    function chain2<R1, R2>(either1: Either<Error, R1>, either2: Either<Error, R2>): Either<Error, [R1, R2]>;
+    function chain3<R1, R2, R3>(either1: Either<Error, R1>, either2: Either<Error, R2>, either3: Either<Error, R3>): Either<Error, [R1, R2, R3]>;
+    function chain4<R1, R2, R3, R4>(either1: Either<Error, R1>, either2: Either<Error, R2>, either3: Either<Error, R3>, either4: Either<Error, R4>): Either<Error, [R1, R2, R3, R4]>;
+    function chain5<R1, R2, R3, R4, R5>(either1: Either<Error, R1>, either2: Either<Error, R2>, either3: Either<Error, R3>, either4: Either<Error, R4>, either5: Either<Error, R5>): Either<Error, [R1, R2, R3, R4, R5]>;
+    function chain6<R1, R2, R3, R4, R5, R6>(either1: Either<Error, R1>, either2: Either<Error, R2>, either3: Either<Error, R3>, either4: Either<Error, R4>, either5: Either<Error, R5>, either6: Either<Error, R6>): Either<Error, [R1, R2, R3, R4, R5, R6]>;
+    function chain7<R1, R2, R3, R4, R5, R6, R7>(either1: Either<Error, R1>, either2: Either<Error, R2>, either3: Either<Error, R3>, either4: Either<Error, R4>, either5: Either<Error, R5>, either6: Either<Error, R6>, either7: Either<Error, R7>): Either<Error, [R1, R2, R3, R4, R5, R6, R7]>;
+    function chain8<R1, R2, R3, R4, R5, R6, R7, R8>(either1: Either<Error, R1>, either2: Either<Error, R2>, either3: Either<Error, R3>, either4: Either<Error, R4>, either5: Either<Error, R5>, either6: Either<Error, R6>, either7: Either<Error, R7>, either8: Either<Error, R8>): Either<Error, [R1, R2, R3, R4, R5, R6, R7, R8]>;
+    function chain9<R1, R2, R3, R4, R5, R6, R7, R8, R9>(either1: Either<Error, R1>, either2: Either<Error, R2>, either3: Either<Error, R3>, either4: Either<Error, R4>, either5: Either<Error, R5>, either6: Either<Error, R6>, either7: Either<Error, R7>, either8: Either<Error, R8>, either9: Either<Error, R9>): Either<Error, [R1, R2, R3, R4, R5, R6, R7, R8, R9]>;
+    function chain10<R1, R2, R3, R4, R5, R6, R7, R8, R9, R10>(either1: Either<Error, R1>, either2: Either<Error, R2>, either3: Either<Error, R3>, either4: Either<Error, R4>, either5: Either<Error, R5>, either6: Either<Error, R6>, either7: Either<Error, R7>, either8: Either<Error, R8>, either9: Either<Error, R9>, either10: Either<Error, R10>): Either<Error, [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10]>;
+    function chain11<R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11>(either1: Either<Error, R1>, either2: Either<Error, R2>, either3: Either<Error, R3>, either4: Either<Error, R4>, either5: Either<Error, R5>, either6: Either<Error, R6>, either7: Either<Error, R7>, either8: Either<Error, R8>, either9: Either<Error, R9>, either10: Either<Error, R10>, either11: Either<Error, R11>): Either<Error, [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11]>;
+}
+//# sourceMappingURL=Eithers.d.ts.map

package/dist/Eithers.js

@@ -0,0 +1,67 @@
+export var Eithers;
+(function (Eithers) {
+    function chain2(either1, either2) {
+        return either1.chain((r1) => either2.map((r2) => [r1, r2]));
+    }
+    Eithers.chain2 = chain2;
+    function chain3(either1, either2, either3) {
+        return either1.chain((r1) => either2.chain((r2) => either3.map((r3) => [r1, r2, r3])));
+    }
+    Eithers.chain3 = chain3;
+    function chain4(either1, either2, either3, either4) {
+        return either1.chain((r1) => either2.chain((r2) => either3.chain((r3) => either4.map((r4) => [r1, r2, r3, r4]))));
+    }
+    Eithers.chain4 = chain4;
+    function chain5(either1, either2, either3, either4, either5) {
+        return either1.chain((r1) => either2.chain((r2) => either3.chain((r3) => either4.chain((r4) => either5.map((r5) => [r1, r2, r3, r4, r5])))));
+    }
+    Eithers.chain5 = chain5;
+    function chain6(either1, either2, either3, either4, either5, either6) {
+        return either1.chain((r1) => either2.chain((r2) => either3.chain((r3) => either4.chain((r4) => either5.chain((r5) => either6.map((r6) => [r1, r2, r3, r4, r5, r6]))))));
+    }
+    Eithers.chain6 = chain6;
+    function chain7(either1, either2, either3, either4, either5, either6, either7) {
+        return either1.chain((r1) => either2.chain((r2) => either3.chain((r3) => either4.chain((r4) => either5.chain((r5) => either6.chain((r6) => either7.map((r7) => [r1, r2, r3, r4, r5, r6, r7])))))));
+    }
+    Eithers.chain7 = chain7;
+    function chain8(either1, either2, either3, either4, either5, either6, either7, either8) {
+        return either1.chain((r1) => either2.chain((r2) => either3.chain((r3) => either4.chain((r4) => either5.chain((r5) => either6.chain((r6) => either7.chain((r7) => either8.map((r8) => [r1, r2, r3, r4, r5, r6, r7, r8]))))))));
+    }
+    Eithers.chain8 = chain8;
+    function chain9(either1, either2, either3, either4, either5, either6, either7, either8, either9) {
+        return either1.chain((r1) => either2.chain((r2) => either3.chain((r3) => either4.chain((r4) => either5.chain((r5) => either6.chain((r6) => either7.chain((r7) => either8.chain((r8) => either9.map((r9) => [r1, r2, r3, r4, r5, r6, r7, r8, r9])))))))));
+    }
+    Eithers.chain9 = chain9;
+    function chain10(either1, either2, either3, either4, either5, either6, either7, either8, either9, either10) {
+        return either1.chain((r1) => either2.chain((r2) => either3.chain((r3) => either4.chain((r4) => either5.chain((r5) => either6.chain((r6) => either7.chain((r7) => either8.chain((r8) => either9.chain((r9) => either10.map((r10) => [
+            r1,
+            r2,
+            r3,
+            r4,
+            r5,
+            r6,
+            r7,
+            r8,
+            r9,
+            r10,
+        ]))))))))));
+    }
+    Eithers.chain10 = chain10;
+    function chain11(either1, either2, either3, either4, either5, either6, either7, either8, either9, either10, either11) {
+        return either1.chain((r1) => either2.chain((r2) => either3.chain((r3) => either4.chain((r4) => either5.chain((r5) => either6.chain((r6) => either7.chain((r7) => either8.chain((r8) => either9.chain((r9) => either10.chain((r10) => either11.map((r11) => [
+            r1,
+            r2,
+            r3,
+            r4,
+            r5,
+            r6,
+            r7,
+            r8,
+            r9,
+            r10,
+            r11,
+        ])))))))))));
+    }
+    Eithers.chain11 = chain11;
+})(Eithers || (Eithers = {}));
+//# sourceMappingURL=Eithers.js.map

package/dist/ShapesGraphToAstTransformer.d.ts

@@ -2,22 +2,17 @@ import type PrefixMap from "@rdfjs/prefix-map/PrefixMap.js";
 import TermMap from "@rdfjs/term-map";
 import type * as rdfjs from "@rdfjs/types";
 import { Either } from "purify-ts";
+import { CurieFactory } from "./_ShapesGraphToAstTransformer/CurieFactory.js";
 import * as _ShapesGraphToAstTransformer from "./_ShapesGraphToAstTransformer/index.js";
 import type * as ast from "./ast/index.js";
 import type * as input from "./input/index.js";
 export declare class ShapesGraphToAstTransformer {
-    protected readonly astObjectTypePropertiesByIdentifier: TermMap<rdfjs.BlankNode | rdfjs.NamedNode, ast.ObjectType.Property>;
-    protected readonly iriLocalParts: Record<string, Record<string, number>>;
-    protected readonly iriPrefixMap: PrefixMap;
+    protected readonly curieFactory: CurieFactory;
     protected readonly nodeShapeAstTypesByIdentifier: TermMap<rdfjs.BlankNode | rdfjs.NamedNode, _ShapesGraphToAstTransformer.NodeShapeAstType>;
-    protected shapeAstName: typeof _ShapesGraphToAstTransformer.shapeAstName;
     protected readonly shapesGraph: input.ShapesGraph;
+    protected shapeIdentifier: typeof _ShapesGraphToAstTransformer.shapeIdentifier;
     protected transformNodeShapeToAstType: typeof _ShapesGraphToAstTransformer.transformNodeShapeToAstType;
     protected transformPropertyShapeToAstObjectTypeProperty: typeof _ShapesGraphToAstTransformer.transformPropertyShapeToAstObjectTypeProperty;
-    protected transformShapeToAstCompositeType: typeof _ShapesGraphToAstTransformer.transformShapeToAstCompositeType;
-    protected transformShapeToAstIdentifierType: typeof _ShapesGraphToAstTransformer.transformShapeToAstIdentifierType;
-    protected transformShapeToAstLiteralType: typeof _ShapesGraphToAstTransformer.transformShapeToAstLiteralType;
-    protected transformShapeToAstTermType: typeof _ShapesGraphToAstTransformer.transformShapeToAstTermType;
     protected transformShapeToAstType: typeof _ShapesGraphToAstTransformer.transformShapeToAstType;
     constructor({ iriPrefixMap, shapesGraph, }: {
         iriPrefixMap: PrefixMap;

package/dist/ShapesGraphToAstTransformer.js

@@ -1,24 +1,19 @@
 import TermMap from "@rdfjs/term-map";
 import { dash } from "@tpluscode/rdf-ns-builders";
 import { Either } from "purify-ts";
+import { CurieFactory } from "./_ShapesGraphToAstTransformer/CurieFactory.js";
 import * as _ShapesGraphToAstTransformer from "./_ShapesGraphToAstTransformer/index.js";
 export class ShapesGraphToAstTransformer {
     // Members are protected so they're accessible to the bound functions
-    astObjectTypePropertiesByIdentifier = new TermMap();
-    iriLocalParts = {};
-    iriPrefixMap;
+    curieFactory;
     nodeShapeAstTypesByIdentifier = new TermMap();
-    shapeAstName = _ShapesGraphToAstTransformer.shapeAstName;
     shapesGraph;
+    shapeIdentifier = _ShapesGraphToAstTransformer.shapeIdentifier;
     transformNodeShapeToAstType = _ShapesGraphToAstTransformer.transformNodeShapeToAstType;
     transformPropertyShapeToAstObjectTypeProperty = _ShapesGraphToAstTransformer.transformPropertyShapeToAstObjectTypeProperty;
-    transformShapeToAstCompositeType = _ShapesGraphToAstTransformer.transformShapeToAstCompositeType;
-    transformShapeToAstIdentifierType = _ShapesGraphToAstTransformer.transformShapeToAstIdentifierType;
-    transformShapeToAstLiteralType = _ShapesGraphToAstTransformer.transformShapeToAstLiteralType;
-    transformShapeToAstTermType = _ShapesGraphToAstTransformer.transformShapeToAstTermType;
     transformShapeToAstType = _ShapesGraphToAstTransformer.transformShapeToAstType;
     constructor({ iriPrefixMap, shapesGraph, }) {
-        this.iriPrefixMap = iriPrefixMap;
+        this.curieFactory = new CurieFactory({ prefixMap: iriPrefixMap });
         this.shapesGraph = shapesGraph;
     }
     transform() {
@@ -35,7 +30,7 @@ export class ShapesGraphToAstTransformer {
             }
             const nodeShapeAstTypeEither = this.transformNodeShapeToAstType(nodeShape);
             if (nodeShapeAstTypeEither.isLeft()) {
-                continue;
+                return nodeShapeAstTypeEither;
             }
             const nodeShapeAstType = nodeShapeAstTypeEither.unsafeCoerce();
             switch (nodeShapeAstType.kind) {
@@ -47,20 +42,24 @@ export class ShapesGraphToAstTransformer {
                 case "ObjectType": {
                     nodeShapeAstObjectTypes.push(nodeShapeAstType);
                     for (const property of nodeShapeAstType.properties) {
-                        property.stubType
-                            .map((stubType) => stubType.kind === "ObjectType" ||
-                            stubType.kind === "ObjectUnionType"
-                            ? stubType
-                            : stubType.itemType)
-                            .filter((stubItemType) => stubItemType.kind === "ObjectType")
-                            .filter((stubItemType) => stubItemType.synthetic)
-                            .ifJust((stubItemType) => {
-                            const stubItemTypeName = stubItemType.name.syntheticName.unsafeCoerce();
-                            if (!syntheticAstObjectTypesByName[stubItemTypeName]) {
-                                syntheticAstObjectTypesByName[stubItemTypeName] =
-                                    stubItemType;
+                        switch (property.type.kind) {
+                            case "LazyObjectOptionType":
+                            case "LazyObjectSetType":
+                            case "LazyObjectType": {
+                                const partialItemType = property.type.partialType.kind === "ObjectType" ||
+                                    property.type.partialType.kind === "ObjectUnionType"
+                                    ? property.type.partialType
+                                    : property.type.partialType.itemType;
+                                if (partialItemType.kind === "ObjectType" &&
+                                    partialItemType.synthetic) {
+                                    const partialItemTypeName = partialItemType.name.unsafeCoerce();
+                                    if (!syntheticAstObjectTypesByName[partialItemTypeName]) {
+                                        syntheticAstObjectTypesByName[partialItemTypeName] =
+                                            partialItemType;
+                                    }
+                                }
                             }
-                        });
+                        }
                     }
                     break;
                 }

package/dist/_ShapesGraphToAstTransformer/CurieFactory.d.ts

@@ -0,0 +1,16 @@
+import type PrefixMap from "@rdfjs/prefix-map/PrefixMap.js";
+import type { NamedNode } from "@rdfjs/types";
+import { Maybe } from "purify-ts";
+import { Curie } from "../ast/Curie.js";
+/**
+ * Factory for Compact URIs (CURIEs). Tracks whether the reference part of the CURIE is unique.
+ */
+export declare class CurieFactory {
+    private readonly prefixMap;
+    private readonly referenceCounts;
+    constructor({ prefixMap }: {
+        prefixMap: PrefixMap;
+    });
+    create(namedNode: NamedNode): Maybe<Curie>;
+}
+//# sourceMappingURL=CurieFactory.d.ts.map

package/dist/_ShapesGraphToAstTransformer/CurieFactory.js

@@ -0,0 +1,45 @@
+import { Maybe } from "purify-ts";
+import { invariant } from "ts-invariant";
+import { Curie } from "../ast/Curie.js";
+import { logger } from "../logger.js";
+/**
+ * Factory for Compact URIs (CURIEs). Tracks whether the reference part of the CURIE is unique.
+ */
+export class CurieFactory {
+    prefixMap;
+    referenceCounts = {};
+    constructor({ prefixMap }) {
+        this.prefixMap = prefixMap;
+    }
+    create(namedNode) {
+        return Maybe.fromNullable(this.prefixMap.shrink(namedNode)?.value).map((value) => {
+            const split = value.split(":", 2);
+            invariant(split.length === 2);
+            const prefix = split[0];
+            const reference = split[1];
+            if (this.referenceCounts[reference] === undefined) {
+                this.referenceCounts[reference] = {};
+            }
+            if (this.referenceCounts[reference][prefix] === undefined) {
+                this.referenceCounts[reference][prefix] = 1;
+            }
+            else {
+                this.referenceCounts[reference][prefix] += 1;
+            }
+            return new Curie({
+                hasUniqueReference: () => {
+                    const referenceCounts = this.referenceCounts[reference];
+                    if (Object.entries(referenceCounts).length === 1) {
+                        return true;
+                    }
+                    logger.debug(`duplicate local part ${reference} in ${JSON.stringify(referenceCounts)}`);
+                    return false;
+                },
+                prefix: split[0],
+                reference: split[1],
+                value: namedNode.value,
+            });
+        });
+    }
+}
+//# sourceMappingURL=CurieFactory.js.map

package/dist/_ShapesGraphToAstTransformer/ShapeStack.d.ts

@@ -1,6 +1,6 @@
 import type { Literal, NamedNode } from "@rdfjs/types";
 import { Maybe } from "purify-ts";
-import * as input from "../input/index.js";
+import type * as input from "../input/index.js";
 export declare class ShapeStack {
     private readonly stack;
     constructor();

package/dist/_ShapesGraphToAstTransformer/ShapeStack.js

@@ -1,6 +1,5 @@
 import { Maybe } from "purify-ts";
 import { invariant } from "ts-invariant";
-import * as input from "../input/index.js";
 export class ShapeStack {
     stack = [];
     constructor() {
@@ -27,7 +26,7 @@ export class ShapeStack {
     constraints;
     get defaultValue() {
         for (const shape of this.stack.toReversed()) {
-            if (!(shape instanceof input.PropertyShape)) {
+            if (shape.kind !== "PropertyShape") {
                 continue;
             }
             if (shape.defaultValue.isJust()) {

package/dist/_ShapesGraphToAstTransformer/index.d.ts

@@ -1,10 +1,6 @@
 export * from "./NodeShapeAstType.js";
-export * from "./shapeAstName.js";
+export * from "./shapeIdentifier.js";
 export * from "./transformNodeShapeToAstType.js";
 export * from "./transformPropertyShapeToAstObjectTypeProperty.js";
-export * from "./transformShapeToAstCompositeType.js";
-export * from "./transformShapeToAstIdentifierType.js";
-export * from "./transformShapeToAstLiteralType.js";
 export * from "./transformShapeToAstType.js";
-export * from "./transformShapeToAstTermType.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/_ShapesGraphToAstTransformer/index.js

@@ -1,10 +1,6 @@
 export * from "./NodeShapeAstType.js";
-export * from "./shapeAstName.js";
+export * from "./shapeIdentifier.js";
 export * from "./transformNodeShapeToAstType.js";
 export * from "./transformPropertyShapeToAstObjectTypeProperty.js";
-export * from "./transformShapeToAstCompositeType.js";
-export * from "./transformShapeToAstIdentifierType.js";
-export * from "./transformShapeToAstLiteralType.js";
 export * from "./transformShapeToAstType.js";
-export * from "./transformShapeToAstTermType.js";
 //# sourceMappingURL=index.js.map

package/dist/_ShapesGraphToAstTransformer/nodeShapeIdentifierMintingStrategy.d.ts

@@ -0,0 +1,5 @@
+import { Either, Maybe } from "purify-ts";
+import type { IdentifierMintingStrategy } from "../enums/IdentifierMintingStrategy.js";
+import type * as input from "../input/index.js";
+export declare function nodeShapeIdentifierMintingStrategy(nodeShape: input.NodeShape): Either<Error, Maybe<IdentifierMintingStrategy>>;
+//# sourceMappingURL=nodeShapeIdentifierMintingStrategy.d.ts.map

package/dist/_ShapesGraphToAstTransformer/nodeShapeIdentifierMintingStrategy.js

@@ -0,0 +1,28 @@
+import { Either, Left, Maybe } from "purify-ts";
+import { shapeNodeKinds } from "./shapeNodeKinds.js";
+const defaultNodeShapeNodeKinds = new Set([
+    "BlankNode",
+    "IRI",
+]);
+export function nodeShapeIdentifierMintingStrategy(nodeShape) {
+    if (nodeShape.identifierMintingStrategy.isJust()) {
+        if (nodeShape.identifierIn.length > 0) {
+            return Left(new Error(`${nodeShape} cannot have an identifier minting strategy and sh:in`));
+        }
+        return Either.of(nodeShape.identifierMintingStrategy);
+    }
+    return nodeShape.ancestorNodeShapes.chain((ancestorNodeShapes) => {
+        for (const ancestorNodeShape of ancestorNodeShapes) {
+            if (ancestorNodeShape.identifierMintingStrategy.isJust()) {
+                return Either.of(ancestorNodeShape.identifierMintingStrategy);
+            }
+        }
+        return shapeNodeKinds(nodeShape, { defaultNodeShapeNodeKinds }).map((nodeKinds) => {
+            if (nodeKinds.has("BlankNode")) {
+                return Maybe.of("blankNode");
+            }
+            return Maybe.empty();
+        });
+    });
+}
+//# sourceMappingURL=nodeShapeIdentifierMintingStrategy.js.map

package/dist/_ShapesGraphToAstTransformer/nodeShapeTsFeatures.d.ts

@@ -0,0 +1,5 @@
+import { Either, type Maybe } from "purify-ts";
+import type { TsFeature } from "../enums/TsFeature.js";
+import type * as input from "../input/index.js";
+export declare function nodeShapeTsFeatures(nodeShape: input.NodeShape): Either<Error, Maybe<ReadonlySet<TsFeature>>>;
+//# sourceMappingURL=nodeShapeTsFeatures.d.ts.map

package/dist/_ShapesGraphToAstTransformer/nodeShapeTsFeatures.js

@@ -0,0 +1,8 @@
+import { Either } from "purify-ts";
+export function nodeShapeTsFeatures(nodeShape) {
+    if (nodeShape.tsFeatures.isJust()) {
+        return Either.of(nodeShape.tsFeatures);
+    }
+    return nodeShape.isDefinedBy.map((ontology) => ontology.chain((ontology) => ontology.tsFeatures));
+}
+//# sourceMappingURL=nodeShapeTsFeatures.js.map

package/dist/_ShapesGraphToAstTransformer/shapeIdentifier.d.ts

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

package/dist/_ShapesGraphToAstTransformer/shapeIdentifier.js

@@ -0,0 +1,9 @@
+export function shapeIdentifier(shape) {
+    switch (shape.identifier.termType) {
+        case "BlankNode":
+            return shape.identifier;
+        case "NamedNode":
+            return (this.curieFactory.create(shape.identifier).extract() ?? shape.identifier);
+    }
+}
+//# sourceMappingURL=shapeIdentifier.js.map

package/dist/_ShapesGraphToAstTransformer/shapeNodeKinds.d.ts

@@ -0,0 +1,8 @@
+import { NodeKind } from "@shaclmate/shacl-ast";
+import { Either } from "purify-ts";
+import type * as input from "../input/index.js";
+export declare function shapeNodeKinds(shape: input.Shape, options?: {
+    defaultNodeShapeNodeKinds: ReadonlySet<NodeKind>;
+    defaultPropertyShapeNodeKinds?: ReadonlySet<NodeKind>;
+}): Either<Error, ReadonlySet<NodeKind>>;
+//# sourceMappingURL=shapeNodeKinds.d.ts.map

package/dist/_ShapesGraphToAstTransformer/shapeNodeKinds.js

@@ -0,0 +1,175 @@
+import { NodeKind } from "@shaclmate/shacl-ast";
+import { Either, Left } from "purify-ts";
+const defaultNodeShapeNodeKinds = new Set([
+    "BlankNode",
+    "IRI",
+    "Literal",
+]);
+const defaultPropertyShapeNodeKinds = new Set([
+    "BlankNode",
+    "IRI",
+    "Literal",
+]);
+function nodeShapeNodeKinds(nodeShape) {
+    const thisNodeKinds = nodeShape.constraints.nodeKinds;
+    return nodeShape.parentNodeShapes.chain((parentNodeShapes) => {
+        const parentNodeKinds = new Set();
+        for (const parentNodeShape of parentNodeShapes) {
+            for (const parentNodeKind of parentNodeShape.constraints.nodeKinds) {
+                parentNodeKinds.add(parentNodeKind);
+            }
+        }
+        if (parentNodeKinds.size > 0) {
+            if (thisNodeKinds.size === 0) {
+                return Either.of(parentNodeKinds);
+            }
+            // Check that thisNodeKinds doesn't conflict with parent node kinds
+            for (const thisNodeKind of thisNodeKinds) {
+                if (!parentNodeKinds.has(thisNodeKind)) {
+                    return Left(new Error(`${nodeShape} has a nodeKind ${thisNodeKind} that is not in its parent's node kinds`));
+                }
+            }
+        }
+        return Either.of(thisNodeKinds);
+    });
+}
+function propertyShapeNodeKinds(propertyShape) {
+    return Either.of(propertyShape.constraints.nodeKinds);
+}
+export function shapeNodeKinds(shape, options) {
+    return (shape.kind === "NodeShape"
+        ? nodeShapeNodeKinds(shape)
+        : propertyShapeNodeKinds(shape)).chain((explicitNodeKinds) => {
+        // Consider constraints that dictate certain node kinds, like sh:datatype dictates a Literal nodeKind.
+        const constraintExcludeNodeKinds = new Set();
+        const constraintIncludeNodeKinds = new Set();
+        for (const [constraint, { excludeNodeKinds, includeNodeKinds }] of [
+            [
+                "sh:class",
+                shape.constraints.classes.length > 0
+                    ? { excludeNodeKinds: ["Literal"] }
+                    : {},
+            ],
+            [
+                "sh:datatype",
+                {
+                    includeNodeKinds: shape.constraints.datatype
+                        .map(() => ["Literal"])
+                        .orDefault([]),
+                },
+            ],
+            [
+                "sh:defaultValue",
+                {
+                    includeNodeKinds: shape.kind === "PropertyShape"
+                        ? shape.defaultValue
+                            .map((value) => NodeKind.fromTermType(value.termType))
+                            .toList()
+                        : [],
+                },
+            ],
+            [
+                "sh:hasValue",
+                {
+                    includeNodeKinds: shape.constraints.hasValues.map((value) => NodeKind.fromTermType(value.termType)),
+                },
+            ],
+            [
+                "sh:in",
+                {
+                    includeNodeKinds: shape.constraints.in_.map((in_) => NodeKind.fromTermType(in_.termType)),
+                },
+            ],
+            [
+                "sh:languageIn",
+                shape.constraints.languageIn.length > 0
+                    ? { includeNodeKinds: ["Literal"] }
+                    : {},
+            ],
+            [
+                "sh:maxExclusive",
+                {
+                    includeNodeKinds: shape.constraints.maxExclusive
+                        .map(() => ["Literal"])
+                        .orDefault([]),
+                },
+            ],
+            [
+                "sh:maxInclusive",
+                {
+                    includeNodeKinds: shape.constraints.maxInclusive
+                        .map(() => ["Literal"])
+                        .orDefault([]),
+                },
+            ],
+            [
+                "sh:minExclusive",
+                {
+                    includeNodeKinds: shape.constraints.minExclusive
+                        .map(() => ["Literal"])
+                        .orDefault([]),
+                },
+            ],
+            [
+                "sh:minInclusive",
+                {
+                    includeNodeKinds: shape.constraints.minInclusive
+                        .map(() => ["Literal"])
+                        .orDefault([]),
+                },
+            ],
+        ]) {
+            for (const excludeNodeKind of excludeNodeKinds ?? []) {
+                if (explicitNodeKinds.size > 0 &&
+                    explicitNodeKinds.has(excludeNodeKind)) {
+                    return Left(new Error(`${shape} has ${constraint} that conflicts with sh:nodeKind`));
+                }
+                constraintExcludeNodeKinds.add(excludeNodeKind);
+            }
+            for (const includeNodeKind of includeNodeKinds ?? []) {
+                if (explicitNodeKinds.size > 0 &&
+                    !explicitNodeKinds.has(includeNodeKind)) {
+                    return Left(new Error(`${shape} has ${constraint} that conflicts with sh:nodeKind`));
+                }
+                constraintIncludeNodeKinds.add(includeNodeKind);
+            }
+        }
+        if (explicitNodeKinds.size > 0) {
+            return Either.of(explicitNodeKinds);
+        }
+        // There were no explicit sh:nodeKind, try to infer the shape's node kind from the node kinds excluded and included by constraints
+        const constraintNodeKinds = new Set();
+        if (constraintIncludeNodeKinds.size > 0) {
+            // If constraints dictated/included certain node kinds be included. Add those to the set.
+            for (const constraintIncludeNodeKind of constraintIncludeNodeKinds) {
+                constraintNodeKinds.add(constraintIncludeNodeKind);
+            }
+            // Check whether other constraints' excluded node kinds conflict.
+            if (constraintExcludeNodeKinds.size > 0) {
+                for (const constraintExcludeNodeKind of constraintExcludeNodeKinds) {
+                    if (constraintIncludeNodeKinds.has(constraintExcludeNodeKind)) {
+                        return Left(new Error(`${shape} has constraints with conflicting exclude/include node kinds`));
+                    }
+                }
+            }
+        }
+        else if (constraintExcludeNodeKinds.size > 0) {
+            // No constraint dictated that certain node kinds be included, but some constraint dictated that certain node kinds be excluded.
+            // Start with all node kinds and exclude.
+            constraintNodeKinds.add("BlankNode");
+            constraintNodeKinds.add("IRI");
+            constraintNodeKinds.add("Literal");
+            for (const constraintExcludeNodeKind of constraintExcludeNodeKinds) {
+                constraintNodeKinds.delete(constraintExcludeNodeKind);
+            }
+        }
+        if (constraintNodeKinds.size > 0) {
+            return Either.of(constraintNodeKinds);
+        }
+        if (shape.kind === "NodeShape") {
+            return Either.of(options?.defaultNodeShapeNodeKinds ?? defaultNodeShapeNodeKinds);
+        }
+        return Either.of(options?.defaultPropertyShapeNodeKinds ?? defaultPropertyShapeNodeKinds);
+    });
+}
+//# sourceMappingURL=shapeNodeKinds.js.map

package/dist/_ShapesGraphToAstTransformer/transformNodeShapeToAstType.d.ts

@@ -1,9 +1,9 @@
 import { Either } from "purify-ts";
+import * as ast from "../ast/index.js";
+import type * as input from "../input/index.js";
 import type { ShapesGraphToAstTransformer } from "../ShapesGraphToAstTransformer.js";
-import type * as ast from "../ast/index.js";
-import * as input from "../input/index.js";
 import type { NodeShapeAstType } from "./NodeShapeAstType.js";
-export declare function transformNodeShapeToAstObjectCompositeType(this: ShapesGraphToAstTransformer, { export_, nodeShape, }: {
+export declare function transformNodeShapeToAstObjectCompoundType(this: ShapesGraphToAstTransformer, { export_, nodeShape, }: {
     export_: boolean;
     nodeShape: input.NodeShape;
 }): Either<Error, ast.ObjectIntersectionType | ast.ObjectUnionType>;