@shaclmate/shacl-ast 4.0.22 → 4.0.23

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";
@@ -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 {
@@ -2205,6 +2218,7 @@ export declare namespace Shape {
         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;
@@ -3031,6 +3045,7 @@ export declare namespace $Object {
         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) {
@@ -2149,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) {
@@ -2350,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) {
@@ -2551,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) {
@@ -4369,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) {
@@ -4690,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));
     }
@@ -4871,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;

package/package.json

@@ -44,5 +44,5 @@
   },
   "type": "module",
   "types": "./dist/index.d.ts",
-  "version": "4.0.22"
+  "version": "4.0.23"
 }