@shaclmate/cli 4.0.60 → 4.0.61

package/dist/cli.js

@@ -16,7 +16,7 @@ const inputPaths = restPositionals({
 const outputFilePath = option({
     defaultValue: () => "",
     description: "path to a file to write output to; if not specified, write to stdout",
-    long: "output-path",
+    long: "output-file-path",
     short: "o",
     type: string,
 });
@@ -89,6 +89,18 @@ run(subcommands({
                             },
                         }),
                         inputPaths,
+                        objectDiscriminantPropertyJsonName: option({
+                            defaultValue: () => TsGenerator.Configuration.default_.objectDiscriminantProperty
+                                .jsonName,
+                            description: "name of the property to use to discriminate object types (in JSON)",
+                            long: "object-discriminant-property-json-name",
+                        }),
+                        objectDiscriminantPropertyName: option({
+                            defaultValue: () => TsGenerator.Configuration.default_.objectDiscriminantProperty
+                                .name,
+                            description: "name of the property to use to discriminate object types",
+                            long: "object-discriminant-property-name",
+                        }),
                         outputFilePath,
                         syntheticNamePrefix: option({
                             defaultValue: () => TsGenerator.Configuration.default_.syntheticNamePrefix,
@@ -96,11 +108,15 @@ run(subcommands({
                             long: "synthetic-name-prefix",
                         }),
                     },
-                    handler: async ({ features, inputPaths, outputFilePath, syntheticNamePrefix, }) => {
+                    handler: async ({ features, inputPaths, objectDiscriminantPropertyJsonName, objectDiscriminantPropertyName, outputFilePath, syntheticNamePrefix, }) => {
                         (await generate({
                             generator: new TsGenerator({
                                 configuration: {
                                     features: new Set(features),
+                                    objectDiscriminantProperty: {
+                                        jsonName: objectDiscriminantPropertyJsonName,
+                                        name: objectDiscriminantPropertyName,
+                                    },
                                     syntheticNamePrefix,
                                 },
                                 logger,
@@ -133,11 +149,19 @@ run(subcommands({
             args: {
                 inputPaths,
                 outputFilePath,
+                outputFormat: option({
+                    defaultValue: () => "application/n-quads",
+                    description: "output RDF format",
+                    long: "output-format",
+                    short: "f",
+                    type: string,
+                }),
             },
-            handler: async ({ inputPaths, outputFilePath }) => {
+            handler: async ({ inputPaths, outputFilePath, outputFormat }) => {
                 (await merge({
                     inputPaths,
                     outputFilePath,
+                    outputFormat,
                 })).unsafeCoerce();
             },
         }),

package/dist/commands/generate.js

@@ -1,27 +1,29 @@
 import * as fs from "node:fs";
-import Serializer from "@rdfjs/serializer-turtle";
 import { Compiler, ShapesGraph } from "@shaclmate/compiler";
 import { EitherAsync } from "purify-ts";
-import SHACLValidator from "rdf-validate-shacl";
 import { logger } from "../logger.js";
 import { parseInputs } from "../parseInputs.js";
-import { shaclShaclDataset } from "../shaclShaclDataset.js";
 export async function generate({ generator, inputPaths, outputFilePath, }) {
     return EitherAsync(async ({ liftEither }) => {
         if (inputPaths.length === 0) {
             throw new Error("must specify at least one input shapes graph file path");
         }
         const { dataset, prefixMap } = await liftEither(await parseInputs(inputPaths));
-        {
-            const validationReport = await new SHACLValidator(shaclShaclDataset, {}).validate(dataset);
-            if (!validationReport.conforms) {
-                process.stderr.write("input is not valid SHACL:\n");
-                process.stderr.write(new Serializer({
-                    prefixes: prefixMap,
-                }).transform(validationReport.dataset));
-                return;
-            }
-        }
+        // {
+        //   const validationReport = await new SHACLValidator(
+        //     shaclShaclDataset,
+        //     {},
+        //   ).validate(dataset);
+        //   if (!validationReport.conforms) {
+        //     process.stderr.write("input is not valid SHACL:\n");
+        //     process.stderr.write(
+        //       new Serializer({
+        //         prefixes: prefixMap,
+        //       }).transform(validationReport.dataset),
+        //     );
+        //     return;
+        //   }
+        // }
         const output = await liftEither(ShapesGraph.builder()
             .parseDataset(dataset, { prefixMap })
             .map((_) => _.build())

package/dist/commands/merge.d.ts

@@ -1,6 +1,7 @@
 import { type Either } from "purify-ts";
-export declare function merge({ inputPaths, outputFilePath, }: {
+export declare function merge({ inputPaths, outputFilePath, outputFormat, }: {
     inputPaths: readonly string[];
     outputFilePath: string;
+    outputFormat: string;
 }): Promise<Either<Error, void>>;
 //# sourceMappingURL=merge.d.ts.map

package/dist/commands/merge.js

@@ -1,16 +1,23 @@
 import fs from "node:fs";
-import Serializer from "@rdfjs/serializer-turtle";
+import { Readable } from "node:stream";
+import serializers from "@rdfx/serializers";
 import { EitherAsync } from "purify-ts";
 import { parseInputs } from "../parseInputs.js";
-export async function merge({ inputPaths, outputFilePath, }) {
+export async function merge({ inputPaths, outputFilePath, outputFormat, }) {
     return EitherAsync(async ({ liftEither }) => {
         const { dataset, prefixMap } = await liftEither(await parseInputs(inputPaths));
-        const output = new Serializer({ prefixes: prefixMap }).transform(dataset);
+        const outputStream = serializers({
+            prefixes: prefixMap,
+            rdfjs: { module: "ts" },
+        }).import(outputFormat, Readable.from([...dataset]));
+        if (outputStream === null) {
+            throw new RangeError(`invalid output format: ${outputFormat}`);
+        }
         if (outputFilePath.length === 0) {
-            process.stdout.write(output);
+            outputStream.pipe(process.stdout);
         }
         else {
-            await fs.promises.writeFile(outputFilePath, output);
+            outputStream.pipe(fs.createWriteStream(outputFilePath));
         }
     });
 }

package/dist/commands/validate.js

@@ -1,94 +1,37 @@
-import { spawn } from "node:child_process";
-import fs from "node:fs/promises";
-import path from "node:path";
-import Serializer from "@rdfjs/serializer-turtle";
+import { ZazukoValidator } from "@shaclmate/validator";
+import { JenaValidator } from "@shaclmate/validator/JenaValidator";
+import { PyShaclValidator } from "@shaclmate/validator/PyShaclValidator";
 import { EitherAsync } from "purify-ts";
-import SHACLValidator from "rdf-validate-shacl";
-import * as tmp from "tmp-promise";
-import which from "which";
 import { logger } from "../logger.js";
 import { parseInputs } from "../parseInputs.js";
-function execFileStreaming(cmd, args) {
-    return new Promise((resolve) => {
-        const child = spawn(cmd, args, { stdio: "inherit" });
-        child.on("close", (code) => {
-            resolve(code);
-        });
-    });
-}
 export async function validate({ dataGraphPaths, shapesGraphPaths, }) {
     return EitherAsync(async ({ liftEither }) => {
-        const { dataset: dataGraphDataset, prefixMap: dataGraphPrefixMap } = await liftEither(await parseInputs(dataGraphPaths));
-        if (dataGraphDataset.size === 0) {
+        const { dataset: dataGraph, prefixMap } = await liftEither(await parseInputs(dataGraphPaths));
+        if (dataGraph.size === 0) {
             throw new Error("data graph is empty!");
         }
-        logger.info("data graph size: %d", dataGraphDataset.size);
-        const { dataset: shapesGraphDataset } = await liftEither(await parseInputs(shapesGraphPaths));
-        if (shapesGraphDataset.size === 0) {
+        logger.debug("data graph size: %d", dataGraph.size);
+        const { dataset: shapesGraph } = await liftEither(await parseInputs(shapesGraphPaths));
+        if (shapesGraph.size === 0) {
             throw new Error("shapes graph is empty!");
         }
-        logger.info("shapes graph size: %d", shapesGraphDataset.size);
-        const serializer = new Serializer({
-            prefixes: dataGraphPrefixMap,
-        });
-        logger.info("validating with rdf-shacl-validate");
-        const validationReport = await new SHACLValidator(shapesGraphDataset, {}).validate(dataGraphDataset);
-        if (validationReport.conforms) {
-            logger.info("validated with rdf-shacl-validate: conforms");
-        }
-        else {
-            logger.info("validated with rdf-shacl-validate: does not conform");
-            process.stderr.write(serializer.transform(validationReport.dataset));
-            return;
-        }
-        const jenaShaclFilePath = await which("shacl", { nothrow: true });
-        const pyshaclFilePath = await which("pyshacl", { nothrow: true });
-        if (jenaShaclFilePath === null && pyshaclFilePath === null) {
-            logger.debug("neither Jena nor pyshacl found on PATH");
-            return;
-        }
-        await tmp.withDir(async ({ path: tmpDirectoryPath }) => {
-            const dataGraphFilePath = path.join(tmpDirectoryPath, "data.ttl");
-            logger.debug("writing data graph to %s", dataGraphFilePath);
-            await fs.writeFile(dataGraphFilePath, serializer.transform(dataGraphDataset));
-            logger.debug("wrote data graph to %s", dataGraphFilePath);
-            const shapesGraphFilePath = path.join(tmpDirectoryPath, "shapes.ttl");
-            logger.debug("writing shapes graph to %s", shapesGraphFilePath);
-            await fs.writeFile(shapesGraphFilePath, serializer.transform(shapesGraphDataset));
-            logger.debug("wrote shapes graph to %s", shapesGraphFilePath);
-            if (jenaShaclFilePath !== null) {
-                const args = [
-                    "validate",
-                    "--data",
-                    dataGraphFilePath,
-                    "--shapes",
-                    shapesGraphFilePath,
-                ];
-                logger.info("validating with Jena (args=%s)", args);
-                const code = await execFileStreaming(jenaShaclFilePath, args);
-                logger.info("validated with Jena: %s", code === 0 ? "conforms" : "does not conform");
-                if (code !== 0) {
-                    return;
-                }
-            }
-            else {
-                logger.info("Jena not found on PATH, skipping");
+        logger.debug("shapes graph size: %d", shapesGraph.size);
+        for (const [validatorId, validator] of Object.entries({
+            zazuko: new ZazukoValidator({ logger, prefixMap, shapesGraph }),
+            jena: (await liftEither(await JenaValidator.create({ logger, prefixMap, shapesGraph }))).extractNullable(),
+            pyshacl: (await liftEither(await PyShaclValidator.create({ logger, prefixMap, shapesGraph }))).extractNullable(),
+        })) {
+            if (validator === null) {
+                continue;
             }
-            if (pyshaclFilePath !== null) {
-                const args = ["-s", shapesGraphFilePath, dataGraphFilePath];
-                logger.info("validating with pyshacl (args=%s)", args);
-                const code = await execFileStreaming(pyshaclFilePath, args);
-                logger.info("validated with pyshacl: %s", code === 0 ? "conforms" : "does not conform");
-                if (code !== 0) {
-                    return;
-                }
+            logger.debug("validating with %s", validatorId);
+            const validationReport = await liftEither(await validator.validate(dataGraph));
+            if (!validationReport.conforms) {
+                logger.warn(validationReport.toString());
+                process.exit(1);
             }
-            else {
-                logger.info("pyshacl not found on PATH, skipping");
-            }
-        }, {
-            unsafeCleanup: true,
-        });
+            logger.info("validated with %s", validatorId);
+        }
     });
 }
 //# sourceMappingURL=validate.js.map

package/dist/index.d.ts

@@ -1,5 +1,4 @@
 export * as commands from "./commands/index.js";
 export * from "./logger.js";
 export * from "./parseInputs.js";
-export * from "./shaclShaclDataset.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1,5 +1,4 @@
 export * as commands from "./commands/index.js";
 export * from "./logger.js";
 export * from "./parseInputs.js";
-export * from "./shaclShaclDataset.js";
 //# sourceMappingURL=index.js.map

package/dist/logger.d.ts

@@ -1,2 +1,3 @@
-export declare const logger: import("pino").Logger<never>;
+import type { Logger } from "ts-log";
+export declare const logger: Logger;
 //# sourceMappingURL=logger.d.ts.map

package/dist/parseInputs.d.ts

@@ -1,6 +1,6 @@
 import PrefixMap from "@rdfjs/prefix-map/PrefixMap.js";
 import type { DatasetCore } from "@rdfjs/types";
-import { Either } from "purify-ts";
+import { type Either } from "purify-ts";
 export declare function parseInputs(inputPaths: readonly string[]): Promise<Either<Error, {
     dataset: DatasetCore;
     prefixMap: PrefixMap;

package/dist/parseInputs.js

@@ -1,48 +1,19 @@
 import datasetFactory from "@rdfjs/dataset";
 import PrefixMap from "@rdfjs/prefix-map/PrefixMap.js";
 import dataFactory from "@rdfx/data-factory";
-import { RdfDirectory, RdfFileSystemEntry } from "@rdfx/fs";
-import { Either, EitherAsync, Left } from "purify-ts";
+import { RdfFileSystemEntry } from "@rdfx/fs";
+import { EitherAsync } from "purify-ts";
 import { logger } from "./logger.js";
 export async function parseInputs(inputPaths) {
     return EitherAsync(async ({ liftEither }) => {
         const dataset = datasetFactory.dataset();
-        const prefixMapInit = [];
+        const prefixMap = new PrefixMap(undefined, { factory: dataFactory });
         for (const inputPath of inputPaths) {
-            const parseInputFileSystemEntry = async (inputFileSystemEntry) => {
-                if (inputFileSystemEntry instanceof RdfDirectory) {
-                    for await (const file of inputFileSystemEntry.files({
-                        recursive: true,
-                    })) {
-                        await parseInputFileSystemEntry(file);
-                    }
-                    return;
-                }
-                const inputFile = inputFileSystemEntry;
-                await liftEither(await new Promise((resolve) => {
-                    const inputQuadStream = inputFile.parse();
-                    inputQuadStream.on("data", (quad) => dataset.add(quad));
-                    inputQuadStream.on("end", () => resolve(Either.of(null)));
-                    inputQuadStream.on("error", (error) => resolve(Left(error)));
-                    inputQuadStream.on("prefix", (prefix, prefixNode) => {
-                        const existingPrefixMapEntry = prefixMapInit.find((prefixMapEntry) => prefixMapEntry[0] === prefix ||
-                            prefixMapEntry[1].equals(prefixNode));
-                        if (existingPrefixMapEntry) {
-                            if (existingPrefixMapEntry[0] !== prefix ||
-                                !existingPrefixMapEntry[1].equals(prefixNode)) {
-                                logger.warn("conflicting prefix %s: %s", prefix, prefixNode.value);
-                            }
-                            return;
-                        }
-                        prefixMapInit.push([prefix, prefixNode]);
-                    });
-                }));
-            };
-            await parseInputFileSystemEntry(await liftEither(await RdfFileSystemEntry.fromPath(inputPath)));
+            await liftEither(await (await liftEither(await RdfFileSystemEntry.fromPath(inputPath, { logger }))).parseInto(dataset, { prefixMap, recursive: true }));
         }
         return {
             dataset,
-            prefixMap: new PrefixMap(prefixMapInit, { factory: dataFactory }),
+            prefixMap,
         };
     });
 }

package/package.json

@@ -3,26 +3,24 @@
     "shaclmate": "dist/cli.js"
   },
   "dependencies": {
-    "@shaclmate/compiler": "4.0.60",
+    "@shaclmate/compiler": "4.0.61",
+    "@shaclmate/validator": "4.0.61",
     "@rdfjs/dataset": "~2.0.2",
     "@rdfjs/prefix-map": "~0.1.2",
-    "@rdfjs/serializer-turtle": "~1.1.5",
     "@rdfx/data-factory": "0.0.30",
     "@rdfx/fs": "0.0.30",
+    "@rdfx/serializers": "0.0.30",
     "cmd-ts": "~0.15.0",
     "pino": "~9.1.0",
     "pino-pretty": "~13.1.2",
     "purify-ts": "~2.1.4",
-    "rdf-validate-shacl": "0.6.5",
-    "tmp-promise": "~3.0.3",
-    "which": "~6.0.1"
+    "ts-log": "~3.0.2"
   },
   "description": "Command line program to generate TypeScript code from SHACL shapes",
   "devDependencies": {
     "@rdfjs/types": "~2.0.1",
     "@types/rdfjs__dataset": "~2.0.7",
-    "@types/rdfjs__prefix-map": "~0.1.5",
-    "@types/which": "~3.0.4"
+    "@types/rdfjs__prefix-map": "~0.1.5"
   },
   "files": [
     "README.md",
@@ -41,9 +39,7 @@
     "dist/logger.d.ts",
     "dist/logger.js",
     "dist/parseInputs.d.ts",
-    "dist/parseInputs.js",
-    "dist/shaclShaclDataset.d.ts",
-    "dist/shaclShaclDataset.js"
+    "dist/parseInputs.js"
   ],
   "homepage": "https://github.com/minorg/shaclmate",
   "keywords": [
@@ -69,5 +65,5 @@
   },
   "type": "module",
   "types": "./dist/index.d.ts",
-  "version": "4.0.60"
+  "version": "4.0.61"
 }

package/dist/shaclShaclDataset.d.ts

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

package/dist/shaclShaclDataset.js

@@ -1,414 +0,0 @@
-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