@shaclmate/shacl-ast 4.0.21 → 4.0.23

package/dist/AbstractShapesGraph.js

@@ -71,7 +71,7 @@ export class AbstractShapesGraph {
      */
     toDataset() {
         const dataset = datasetFactory.dataset();
-        const resourceSet = new ResourceSet(dataset);
+        const resourceSet = new ResourceSet({ dataFactory, dataset });
         for (const nodeShape of this.nodeShapes) {
             this.typeFunctions.NodeShape.$toRdfResource(nodeShape, { resourceSet });
         }
@@ -185,7 +185,10 @@ export class AbstractShapesGraph {
             else {
                 curieDataset = dataset;
             }
-            const curieResourceSet = new ResourceSet(curieDataset);
+            const curieResourceSet = new ResourceSet({
+                dataFactory,
+                dataset: curieDataset,
+            });
             return Either.encase(() => {
                 function readGraph() {
                     const graphs = new TermSet();

package/dist/generated.d.ts

@@ -1,5 +1,5 @@
 import type { BlankNode, DatasetCore, Literal, NamedNode, Quad_Graph, Variable } from "@rdfjs/types";
-import { PropertyPath as RdfjsResourcePropertyPath, Resource, ResourceSet } from "@rdfx/resource";
+import { PropertyPath as RdfxResourcePropertyPath, Resource, ResourceSet } from "@rdfx/resource";
 import { NTriplesTerm } from "@rdfx/string";
 import { Either, Maybe } from "purify-ts";
 interface $BooleanFilter {
@@ -50,7 +50,7 @@ type $PropertiesFromRdfResourceFunction<T> = (resource: Resource, options: {
     objectSet: $ObjectSet;
     preferredLanguages?: readonly string[];
 }) => Either<Error, T>;
-export type $PropertyPath = RdfjsResourcePropertyPath;
+export type $PropertyPath = RdfxResourcePropertyPath;
 export declare namespace $PropertyPath {
     type $Filter = object;
     function $filter(_filter: $Filter, _value: $PropertyPath): boolean;
@@ -58,6 +58,7 @@ export declare namespace $PropertyPath {
     const $fromRdfResourceValues: $FromRdfResourceValuesFunction<$PropertyPath>;
     const $schema: Readonly<object>;
     const $toRdfResource: $ToRdfResourceFunction<$PropertyPath>;
+    const $toString: typeof RdfxResourcePropertyPath.toString;
 }
 export interface $ShaclPropertySchema<TypeSchemaT = object> {
     readonly kind: "Shacl";
@@ -80,13 +81,13 @@ export type $ToRdfResourceFunction<T> = (value: T, options?: {
     ignoreRdfType?: boolean;
     resourceSet?: ResourceSet;
 }) => Resource;
-export type $ToRdfResourceValuesFunction<T> = (value: T, options: {
+export type $ToRdfResourceValuesFunction<ValueT, ReturnT extends BlankNode | Literal | NamedNode = BlankNode | Literal | NamedNode> = (value: ValueT, options: {
     graph?: Exclude<Quad_Graph, Variable>;
     ignoreRdfType?: boolean;
     propertyPath: $PropertyPath;
     resource: Resource;
     resourceSet: ResourceSet;
-}) => (bigint | boolean | number | string | BlankNode | Literal | NamedNode)[];
+}) => ReturnT[];
 export interface PropertyShape {
     readonly $identifier: PropertyShape.$Identifier;
     readonly $type: "PropertyShape";
@@ -589,6 +590,9 @@ export declare namespace PropertyShape {
         };
     };
     function $toRdfResource(_propertyShape: PropertyShape, options?: Parameters<$ToRdfResourceFunction<PropertyShape>>[1]): Resource;
+    function $propertiesToStrings(_propertyShape: PropertyShape): Record<string, string>;
+    function $toString(this: PropertyShape): string;
+    function $toString(_propertyShape: PropertyShape): string;
 }
 export interface PropertyGroup {
     readonly $identifier: PropertyGroup.$Identifier;
@@ -661,6 +665,9 @@ export declare namespace PropertyGroup {
         };
     };
     function $toRdfResource(_propertyGroup: PropertyGroup, options?: Parameters<$ToRdfResourceFunction<PropertyGroup>>[1]): Resource;
+    function $propertiesToStrings(_propertyGroup: PropertyGroup): Record<string, string>;
+    function $toString(this: PropertyGroup): string;
+    function $toString(_propertyGroup: PropertyGroup): string;
 }
 export interface Ontology {
     readonly $identifier: Ontology.$Identifier;
@@ -733,6 +740,9 @@ export declare namespace Ontology {
         };
     };
     function $toRdfResource(_ontology: Ontology, options?: Parameters<$ToRdfResourceFunction<Ontology>>[1]): Resource;
+    function $propertiesToStrings(_ontology: Ontology): Record<string, string>;
+    function $toString(this: Ontology): string;
+    function $toString(_ontology: Ontology): string;
 }
 export interface NodeShape {
     readonly $identifier: NodeShape.$Identifier;
@@ -1216,6 +1226,9 @@ export declare namespace NodeShape {
         };
     };
     function $toRdfResource(_nodeShape: NodeShape, options?: Parameters<$ToRdfResourceFunction<NodeShape>>[1]): Resource;
+    function $propertiesToStrings(_nodeShape: NodeShape): Record<string, string>;
+    function $toString(this: NodeShape): string;
+    function $toString(_nodeShape: NodeShape): string;
 }
 export type Shape = NodeShape | PropertyShape;
 export declare namespace Shape {
@@ -2198,7 +2211,14 @@ export declare namespace Shape {
         };
     };
     const $toRdfResource: $ToRdfResourceFunction<Shape>;
-    const $toRdfResourceValues: $ToRdfResourceValuesFunction<Shape>;
+    const $toRdfResourceValues: (value: Shape, _options: {
+        graph?: Exclude<Quad_Graph, Variable>;
+        ignoreRdfType?: boolean;
+        propertyPath: $PropertyPath;
+        resource: Resource;
+        resourceSet: ResourceSet;
+    }) => (BlankNode | NamedNode)[];
+    const $toString: (value: Shape) => string;
     function isShape(object: $Object): object is Shape;
 }
 export type $Object = NodeShape | Ontology | PropertyGroup | PropertyShape;
@@ -3018,7 +3038,14 @@ export declare namespace $Object {
         };
     };
     const $toRdfResource: $ToRdfResourceFunction<$Object>;
-    const $toRdfResourceValues: $ToRdfResourceValuesFunction<$Object>;
+    const $toRdfResourceValues: (value: $Object, _options: {
+        graph?: Exclude<Quad_Graph, Variable>;
+        ignoreRdfType?: boolean;
+        propertyPath: $PropertyPath;
+        resource: Resource;
+        resourceSet: ResourceSet;
+    }) => (BlankNode | NamedNode)[];
+    const $toString: (value: $Object) => string;
 }
 export interface $ObjectSet {
     nodeShape(identifier: NodeShape.$Identifier, options?: {

package/dist/generated.js

@@ -1,9 +1,20 @@
 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;
+    }, {});
+}
 function $filterArray(filterItem) {
     return (filter, values) => {
         for (const value of values) {
@@ -184,12 +195,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) {
@@ -1960,7 +1972,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);
@@ -2146,6 +2161,19 @@ 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),
+        });
+    }
+    PropertyShape.$propertiesToStrings = $propertiesToStrings;
+    function $toString(_propertyShape) {
+        return `PropertyShape(${JSON.stringify($propertiesToStrings((_propertyShape ?? this)))})`;
+    }
+    PropertyShape.$toString = $toString;
 })(PropertyShape || (PropertyShape = {}));
 export var PropertyGroup;
 (function (PropertyGroup) {
@@ -2330,7 +2358,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);
@@ -2344,6 +2375,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) {
@@ -2528,7 +2570,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);
@@ -2542,6 +2587,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) {
@@ -4165,7 +4221,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);
@@ -4357,6 +4416,17 @@ 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(),
+        });
+    }
+    NodeShape.$propertiesToStrings = $propertiesToStrings;
+    function $toString(_nodeShape) {
+        return `NodeShape(${JSON.stringify($propertiesToStrings((_nodeShape ?? this)))})`;
+    }
+    NodeShape.$toString = $toString;
 })(NodeShape || (NodeShape = {}));
 export var Shape;
 (function (Shape) {
@@ -4678,6 +4748,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));
     }
@@ -4859,6 +4938,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;
@@ -4874,7 +4968,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

@@ -4,9 +4,9 @@
     "@rdfjs/term-map": "~2.0.2",
     "@rdfjs/term-set": "~2.0.3",
     "@rdfjs/types": "~2.0.1",
-    "@rdfx/data-factory": "0.0.11",
-    "@rdfx/resource": "0.0.11",
-    "@rdfx/string": "0.0.11",
+    "@rdfx/data-factory": "0.0.12",
+    "@rdfx/resource": "0.0.12",
+    "@rdfx/string": "0.0.12",
     "@tpluscode/rdf-ns-builders": "~4.3.0",
     "@types/rdfjs__dataset": "~2.0.7",
     "@types/rdfjs__term-map": "~2.0.10",
@@ -44,5 +44,5 @@
   },
   "type": "module",
   "types": "./dist/index.d.ts",
-  "version": "4.0.21"
+  "version": "4.0.23"
 }