@shaclmate/compiler 4.0.21 → 4.0.23

package/dist/input/generated.js

@@ -1,9 +1,34 @@
 import datasetFactory from "@rdfjs/dataset";
 import dataFactory from "@rdfx/data-factory";
 import { LiteralFactory } from "@rdfx/literal";
-import { PropertyPath as RdfjsResourcePropertyPath, Resource, ResourceSet, } from "@rdfx/resource";
+import { PropertyPath as RdfxResourcePropertyPath, Resource, ResourceSet, } from "@rdfx/resource";
 import { NTriplesIdentifier, NTriplesTerm } from "@rdfx/string";
 import { Either, Left, Maybe, Right } from "purify-ts";
+/**
+ * Remove undefined values from a record.
+ */
+function $compactRecord(record) {
+    return Object.entries(record).reduce((definedProperties, [propertyName, propertyValue]) => {
+        if (propertyValue !== undefined) {
+            definedProperties[propertyName] = propertyValue;
+        }
+        return definedProperties;
+    }, {});
+}
+export var $EqualsResult;
+(function ($EqualsResult) {
+    $EqualsResult.Equal = Right(true);
+    function fromBooleanEqualsResult(left, right, equalsResult) {
+        if (typeof equalsResult !== "boolean") {
+            return equalsResult;
+        }
+        if (equalsResult) {
+            return $EqualsResult.Equal;
+        }
+        return Left({ left, right, type: "boolean" });
+    }
+    $EqualsResult.fromBooleanEqualsResult = fromBooleanEqualsResult;
+})($EqualsResult || ($EqualsResult = {}));
 function $filterArray(filterItem) {
     return (filter, values) => {
         for (const value of values) {
@@ -184,12 +209,13 @@ export var $PropertyPath;
         return true;
     }
     $PropertyPath.$filter = $filter;
-    $PropertyPath.$fromRdfResource = RdfjsResourcePropertyPath.fromResource;
+    $PropertyPath.$fromRdfResource = RdfxResourcePropertyPath.fromResource;
     $PropertyPath.$fromRdfResourceValues = (values, options) => values.chain((values) => values.chainMap((value) => value
         .toResource()
         .chain((resource) => $PropertyPath.$fromRdfResource(resource, options))));
     $PropertyPath.$schema = {};
-    $PropertyPath.$toRdfResource = RdfjsResourcePropertyPath.toResource;
+    $PropertyPath.$toRdfResource = RdfxResourcePropertyPath.toResource;
+    $PropertyPath.$toString = RdfxResourcePropertyPath.toString;
 })($PropertyPath || ($PropertyPath = {}));
 var $RdfVocabularies;
 (function ($RdfVocabularies) {
@@ -232,6 +258,12 @@ var $RdfVocabularies;
 function $shaclPropertyFromRdf({ graph, propertySchema, resource, typeFromRdf, }) {
     return typeFromRdf(Right(resource.values(propertySchema.path, { graph, unique: true }))).chain((values) => values.head());
 }
+/**
+ * Compare two values for strict equality (===), returning an $EqualsResult rather than a boolean.
+ */
+function $strictEquals(left, right) {
+    return $EqualsResult.fromBooleanEqualsResult(left, right, left === right);
+}
 export var PropertyShape;
 (function (PropertyShape) {
     function $create(parameters) {
@@ -362,6 +394,16 @@ export var PropertyShape;
         else {
             description = parameters.description;
         }
+        let display;
+        if (typeof parameters.display === "boolean") {
+            display = parameters.display;
+        }
+        else if (parameters.display === undefined) {
+            display = false;
+        }
+        else {
+            display = parameters.display;
+        }
         let flags;
         if (parameters.flags === undefined) {
             flags = [];
@@ -834,6 +876,7 @@ export var PropertyShape;
             deactivated,
             defaultValue,
             description,
+            display,
             flags,
             groups,
             hasValues,
@@ -904,6 +947,10 @@ export var PropertyShape;
             !$filterMaybe($filterString)(filter.description, value.description)) {
             return false;
         }
+        if (filter.display !== undefined &&
+            !$filterBoolean(filter.display, value.display)) {
+            return false;
+        }
         if (filter.flags !== undefined &&
             !$filterArray($filterString)(filter.flags, value.flags)) {
             return false;
@@ -1193,6 +1240,21 @@ export var PropertyShape;
                     value: Maybe.empty(),
                 })),
         }).chain((description) => $shaclPropertyFromRdf({
+            graph: _$options.graph,
+            resource: $resource,
+            propertySchema: PropertyShape.$schema.properties.display,
+            typeFromRdf: (resourceValues) => resourceValues
+                .map((values) => values.length > 0
+                ? values
+                : new Resource.Value({
+                    dataFactory: dataFactory,
+                    focusResource: $resource,
+                    propertyPath: PropertyShape.$schema.properties
+                        .display.path,
+                    term: dataFactory.literal("false", $RdfVocabularies.xsd.boolean),
+                }).toValues())
+                .chain((values) => values.chainMap((value) => value.toBoolean())),
+        }).chain((display) => $shaclPropertyFromRdf({
             graph: _$options.graph,
             resource: $resource,
             propertySchema: PropertyShape.$schema.properties.flags,
@@ -1215,8 +1277,8 @@ export var PropertyShape;
                 .map((values) => values.toArray())
                 .map((valuesArray) => Resource.Values.fromValue({
                 focusResource: $resource,
-                propertyPath: PropertyShape.$schema.properties.groups
-                    .path,
+                propertyPath: PropertyShape.$schema.properties
+                    .groups.path,
                 value: valuesArray,
             })),
         }).chain((groups) => $shaclPropertyFromRdf({
@@ -1257,8 +1319,8 @@ export var PropertyShape;
             })))
                 .chain((valueLists) => valueLists.chainMap((valueList) => Right(Resource.Values.fromArray({
                 focusResource: $resource,
-                propertyPath: PropertyShape.$schema.properties
-                    .in_.path,
+                propertyPath: PropertyShape.$schema
+                    .properties.in_.path,
                 values: valueList.toArray(),
             })).chain((values) => values.chainMap((value) => value.toTerm().chain((term) => {
                 switch (term.termType) {
@@ -1282,8 +1344,8 @@ export var PropertyShape;
                 ? values.map((value) => Maybe.of(value))
                 : Resource.Values.fromValue({
                     focusResource: $resource,
-                    propertyPath: PropertyShape.$schema.properties
-                        .in_.path,
+                    propertyPath: PropertyShape.$schema
+                        .properties.in_.path,
                     value: Maybe.empty(),
                 })),
         }).chain((in_) => $shaclPropertyFromRdf({
@@ -1326,9 +1388,10 @@ export var PropertyShape;
             })))
                 .chain((valueLists) => valueLists.chainMap((valueList) => Right(Resource.Values.fromArray({
                 focusResource: $resource,
-                propertyPath: PropertyShape.$schema
-                    .properties.languageIn
-                    .path,
+                propertyPath: PropertyShape
+                    .$schema
+                    .properties
+                    .languageIn.path,
                 values: valueList.toArray(),
             }))
                 .chain((values) => $fromRdfPreferredLanguages(values, _$options.preferredLanguages))
@@ -1369,15 +1432,18 @@ export var PropertyShape;
                 ? values.map((value) => Maybe.of(value))
                 : Resource.Values.fromValue({
                     focusResource: $resource,
-                    propertyPath: PropertyShape.$schema
+                    propertyPath: PropertyShape
+                        .$schema
                         .properties
-                        .maxExclusive.path,
+                        .maxExclusive
+                        .path,
                     value: Maybe.empty(),
                 })),
         }).chain((maxExclusive) => $shaclPropertyFromRdf({
             graph: _$options.graph,
             resource: $resource,
-            propertySchema: PropertyShape.$schema.properties.maxInclusive,
+            propertySchema: PropertyShape.$schema.properties
+                .maxInclusive,
             typeFromRdf: (resourceValues) => resourceValues
                 .chain((values) => $fromRdfPreferredLanguages(values, _$options.preferredLanguages))
                 .chain((values) => values.chainMap((value) => value.toLiteral()))
@@ -1395,7 +1461,8 @@ export var PropertyShape;
         }).chain((maxInclusive) => $shaclPropertyFromRdf({
             graph: _$options.graph,
             resource: $resource,
-            propertySchema: PropertyShape.$schema.properties.maxLength,
+            propertySchema: PropertyShape.$schema.properties
+                .maxLength,
             typeFromRdf: (resourceValues) => resourceValues
                 .chain((values) => values.chainMap((value) => value.toInt()))
                 .map((values) => values.length > 0
@@ -1405,13 +1472,15 @@ export var PropertyShape;
                     propertyPath: PropertyShape
                         .$schema
                         .properties
-                        .maxLength.path,
+                        .maxLength
+                        .path,
                     value: Maybe.empty(),
                 })),
         }).chain((maxLength) => $shaclPropertyFromRdf({
             graph: _$options.graph,
             resource: $resource,
-            propertySchema: PropertyShape.$schema.properties.minCount,
+            propertySchema: PropertyShape.$schema.properties
+                .minCount,
             typeFromRdf: (resourceValues) => resourceValues
                 .chain((values) => values.chainMap((value) => value.toInt()))
                 .map((values) => values.length > 0
@@ -1470,7 +1539,8 @@ export var PropertyShape;
                 .minLength,
             typeFromRdf: (resourceValues) => resourceValues
                 .chain((values) => values.chainMap((value) => value.toInt()))
-                .map((values) => values.length > 0
+                .map((values) => values.length >
+                0
                 ? values.map((value) => Maybe.of(value))
                 : Resource.Values.fromValue({
                     focusResource: $resource,
@@ -1484,7 +1554,8 @@ export var PropertyShape;
         }).chain((minLength) => $shaclPropertyFromRdf({
             graph: _$options.graph,
             resource: $resource,
-            propertySchema: PropertyShape.$schema.properties
+            propertySchema: PropertyShape.$schema
+                .properties
                 .mutable,
             typeFromRdf: (resourceValues) => resourceValues
                 .chain((values) => values.chainMap((value) => value.toBoolean()))
@@ -1801,6 +1872,7 @@ export var PropertyShape;
             deactivated,
             defaultValue,
             description,
+            display,
             flags,
             groups,
             hasValues,
@@ -1830,7 +1902,7 @@ export var PropertyShape;
             uniqueLang,
             visibility,
             xone,
-        }))))))))))))))))))))))))))))))))))))))));
+        })))))))))))))))))))))))))))))))))))))))));
     };
     PropertyShape.$schema = {
         properties: {
@@ -1904,6 +1976,15 @@ export var PropertyShape;
                 }),
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#description"),
             },
+            display: {
+                kind: "Shacl",
+                type: () => ({
+                    kind: "DefaultValue",
+                    item: () => ({ kind: "Boolean" }),
+                    defaultValue: dataFactory.literal("false", $RdfVocabularies.xsd.boolean),
+                }),
+                path: dataFactory.namedNode("http://purl.org/shaclmate/ontology#display"),
+            },
             flags: {
                 kind: "Shacl",
                 type: () => ({
@@ -2166,7 +2247,10 @@ export var PropertyShape;
     };
     function $toRdfResource(_propertyShape, options) {
         const resourceSet = options?.resourceSet ??
-            new ResourceSet(datasetFactory.dataset(), { dataFactory: dataFactory });
+            new ResourceSet({
+                dataFactory: dataFactory,
+                dataset: datasetFactory.dataset(),
+            });
         const resource = resourceSet.resource(_propertyShape.$identifier);
         if (!options?.ignoreRdfType) {
             resource.add($RdfVocabularies.rdf.type, dataFactory.namedNode("http://www.w3.org/ns/shacl#PropertyShape"), options?.graph);
@@ -2207,6 +2291,11 @@ export var PropertyShape;
         resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#description"), _propertyShape.description
             .toList()
             .flatMap((value) => [$literalFactory.string(value)]), options?.graph);
+        resource.add(dataFactory.namedNode("http://purl.org/shaclmate/ontology#display"), $strictEquals(_propertyShape.display, false).isLeft()
+            ? [
+                $literalFactory.boolean(_propertyShape.display, $RdfVocabularies.xsd.boolean),
+            ]
+            : [], options?.graph);
         resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#flags"), _propertyShape.flags.flatMap((item) => [$literalFactory.string(item)]), options?.graph);
         resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#group"), _propertyShape.groups.flatMap((item) => [item]), options?.graph);
         resource.add(dataFactory.namedNode("http://www.w3.org/ns/shacl#hasValue"), _propertyShape.hasValues.flatMap((item) => [item]), options?.graph);
@@ -2362,6 +2451,22 @@ export var PropertyShape;
         return resource;
     }
     PropertyShape.$toRdfResource = $toRdfResource;
+    function $propertiesToStrings(_propertyShape) {
+        return $compactRecord({
+            $identifier: _propertyShape.$identifier.toString(),
+            label: _propertyShape.label.map((item) => item.toString()).extract(),
+            name: _propertyShape.name.map((item) => item.toString()).extract(),
+            path: $PropertyPath.$toString(_propertyShape.path),
+            shaclmateName: _propertyShape.shaclmateName
+                .map((item) => item.toString())
+                .extract(),
+        });
+    }
+    PropertyShape.$propertiesToStrings = $propertiesToStrings;
+    function $toString(_propertyShape) {
+        return `PropertyShape(${JSON.stringify($propertiesToStrings((_propertyShape ?? this)))})`;
+    }
+    PropertyShape.$toString = $toString;
 })(PropertyShape || (PropertyShape = {}));
 export var PropertyGroup;
 (function (PropertyGroup) {
@@ -2546,7 +2651,10 @@ export var PropertyGroup;
     };
     function $toRdfResource(_propertyGroup, options) {
         const resourceSet = options?.resourceSet ??
-            new ResourceSet(datasetFactory.dataset(), { dataFactory: dataFactory });
+            new ResourceSet({
+                dataFactory: dataFactory,
+                dataset: datasetFactory.dataset(),
+            });
         const resource = resourceSet.resource(_propertyGroup.$identifier);
         if (!options?.ignoreRdfType) {
             resource.add($RdfVocabularies.rdf.type, dataFactory.namedNode("http://www.w3.org/ns/shacl#PropertyGroup"), options?.graph);
@@ -2560,6 +2668,17 @@ export var PropertyGroup;
         return resource;
     }
     PropertyGroup.$toRdfResource = $toRdfResource;
+    function $propertiesToStrings(_propertyGroup) {
+        return $compactRecord({
+            $identifier: _propertyGroup.$identifier.toString(),
+            label: _propertyGroup.label.map((item) => item.toString()).extract(),
+        });
+    }
+    PropertyGroup.$propertiesToStrings = $propertiesToStrings;
+    function $toString(_propertyGroup) {
+        return `PropertyGroup(${JSON.stringify($propertiesToStrings((_propertyGroup ?? this)))})`;
+    }
+    PropertyGroup.$toString = $toString;
 })(PropertyGroup || (PropertyGroup = {}));
 export var Ontology;
 (function (Ontology) {
@@ -2974,7 +3093,10 @@ export var Ontology;
     };
     function $toRdfResource(_ontology, options) {
         const resourceSet = options?.resourceSet ??
-            new ResourceSet(datasetFactory.dataset(), { dataFactory: dataFactory });
+            new ResourceSet({
+                dataFactory: dataFactory,
+                dataset: datasetFactory.dataset(),
+            });
         const resource = resourceSet.resource(_ontology.$identifier);
         if (!options?.ignoreRdfType) {
             resource.add($RdfVocabularies.rdf.type, dataFactory.namedNode("http://www.w3.org/2002/07/owl#Ontology"), options?.graph);
@@ -2992,6 +3114,17 @@ export var Ontology;
         return resource;
     }
     Ontology.$toRdfResource = $toRdfResource;
+    function $propertiesToStrings(_ontology) {
+        return $compactRecord({
+            $identifier: _ontology.$identifier.toString(),
+            label: _ontology.label.map((item) => item.toString()).extract(),
+        });
+    }
+    Ontology.$propertiesToStrings = $propertiesToStrings;
+    function $toString(_ontology) {
+        return `Ontology(${JSON.stringify($propertiesToStrings((_ontology ?? this)))})`;
+    }
+    Ontology.$toString = $toString;
 })(Ontology || (Ontology = {}));
 export var NodeShape;
 (function (NodeShape) {
@@ -5315,7 +5448,10 @@ export var NodeShape;
     };
     function $toRdfResource(_nodeShape, options) {
         const resourceSet = options?.resourceSet ??
-            new ResourceSet(datasetFactory.dataset(), { dataFactory: dataFactory });
+            new ResourceSet({
+                dataFactory: dataFactory,
+                dataset: datasetFactory.dataset(),
+            });
         const resource = resourceSet.resource(_nodeShape.$identifier);
         if (!options?.ignoreRdfType) {
             resource.add($RdfVocabularies.rdf.type, dataFactory.namedNode("http://www.w3.org/ns/shacl#NodeShape"), options?.graph);
@@ -5536,6 +5672,20 @@ export var NodeShape;
         return resource;
     }
     NodeShape.$toRdfResource = $toRdfResource;
+    function $propertiesToStrings(_nodeShape) {
+        return $compactRecord({
+            $identifier: _nodeShape.$identifier.toString(),
+            label: _nodeShape.label.map((item) => item.toString()).extract(),
+            shaclmateName: _nodeShape.shaclmateName
+                .map((item) => item.toString())
+                .extract(),
+        });
+    }
+    NodeShape.$propertiesToStrings = $propertiesToStrings;
+    function $toString(_nodeShape) {
+        return `NodeShape(${JSON.stringify($propertiesToStrings((_nodeShape ?? this)))})`;
+    }
+    NodeShape.$toString = $toString;
 })(NodeShape || (NodeShape = {}));
 export var Shape;
 (function (Shape) {
@@ -5873,6 +6023,15 @@ export var Shape;
         }
         throw new Error("unable to serialize to RDF");
     });
+    Shape.$toString = (value) => {
+        if (NodeShape.isNodeShape(value)) {
+            return NodeShape.$toString(value);
+        }
+        if (PropertyShape.isPropertyShape(value)) {
+            return PropertyShape.$toString(value);
+        }
+        throw new Error("unable to serialize to string");
+    };
     function isShape(object) {
         return (NodeShape.isNodeShape(object) || PropertyShape.isPropertyShape(object));
     }
@@ -6054,6 +6213,21 @@ export var $Object;
         }
         throw new Error("unable to serialize to RDF");
     });
+    $Object.$toString = (value) => {
+        if (NodeShape.isNodeShape(value)) {
+            return NodeShape.$toString(value);
+        }
+        if (Ontology.isOntology(value)) {
+            return Ontology.$toString(value);
+        }
+        if (PropertyGroup.isPropertyGroup(value)) {
+            return PropertyGroup.$toString(value);
+        }
+        if (PropertyShape.isPropertyShape(value)) {
+            return PropertyShape.$toString(value);
+        }
+        throw new Error("unable to serialize to string");
+    };
 })($Object || ($Object = {}));
 export class $RdfjsDatasetObjectSet {
     $graph;
@@ -6069,7 +6243,10 @@ export class $RdfjsDatasetObjectSet {
         return this.#dataset();
     }
     $resourceSet() {
-        return new ResourceSet(this.$dataset(), { dataFactory: dataFactory });
+        return new ResourceSet({
+            dataFactory: dataFactory,
+            dataset: this.$dataset(),
+        });
     }
     async nodeShape(identifier, options) {
         return this.nodeShapeSync(identifier, options);

package/package.json

@@ -1,15 +1,15 @@
 {
   "dependencies": {
-    "@shaclmate/shacl-ast": "4.0.21",
+    "@shaclmate/shacl-ast": "4.0.23",
     "@rdfjs/dataset": "~2.0.2",
     "@rdfjs/prefix-map": "~0.1.2",
     "@rdfjs/term-map": "~2.0.2",
     "@rdfjs/term-set": "~2.0.3",
     "@rdfjs/types": "~2.0.1",
-    "@rdfx/data-factory": "0.0.11",
-    "@rdfx/literal": "0.0.11",
-    "@rdfx/resource": "0.0.11",
-    "@rdfx/string": "0.0.11",
+    "@rdfx/data-factory": "0.0.12",
+    "@rdfx/literal": "0.0.12",
+    "@rdfx/resource": "0.0.12",
+    "@rdfx/string": "0.0.12",
     "@sindresorhus/base62": "~0.1.0",
     "@tpluscode/rdf-ns-builders": "~4.3.0",
     "@types/rdfjs__dataset": "~2.0.7",
@@ -70,5 +70,5 @@
   },
   "type": "module",
   "types": "./dist/index.d.ts",
-  "version": "4.0.21"
+  "version": "4.0.23"
 }