npm - @shaclmate/cli - Versions diffs - 2.0.13 → 2.0.14 - Mend

@shaclmate/cli 2.0.13 → 2.0.14

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (6) hide show

package/cli.js CHANGED Viewed

@@ -1,13 +1,15 @@
 import * as fs from "node:fs";
 import PrefixMap from "@rdfjs/prefix-map/PrefixMap";
-import { ShapesGraphToAstTransformer } from "@shaclmate/compiler/ShapesGraphToAstTransformer.js";
+import { Compiler } from "@shaclmate/compiler";
 import * as generators from "@shaclmate/compiler/generators";
-import { dashDataset } from "@shaclmate/compiler/vocabularies/dashDataset.js";
-import { ShapesGraph } from "@shaclmate/shacl-ast";
-import { array, command, multioption, oneOf, option, restPositionals, run, string, subcommands, } from "cmd-ts";
+import { command, option, restPositionals, run, string, subcommands, } from "cmd-ts";
 import { ExistingPath } from "cmd-ts/dist/esm/batteries/fs.js";
+import * as N3 from "n3";
 import { DataFactory, Parser, Store } from "n3";
 import pino from "pino";
+import SHACLValidator from "rdf-validate-shacl";
+import { dashDataset } from "./dashDataset.js";
+import { shaclShaclDataset } from "./shaclShaclDataset.js";
 const inputFilePaths = restPositionals({
     displayName: "inputFilePaths",
     description: "paths to RDF files containing SHACL shapes",
@@ -26,7 +28,7 @@ const outputFilePath = option({
     short: "o",
     type: string,
 });
-function readInput(inputFilePaths) {
+function generate({ generator, inputFilePaths, outputFilePath, }) {
     if (inputFilePaths.length === 0) {
         throw new Error("must specify at least one input shapes graph file path");
     }
@@ -49,24 +51,37 @@ function readInput(inputFilePaths) {
             iriPrefixes.push([prefix, prefixNode]);
         }));
     }
-    const shapesGraph = ShapesGraph.fromDataset(dataset);
-    return new ShapesGraphToAstTransformer({
-        iriPrefixMap: new PrefixMap(iriPrefixes, { factory: DataFactory }),
-        shapesGraph,
-    })
-        .transform()
+    const iriPrefixMap = new PrefixMap(iriPrefixes, { factory: DataFactory });
+    const validationReport = new SHACLValidator(shaclShaclDataset).validate(dataset);
+    if (!validationReport.conforms) {
+        process.stderr.write("input is not valid SHACL:\n");
+        const n3WriterPrefixes = {};
+        for (const prefixEntry of iriPrefixMap.entries()) {
+            n3WriterPrefixes[prefixEntry[0]] = prefixEntry[1].value;
+        }
+        const n3Writer = new N3.Writer({
+            format: "text/turtle",
+            prefixes: n3WriterPrefixes,
+        });
+        for (const quad of validationReport.dataset) {
+            n3Writer.addQuad(quad);
+        }
+        n3Writer.end((_error, result) => process.stderr.write(result));
+        return;
+    }
+    const output = new Compiler({ generator, iriPrefixMap }).compile(dataset);
+    output
         .ifLeft((error) => {
         throw error;
     })
-        .extract();
-}
-function writeOutput(output, outputFilePath) {
-    if (outputFilePath.length === 0) {
-        process.stdout.write(output);
-    }
-    else {
-        fs.writeFileSync(outputFilePath, output);
-    }
+        .ifRight((output) => {
+        if (outputFilePath.length === 0) {
+            process.stdout.write(output);
+        }
+        else {
+            fs.writeFileSync(outputFilePath, output);
+        }
+    });
 }
 run(subcommands({
     cmds: {
@@ -74,63 +89,15 @@ run(subcommands({
             name: "generate",
             description: "generate TypeScript for the SHACL Shapes Graph AST",
             args: {
-                dataFactoryImport: option({
-                    defaultValue: () => generators.ts.TsGenerator.Configuration.Defaults
-                        .dataFactoryImport,
-                    description: "import line to get an RDF/JS DataFactory",
-                    long: "data-factory-import",
-                    type: string,
-                }),
-                dataFactoryVariable: option({
-                    defaultValue: () => generators.ts.TsGenerator.Configuration.Defaults
-                        .dataFactoryVariable,
-                    description: "variable of the RDF/JS DataFactory that was imported",
-                    long: "data-factory-variable",
-                    type: string,
-                }),
-                features: multioption({
-                    description: "generator features to enable",
-                    long: "feature",
-                    type: array(oneOf([
-                        "class",
-                        "equals",
-                        "fromRdf",
-                        "toRdf",
-                        "sparql-graph-patterns",
-                    ])),
-                }),
                 inputFilePaths,
                 outputFilePath,
-                objectTypeDeclarationType: option({
-                    defaultValue: () => generators.ts.TsGenerator.Configuration.Defaults
-                        .objectTypeDeclarationType,
-                    long: "object-type-declaration-type",
-                    type: oneOf(["class", "interface"]),
-                }),
-                objectTypeDiscriminatorPropertyName: option({
-                    defaultValue: () => generators.ts.TsGenerator.Configuration.Defaults
-                        .objectTypeDiscriminatorPropertyName,
-                    description: "name of a property to add to generated object types to discriminate them with a string enum",
-                    long: "object-type-discriminator-property-name",
-                    type: string,
-                }),
-                objectTypeIdentifierPropertyName: option({
-                    defaultValue: () => generators.ts.TsGenerator.Configuration.Defaults
-                        .objectTypeIdentifierPropertyName,
-                    description: "name of a property to add to generated object types to discriminate them with a string enum",
-                    long: "object-type-discriminator-property-name",
-                    type: string,
-                }),
             },
-            handler: async ({ dataFactoryImport, dataFactoryVariable, features, inputFilePaths, objectTypeDeclarationType, objectTypeDiscriminatorPropertyName, objectTypeIdentifierPropertyName, outputFilePath, }) => {
-                writeOutput(new generators.ts.TsGenerator(readInput(inputFilePaths), new generators.ts.TsGenerator.Configuration({
-                    dataFactoryImport,
-                    dataFactoryVariable,
-                    features: new Set(features),
-                    objectTypeDeclarationType: objectTypeDeclarationType,
-                    objectTypeDiscriminatorPropertyName,
-                    objectTypeIdentifierPropertyName,
-                })).generate(), outputFilePath);
+            handler: async ({ inputFilePaths, outputFilePath }) => {
+                generate({
+                    generator: new generators.ts.TsGenerator(),
+                    inputFilePaths,
+                    outputFilePath,
+                });
             },
         }),
         "show-ast-json": command({
@@ -141,7 +108,11 @@ run(subcommands({
                 outputFilePath,
             },
             handler: async ({ inputFilePaths, outputFilePath }) => {
-                writeOutput(new generators.json.AstJsonGenerator(readInput(inputFilePaths)).generate(), outputFilePath);
+                generate({
+                    generator: new generators.json.AstJsonGenerator(),
+                    inputFilePaths,
+                    outputFilePath,
+                });
             },
         }),
     },

package/dashDataset.d.ts ADDED Viewed

@@ -0,0 +1,8 @@
+import type { DatasetCore } from "@rdfjs/types";
+/**
+ * A subset of DASH (https://datashapes.org/dash.html) that's added to command line inputs for convenience.
+ *
+ * Parts that don't validate with SHACL-SHACL have been excised.
+ */
+export declare const dashDataset: DatasetCore;
+//# sourceMappingURL=dashDataset.d.ts.map

package/dashDataset.js ADDED Viewed

@@ -0,0 +1,69 @@
+import { Parser, Store } from "n3";
+/**
+ * A subset of DASH (https://datashapes.org/dash.html) that's added to command line inputs for convenience.
+ *
+ * Parts that don't validate with SHACL-SHACL have been excised.
+ */
+export const dashDataset = new Store(new Parser({ format: "text/turtle" }).parse(`
+# baseURI: http://datashapes.org/dash
+# imports: http://www.w3.org/ns/shacl#
+# prefix: dash
+@prefix dash: <http://datashapes.org/dash#> .
+@prefix owl: <http://www.w3.org/2002/07/owl#> .
+@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
+@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
+@prefix sh: <http://www.w3.org/ns/shacl#> .
+@prefix tosh: <http://topbraid.org/tosh#> .
+@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .
+<http://datashapes.org/dash>
+  a owl:Ontology ;
+  rdfs:comment "DASH is a SHACL library for frequently needed features and design patterns. The constraint components in this library are 100% standards compliant and will work on any engine that fully supports SHACL." ;
+  rdfs:label "DASH Data Shapes Vocabulary" ;
+  owl:imports sh: ;
+  sh:declare [
+      sh:namespace "http://datashapes.org/dash#"^^xsd:anyURI ;
+      sh:prefix "dash" ;
+    ] ;
+  sh:declare [
+      sh:namespace "http://purl.org/dc/terms/"^^xsd:anyURI ;
+      sh:prefix "dcterms" ;
+    ] ;
+  sh:declare [
+      sh:namespace "http://www.w3.org/1999/02/22-rdf-syntax-ns#"^^xsd:anyURI ;
+      sh:prefix "rdf" ;
+    ] ;
+  sh:declare [
+      sh:namespace "http://www.w3.org/2000/01/rdf-schema#"^^xsd:anyURI ;
+      sh:prefix "rdfs" ;
+    ] ;
+  sh:declare [
+      sh:namespace "http://www.w3.org/2001/XMLSchema#"^^xsd:anyURI ;
+      sh:prefix "xsd" ;
+    ] ;
+  sh:declare [
+      sh:namespace "http://www.w3.org/2002/07/owl#"^^xsd:anyURI ;
+      sh:prefix "owl" ;
+    ] ;
+  sh:declare [
+      sh:namespace "http://www.w3.org/2004/02/skos/core#"^^xsd:anyURI ;
+      sh:prefix "skos" ;
+    ] ;
+.
+dash:StringOrLangString
+  a rdf:List ;
+  rdf:first [
+      sh:datatype xsd:string ;
+    ] ;
+  rdf:rest (
+      [
+        sh:datatype rdf:langString ;
+      ]
+    ) ;
+  rdfs:comment "An rdf:List that can be used in property constraints as value for sh:or to indicate that all values of a property must be either xsd:string or rdf:langString." ;
+  rdfs:label "String or langString" ;
+.
+`));
+//# sourceMappingURL=dashDataset.js.map

package/package.json CHANGED Viewed

@@ -3,9 +3,13 @@
     "shaclmate": "cli.js"
   },
   "dependencies": {
-    "@shaclmate/compiler": "2.0.13",
+    "@shaclmate/compiler": "2.0.14",
+    "@types/n3": "^1.21.1",
+    "@types/rdf-validate-shacl": "^0.4.7",
     "cmd-ts": "^0.13.0",
-    "pino": "^9.1.0"
+    "n3": "^1.21.3",
+    "pino": "^9.1.0",
+    "rdf-validate-shacl": "^0.5.6"
   },
   "devDependencies": {},
   "files": [
@@ -33,7 +37,8 @@
     "test:coverage": "biome check && vitest run --coverage",
     "test:watch": "vitest watch",
     "unlink": "npm unlink -g @shaclmate/cli",
-    "watch": "tsc -w --preserveWatchOutput"
+    "watch": "tsc -w --preserveWatchOutput",
+    "watch:noEmit": "tsc --noEmit -w --preserveWatchOutput"
   },
   "repository": {
     "type": "git",
@@ -41,5 +46,5 @@
   },
   "type": "module",
   "types": "index.d.ts",
-  "version": "2.0.13"
+  "version": "2.0.14"
 }

package/shaclShaclDataset.d.ts ADDED Viewed

@@ -0,0 +1,3 @@
+import type { DatasetCore } from "@rdfjs/types";
+export declare const shaclShaclDataset: DatasetCore;
+//# sourceMappingURL=shaclShaclDataset.d.ts.map

package/shaclShaclDataset.js ADDED Viewed

@@ -0,0 +1,414 @@
+import { Parser, Store } from "n3";
+export const shaclShaclDataset = new Store(new Parser({ format: "text/turtle" }).parse(`
+# baseURI: http://www.w3.org/ns/shacl-shacl#
+# A SHACL shapes graph to validate SHACL shapes graphs
+# Draft last edited 2017-04-04
+@prefix rdf:  <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
+@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
+@prefix sh:   <http://www.w3.org/ns/shacl#> .
+@prefix xsd:  <http://www.w3.org/2001/XMLSchema#> .
+@prefix shsh: <http://www.w3.org/ns/shacl-shacl#> .
+shsh:
+ rdfs:label "SHACL for SHACL"@en ;
+ rdfs:comment "This shapes graph can be used to validate SHACL shapes graphs against a subset of the syntax rules."@en ;
+ sh:declare [
+  sh:prefix "shsh" ;
+  sh:namespace "http://www.w3.org/ns/shacl-shacl#" ;
+ ] .
+shsh:ListShape
+ a sh:NodeShape ;
+ rdfs:label "List shape"@en ;
+ rdfs:comment "A shape describing well-formed RDF lists. Currently does not check for non-recursion. This could be expressed using SHACL-SPARQL."@en ;
+ rdfs:seeAlso <https://www.w3.org/TR/shacl/#syntax-rule-SHACL-list> ;
+ sh:property [
+  sh:path [ sh:zeroOrMorePath rdf:rest ] ;
+  rdfs:comment "Each list member (including this node) must be have the shape shsh:ListNodeShape."@en ;
+  sh:hasValue rdf:nil ;
+  sh:node shsh:ListNodeShape ;
+ ] .
+shsh:ListNodeShape
+ a sh:NodeShape ;
+ rdfs:label "List node shape"@en ;
+ rdfs:comment "Defines constraints on what it means for a node to be a node within a well-formed RDF list. Note that this does not check whether the rdf:rest items are also well-formed lists as this would lead to unsupported recursion."@en ;
+ sh:or ( [
+    sh:hasValue rdf:nil ;
+          sh:property [
+     sh:path rdf:first ;
+     sh:maxCount 0 ;
+    ] ;
+    sh:property [
+     sh:path rdf:rest ;
+     sh:maxCount 0 ;
+    ] ;
+   ]
+   [
+    sh:not [ sh:hasValue rdf:nil ] ;
+    sh:property [
+     sh:path rdf:first ;
+     sh:maxCount 1 ;
+     sh:minCount 1 ;
+    ] ;
+    sh:property [
+     sh:path rdf:rest ;
+     sh:maxCount 1 ;
+     sh:minCount 1 ;
+    ] ;
+   ] ) .
+shsh:ShapeShape
+ a sh:NodeShape ;
+ rdfs:label "Shape shape"@en ;
+ rdfs:comment "A shape that can be used to validate syntax rules for other shapes."@en ;
+ # See https://www.w3.org/TR/shacl/#shapes for what counts as a shape
+ sh:targetClass sh:NodeShape ;
+ sh:targetClass sh:PropertyShape ;
+ sh:targetSubjectsOf sh:targetClass, sh:targetNode, sh:targetObjectsOf, sh:targetSubjectsOf ;
+ sh:targetSubjectsOf sh:and, sh:class, sh:closed, sh:datatype, sh:disjoint, sh:equals, sh:flags, sh:hasValue,
+  sh:ignoredProperties, sh:in, sh:languageIn, sh:lessThan, sh:lessThanOrEquals, sh:maxCount, sh:maxExclusive,
+  sh:maxInclusive, sh:maxLength, sh:minCount, sh:minExclusive, sh:minInclusive, sh:minLength, sh:node, sh:nodeKind,
+  sh:not, sh:or, sh:pattern, sh:property, sh:qualifiedMaxCount, sh:qualifiedMinCount, sh:qualifiedValueShape,
+  sh:qualifiedValueShape, sh:qualifiedValueShapesDisjoint, sh:qualifiedValueShapesDisjoint, sh:sparql, sh:uniqueLang, sh:xone ;
+ sh:targetObjectsOf sh:node ;        # node-node
+ sh:targetObjectsOf sh:not ;         # not-node
+ sh:targetObjectsOf sh:property ;    # property-node
+ sh:targetObjectsOf sh:qualifiedValueShape ; # qualifiedValueShape-node
+ # Shapes are either node shapes or property shapes
+ sh:xone ( shsh:NodeShapeShape shsh:PropertyShapeShape ) ;
+ sh:property [
+  sh:path sh:targetNode ;
+  sh:nodeKind sh:IRIOrLiteral ;   # targetNode-nodeKind
+ ] ;
+ sh:property [
+  sh:path sh:targetClass ;
+  sh:nodeKind sh:IRI ;            # targetClass-nodeKind
+ ] ;
+ sh:property [
+  sh:path sh:targetSubjectsOf ;
+  sh:nodeKind sh:IRI ;            # targetSubjectsOf-nodeKind
+ ] ;
+ sh:property [
+  sh:path sh:targetObjectsOf ;
+  sh:nodeKind sh:IRI ;            # targetObjectsOf-nodeKind
+ ] ;
+ sh:or ( [ sh:not [
+    sh:class rdfs:Class ;
+    sh:or ( [ sh:class sh:NodeShape ] [ sh:class sh:PropertyShape ] )
+   ] ]
+   [ sh:nodeKind sh:IRI ]
+    ) ;                           # implicit-targetClass-nodeKind
+ sh:property [
+  sh:path sh:severity ;
+  sh:maxCount 1 ;                 # severity-maxCount
+  sh:nodeKind sh:IRI ;            # severity-nodeKind
+ ] ;
+ sh:property [
+  sh:path sh:message ;
+  sh:or ( [ sh:datatype xsd:string ] [ sh:datatype rdf:langString ] ) ;   # message-datatype
+ ] ;
+ sh:property [
+  sh:path sh:deactivated ;
+  sh:maxCount 1 ;                 # deactivated-maxCount
+  sh:in ( true false ) ;          # deactivated-datatype
+ ] ;
+ sh:property [
+  sh:path sh:and ;
+  sh:node shsh:ListShape ;        # and-node
+ ] ;
+ sh:property [
+  sh:path sh:class ;
+  sh:nodeKind sh:IRI ;            # class-nodeKind
+ ] ;
+ sh:property [
+  sh:path sh:closed ;
+  sh:datatype xsd:boolean ;       # closed-datatype
+  sh:maxCount 1 ;                 # multiple-parameters
+ ] ;
+ sh:property [
+  sh:path sh:ignoredProperties ;
+  sh:node shsh:ListShape ;        # ignoredProperties-node
+  sh:maxCount 1 ;                 # multiple-parameters
+ ] ;
+ sh:property [
+  sh:path ( sh:ignoredProperties [ sh:zeroOrMorePath rdf:rest ] rdf:first ) ;
+  sh:nodeKind sh:IRI ;            # ignoredProperties-members-nodeKind
+ ] ;
+ sh:property [
+  sh:path sh:datatype ;
+  sh:nodeKind sh:IRI ;            # datatype-nodeKind
+  sh:maxCount 1 ;                 # datatype-maxCount
+ ] ;
+ sh:property [
+  sh:path sh:disjoint ;
+  sh:nodeKind sh:IRI ;            # disjoint-nodeKind
+ ] ;
+ sh:property [
+  sh:path sh:equals ;
+  sh:nodeKind sh:IRI ;            # equals-nodeKind
+ ] ;
+ sh:property [
+  sh:path sh:in ;
+  sh:maxCount 1 ;                 # in-maxCount
+  sh:node shsh:ListShape ;        # in-node
+ ] ;
+ sh:property [
+  sh:path sh:languageIn ;
+  sh:maxCount 1 ;                 # languageIn-maxCount
+  sh:node shsh:ListShape ;        # languageIn-node
+ ] ;
+ sh:property [
+  sh:path ( sh:languageIn [ sh:zeroOrMorePath rdf:rest ] rdf:first ) ;
+  sh:datatype xsd:string ;        # languageIn-members-datatype
+ ] ;
+ sh:property [
+  sh:path sh:lessThan ;
+  sh:nodeKind sh:IRI ;            # lessThan-nodeKind
+ ] ;
+ sh:property [
+  sh:path sh:lessThanOrEquals ;
+  sh:nodeKind sh:IRI ;            # lessThanOrEquals-nodeKind
+ ] ;
+ sh:property [
+  sh:path sh:maxCount ;
+  sh:datatype xsd:integer ;       # maxCount-datatype
+  sh:maxCount 1 ;                 # maxCount-maxCount
+ ] ;
+ sh:property [
+  sh:path sh:maxExclusive ;
+  sh:maxCount 1 ;                 # maxExclusive-maxCount
+  sh:nodeKind sh:Literal ;        # maxExclusive-nodeKind
+ ] ;
+ sh:property [
+  sh:path sh:maxInclusive ;
+  sh:maxCount 1 ;                 # maxInclusive-maxCount
+  sh:nodeKind sh:Literal ;        # maxInclusive-nodeKind
+ ] ;
+ sh:property [
+  sh:path sh:maxLength ;
+  sh:datatype xsd:integer ;       # maxLength-datatype
+  sh:maxCount 1 ;                 # maxLength-maxCount
+ ] ;
+ sh:property [
+  sh:path sh:minCount ;
+  sh:datatype xsd:integer ;       # minCount-datatype
+  sh:maxCount 1 ;                 # minCount-maxCount
+ ] ;
+ sh:property [
+  sh:path sh:minExclusive ;
+  sh:maxCount 1 ;                 # minExclusive-maxCount
+  sh:nodeKind sh:Literal ;        # minExclusive-nodeKind
+ ] ;
+ sh:property [
+  sh:path sh:minInclusive ;
+  sh:maxCount 1 ;                 # minInclusive-maxCount
+  sh:nodeKind sh:Literal ;        # minInclusive-nodeKind
+ ] ;
+ sh:property [
+  sh:path sh:minLength ;
+  sh:datatype xsd:integer ;       # minLength-datatype
+  sh:maxCount 1 ;                 # minLength-maxCount
+ ] ;
+ sh:property [
+  sh:path sh:nodeKind ;
+  sh:in ( sh:BlankNode sh:IRI sh:Literal sh:BlankNodeOrIRI sh:BlankNodeOrLiteral sh:IRIOrLiteral ) ; # nodeKind-in
+  sh:maxCount 1 ;                 # nodeKind-maxCount
+ ] ;
+ sh:property [
+  sh:path sh:or ;
+  sh:node shsh:ListShape ;        # or-node
+ ] ;
+ sh:property [
+  sh:path sh:pattern ;
+  sh:datatype xsd:string ;        # pattern-datatype
+  sh:maxCount 1 ;                 # multiple-parameters
+  # Not implemented: syntax rule pattern-regex
+ ] ;
+ sh:property [
+  sh:path sh:flags ;
+  sh:datatype xsd:string ;        # flags-datatype
+  sh:maxCount 1 ;                 # multiple-parameters
+ ] ;
+ sh:property [
+  sh:path sh:qualifiedMaxCount ;
+  sh:datatype xsd:integer ;       # qualifiedMaxCount-datatype
+  sh:maxCount 1 ;                 # multiple-parameters
+ ] ;
+ sh:property [
+  sh:path sh:qualifiedMinCount ;
+  sh:datatype xsd:integer ;       # qualifiedMinCount-datatype
+  sh:maxCount 1 ;                 # multiple-parameters
+ ] ;
+ sh:property [
+  sh:path sh:qualifiedValueShape ;
+  sh:maxCount 1 ;                 # multiple-parameters
+ ] ;
+ sh:property [
+  sh:path sh:qualifiedValueShapesDisjoint ;
+  sh:datatype xsd:boolean ;       # qualifiedValueShapesDisjoint-datatype
+  sh:maxCount 1 ;                 # multiple-parameters
+ ] ;
+ sh:property [
+  sh:path sh:uniqueLang ;
+  sh:datatype xsd:boolean ;       # uniqueLang-datatype
+  sh:maxCount 1 ;                 # uniqueLang-maxCount
+ ] ;
+ sh:property [
+  sh:path sh:xone ;
+  sh:node shsh:ListShape ;        # xone-node
+ ] .
+shsh:NodeShapeShape
+ a sh:NodeShape ;
+ sh:targetObjectsOf sh:node ;        # node-node
+ sh:property [
+  sh:path sh:path ;
+  sh:maxCount 0 ;                 # NodeShape-path-maxCount
+ ] ;
+ sh:property [
+  sh:path sh:lessThan ;
+  sh:maxCount 0 ;                 # lessThan-scope
+ ] ;
+ sh:property [
+  sh:path sh:lessThanOrEquals ;
+  sh:maxCount 0 ;                 # lessThanOrEquals-scope
+ ] ;
+ sh:property [
+  sh:path sh:maxCount ;
+  sh:maxCount 0 ;                 # maxCount-scope
+ ] ;
+ sh:property [
+  sh:path sh:minCount ;
+  sh:maxCount 0 ;                 # minCount-scope
+ ] ;
+ sh:property [
+  sh:path sh:qualifiedValueShape ;
+  sh:maxCount 0 ;                 # qualifiedValueShape-scope
+ ] ;
+ sh:property [
+  sh:path sh:uniqueLang ;
+  sh:maxCount 0 ;                 # uniqueLang-scope
+ ] .
+shsh:PropertyShapeShape
+ a sh:NodeShape ;
+ sh:targetObjectsOf sh:property ;    # property-node
+ sh:property [
+  sh:path sh:path ;
+  sh:maxCount 1 ;                 # path-maxCount
+  sh:minCount 1 ;                 # PropertyShape-path-minCount
+  sh:node shsh:PathShape ;        # path-node
+ ] .
+# Values of sh:and, sh:or and sh:xone must be lists of shapes
+shsh:ShapesListShape
+ a sh:NodeShape ;
+ sh:targetObjectsOf sh:and ;         # and-members-node
+ sh:targetObjectsOf sh:or ;          # or-members-node
+ sh:targetObjectsOf sh:xone ;        # xone-members-node
+ sh:property [
+  sh:path ( [ sh:zeroOrMorePath rdf:rest ] rdf:first ) ;
+  sh:node shsh:ShapeShape ;
+ ] .
+# A path of blank node path syntax, used to simulate recursion
+_:PathPath
+ sh:alternativePath (
+  ( [ sh:zeroOrMorePath rdf:rest ] rdf:first )
+  ( sh:alternativePath [ sh:zeroOrMorePath rdf:rest ] rdf:first )
+  sh:inversePath
+  sh:zeroOrMorePath
+  sh:oneOrMorePath
+  sh:zeroOrOnePath
+ ) .
+shsh:PathShape
+ a sh:NodeShape ;
+ rdfs:label "Path shape"@en ;
+ rdfs:comment "A shape that can be used to validate the syntax rules of well-formed SHACL paths."@en ;
+ rdfs:seeAlso <https://www.w3.org/TR/shacl/#property-paths> ;
+ sh:property [
+  sh:path [ sh:zeroOrMorePath _:PathPath ] ;
+  sh:node shsh:PathNodeShape ;
+ ] .
+shsh:PathNodeShape
+ sh:xone (                           # path-metarule
+   [ sh:nodeKind sh:IRI ]          # 2.3.1.1: Predicate path
+   [ sh:nodeKind sh:BlankNode ;    # 2.3.1.2: Sequence path
+     sh:node shsh:PathListWithAtLeast2Members ;
+   ]
+   [ sh:nodeKind sh:BlankNode ;    # 2.3.1.3: Alternative path
+     sh:closed true ;
+     sh:property [
+       sh:path sh:alternativePath ;
+       sh:node shsh:PathListWithAtLeast2Members ;
+       sh:minCount 1 ;
+       sh:maxCount 1 ;
+     ]
+   ]
+   [ sh:nodeKind sh:BlankNode ;    # 2.3.1.4: Inverse path
+     sh:closed true ;
+     sh:property [
+       sh:path sh:inversePath ;
+       sh:minCount 1 ;
+       sh:maxCount 1 ;
+     ]
+   ]
+   [ sh:nodeKind sh:BlankNode ;    # 2.3.1.5: Zero-or-more path
+     sh:closed true ;
+     sh:property [
+       sh:path sh:zeroOrMorePath ;
+       sh:minCount 1 ;
+       sh:maxCount 1 ;
+     ]
+   ]
+   [ sh:nodeKind sh:BlankNode ;    # 2.3.1.6: One-or-more path
+     sh:closed true ;
+     sh:property [
+       sh:path sh:oneOrMorePath ;
+       sh:minCount 1 ;
+       sh:maxCount 1 ;
+     ]
+   ]
+   [ sh:nodeKind sh:BlankNode ;    # 2.3.1.7: Zero-or-one path
+     sh:closed true ;
+     sh:property [
+       sh:path sh:zeroOrOnePath ;
+       sh:minCount 1 ;
+       sh:maxCount 1 ;
+     ]
+   ]
+  ) .
+shsh:PathListWithAtLeast2Members
+ a sh:NodeShape ;
+ sh:node shsh:ListShape ;
+ sh:property [
+  sh:path [ sh:oneOrMorePath rdf:rest ] ;
+  sh:minCount 2 ;    # 1 other list node plus rdf:nil
+ ] .
+shsh:ShapesGraphShape
+ a sh:NodeShape ;
+ sh:targetObjectsOf sh:shapesGraph ;
+ sh:nodeKind sh:IRI .                # shapesGraph-nodeKind
+shsh:EntailmentShape
+ a sh:NodeShape ;
+ sh:targetObjectsOf sh:entailment ;
+ sh:nodeKind sh:IRI .                # entailment-nodeKind
+`));
+//# sourceMappingURL=shaclShaclDataset.js.map