@shaclmate/shacl-ast 2.0.17 → 2.0.19

package/dist/generated.d.ts

@@ -2,7 +2,10 @@ import type * as rdfjs from "@rdfjs/types";
 import * as purify from "purify-ts";
 import * as rdfjsResource from "rdfjs-resource";
 import { PropertyPath } from "./PropertyPath.js";
+type UnwrapR<T> = T extends purify.Either<any, infer R> ? R : never;
 export interface BaseShaclCoreShape {
+    readonly identifier: rdfjs.BlankNode | rdfjs.NamedNode;
+    readonly type: "ShaclCoreNodeShape" | "ShaclCorePropertyShape";
     readonly and: readonly (readonly (rdfjs.BlankNode | rdfjs.NamedNode)[])[];
     readonly classes: readonly rdfjs.NamedNode[];
     readonly comments: readonly rdfjs.Literal[];
@@ -10,7 +13,6 @@ export interface BaseShaclCoreShape {
     readonly deactivated: purify.Maybe<boolean>;
     readonly flags: readonly string[];
     readonly hasValues: readonly (rdfjs.BlankNode | rdfjs.NamedNode | rdfjs.Literal)[];
-    readonly identifier: rdfjs.BlankNode | rdfjs.NamedNode;
     readonly in_: purify.Maybe<readonly (rdfjs.BlankNode | rdfjs.NamedNode | rdfjs.Literal)[]>;
     readonly isDefinedBy: purify.Maybe<rdfjs.BlankNode | rdfjs.NamedNode>;
     readonly labels: readonly rdfjs.Literal[];
@@ -28,16 +30,16 @@ export interface BaseShaclCoreShape {
     readonly not: readonly (rdfjs.BlankNode | rdfjs.NamedNode)[];
     readonly or: readonly (readonly (rdfjs.BlankNode | rdfjs.NamedNode)[])[];
     readonly patterns: readonly string[];
-    readonly type: "ShaclCoreNodeShape" | "ShaclCorePropertyShape";
     readonly xone: readonly (readonly (rdfjs.BlankNode | rdfjs.NamedNode)[])[];
 }
 export declare namespace BaseShaclCoreShape {
-    function fromRdf({ ignoreRdfType: _ignoreRdfType, languageIn: _languageIn, resource: _resource, ..._context }: {
+    function _propertiesFromRdf({ ignoreRdfType: _ignoreRdfType, languageIn: _languageIn, resource: _resource, ..._context }: {
         [_index: string]: any;
         ignoreRdfType?: boolean;
         languageIn?: readonly string[];
         resource: rdfjsResource.Resource;
     }): purify.Either<rdfjsResource.Resource.ValueError, {
+        identifier: rdfjs.BlankNode | rdfjs.NamedNode;
         and: readonly (readonly (rdfjs.BlankNode | rdfjs.NamedNode)[])[];
         classes: readonly rdfjs.NamedNode[];
         comments: readonly rdfjs.Literal[];
@@ -45,7 +47,6 @@ export declare namespace BaseShaclCoreShape {
         deactivated: purify.Maybe<boolean>;
         flags: readonly string[];
         hasValues: readonly (rdfjs.BlankNode | rdfjs.NamedNode | rdfjs.Literal)[];
-        identifier: rdfjs.BlankNode | rdfjs.NamedNode;
         in_: purify.Maybe<readonly (rdfjs.BlankNode | rdfjs.NamedNode | rdfjs.Literal)[]>;
         isDefinedBy: purify.Maybe<rdfjs.BlankNode | rdfjs.NamedNode>;
         labels: readonly rdfjs.Literal[];
@@ -67,72 +68,106 @@ export declare namespace BaseShaclCoreShape {
     }>;
 }
 export interface ShaclCorePropertyShape extends BaseShaclCoreShape {
+    readonly identifier: rdfjs.BlankNode | rdfjs.NamedNode;
+    readonly type: "ShaclCorePropertyShape";
     readonly defaultValue: purify.Maybe<rdfjs.BlankNode | rdfjs.NamedNode | rdfjs.Literal>;
     readonly descriptions: readonly rdfjs.Literal[];
     readonly groups: readonly (rdfjs.BlankNode | rdfjs.NamedNode)[];
-    readonly identifier: rdfjs.BlankNode | rdfjs.NamedNode;
     readonly names: readonly rdfjs.Literal[];
     readonly order: purify.Maybe<number>;
     readonly path: PropertyPath;
-    readonly type: "ShaclCorePropertyShape";
     readonly uniqueLang: purify.Maybe<boolean>;
 }
 export declare namespace ShaclCorePropertyShape {
-    function fromRdf({ ignoreRdfType: _ignoreRdfType, languageIn: _languageIn, resource: _resource, ..._context }: {
+    function _propertiesFromRdf({ ignoreRdfType: _ignoreRdfType, languageIn: _languageIn, resource: _resource, ..._context }: {
         [_index: string]: any;
         ignoreRdfType?: boolean;
         languageIn?: readonly string[];
         resource: rdfjsResource.Resource;
-    }): purify.Either<rdfjsResource.Resource.ValueError, ShaclCorePropertyShape>;
+    }): purify.Either<rdfjsResource.Resource.ValueError, {
+        identifier: rdfjs.BlankNode | rdfjs.NamedNode;
+        type: "ShaclCorePropertyShape";
+        defaultValue: purify.Maybe<rdfjs.BlankNode | rdfjs.NamedNode | rdfjs.Literal>;
+        descriptions: readonly rdfjs.Literal[];
+        groups: readonly (rdfjs.BlankNode | rdfjs.NamedNode)[];
+        names: readonly rdfjs.Literal[];
+        order: purify.Maybe<number>;
+        path: PropertyPath;
+        uniqueLang: purify.Maybe<boolean>;
+    } & UnwrapR<ReturnType<typeof BaseShaclCoreShape._propertiesFromRdf>>>;
+    function fromRdf(parameters: Parameters<typeof ShaclCorePropertyShape._propertiesFromRdf>[0]): purify.Either<rdfjsResource.Resource.ValueError, ShaclCorePropertyShape>;
+    const fromRdfType: rdfjs.NamedNode<string>;
 }
 export interface ShaclCorePropertyGroup {
-    readonly comments: readonly rdfjs.Literal[];
     readonly identifier: rdfjs.BlankNode | rdfjs.NamedNode;
-    readonly labels: readonly rdfjs.Literal[];
     readonly type: "ShaclCorePropertyGroup";
+    readonly comments: readonly rdfjs.Literal[];
+    readonly labels: readonly rdfjs.Literal[];
 }
 export declare namespace ShaclCorePropertyGroup {
-    function fromRdf({ ignoreRdfType: _ignoreRdfType, languageIn: _languageIn, resource: _resource, ..._context }: {
+    function _propertiesFromRdf({ ignoreRdfType: _ignoreRdfType, languageIn: _languageIn, resource: _resource, ..._context }: {
         [_index: string]: any;
         ignoreRdfType?: boolean;
         languageIn?: readonly string[];
         resource: rdfjsResource.Resource;
-    }): purify.Either<rdfjsResource.Resource.ValueError, ShaclCorePropertyGroup>;
+    }): purify.Either<rdfjsResource.Resource.ValueError, {
+        identifier: rdfjs.BlankNode | rdfjs.NamedNode;
+        type: "ShaclCorePropertyGroup";
+        comments: readonly rdfjs.Literal[];
+        labels: readonly rdfjs.Literal[];
+    }>;
+    function fromRdf(parameters: Parameters<typeof ShaclCorePropertyGroup._propertiesFromRdf>[0]): purify.Either<rdfjsResource.Resource.ValueError, ShaclCorePropertyGroup>;
+    const fromRdfType: rdfjs.NamedNode<string>;
 }
 export interface ShaclCoreNodeShape extends BaseShaclCoreShape {
-    readonly closed: purify.Maybe<boolean>;
     readonly identifier: rdfjs.BlankNode | rdfjs.NamedNode;
+    readonly type: "ShaclCoreNodeShape";
+    readonly closed: purify.Maybe<boolean>;
     readonly ignoredProperties: purify.Maybe<readonly rdfjs.NamedNode[]>;
     readonly properties: readonly (rdfjs.BlankNode | rdfjs.NamedNode)[];
-    readonly type: "ShaclCoreNodeShape";
 }
 export declare namespace ShaclCoreNodeShape {
-    function fromRdf({ ignoreRdfType: _ignoreRdfType, languageIn: _languageIn, resource: _resource, ..._context }: {
+    function _propertiesFromRdf({ ignoreRdfType: _ignoreRdfType, languageIn: _languageIn, resource: _resource, ..._context }: {
         [_index: string]: any;
         ignoreRdfType?: boolean;
         languageIn?: readonly string[];
         resource: rdfjsResource.Resource;
-    }): purify.Either<rdfjsResource.Resource.ValueError, ShaclCoreNodeShape>;
+    }): purify.Either<rdfjsResource.Resource.ValueError, {
+        identifier: rdfjs.BlankNode | rdfjs.NamedNode;
+        type: "ShaclCoreNodeShape";
+        closed: purify.Maybe<boolean>;
+        ignoredProperties: purify.Maybe<readonly rdfjs.NamedNode[]>;
+        properties: readonly (rdfjs.BlankNode | rdfjs.NamedNode)[];
+    } & UnwrapR<ReturnType<typeof BaseShaclCoreShape._propertiesFromRdf>>>;
+    function fromRdf(parameters: Parameters<typeof ShaclCoreNodeShape._propertiesFromRdf>[0]): purify.Either<rdfjsResource.Resource.ValueError, ShaclCoreNodeShape>;
+    const fromRdfType: rdfjs.NamedNode<string>;
 }
 export interface OwlOntology {
     readonly identifier: rdfjs.BlankNode | rdfjs.NamedNode;
-    readonly labels: readonly rdfjs.Literal[];
     readonly type: "OwlOntology";
+    readonly labels: readonly rdfjs.Literal[];
 }
 export declare namespace OwlOntology {
-    function fromRdf({ ignoreRdfType: _ignoreRdfType, languageIn: _languageIn, resource: _resource, ..._context }: {
+    function _propertiesFromRdf({ ignoreRdfType: _ignoreRdfType, languageIn: _languageIn, resource: _resource, ..._context }: {
         [_index: string]: any;
         ignoreRdfType?: boolean;
         languageIn?: readonly string[];
         resource: rdfjsResource.Resource;
-    }): purify.Either<rdfjsResource.Resource.ValueError, OwlOntology>;
+    }): purify.Either<rdfjsResource.Resource.ValueError, {
+        identifier: rdfjs.BlankNode | rdfjs.NamedNode;
+        type: "OwlOntology";
+        labels: readonly rdfjs.Literal[];
+    }>;
+    function fromRdf(parameters: Parameters<typeof OwlOntology._propertiesFromRdf>[0]): purify.Either<rdfjsResource.Resource.ValueError, OwlOntology>;
+    const fromRdfType: rdfjs.NamedNode<string>;
 }
 export type ShaclCoreShape = ShaclCoreNodeShape | ShaclCorePropertyShape;
 export declare namespace ShaclCoreShape {
-    function fromRdf(parameters: {
+    function fromRdf({ ignoreRdfType, resource, ...context }: {
         [_index: string]: any;
         ignoreRdfType?: boolean;
         resource: rdfjsResource.Resource;
     }): purify.Either<rdfjsResource.Resource.ValueError, ShaclCoreShape>;
 }
+export {};
 //# sourceMappingURL=generated.d.ts.map

package/dist/generated.js

@@ -4,9 +4,10 @@ import * as rdfjsResource from "rdfjs-resource";
 import { PropertyPath } from "./PropertyPath.js";
 export var BaseShaclCoreShape;
 (function (BaseShaclCoreShape) {
-    function fromRdf({ ignoreRdfType: _ignoreRdfType, languageIn: _languageIn, resource: _resource, 
+    function _propertiesFromRdf({ ignoreRdfType: _ignoreRdfType, languageIn: _languageIn, resource: _resource, 
     // @ts-ignore
     ..._context }) {
+        const identifier = _resource.identifier;
         const _andEither = purify.Either.of([
             ..._resource
                 .values(dataFactory.namedNode("http://www.w3.org/ns/shacl#and"), {
@@ -122,7 +123,6 @@ export var BaseShaclCoreShape;
             return _hasValuesEither;
         }
         const hasValues = _hasValuesEither.unsafeCoerce();
-        const identifier = _resource.identifier;
         const _in_Either = purify.Either.of(_resource
             .values(dataFactory.namedNode("http://www.w3.org/ns/shacl#in"), {
             unique: true,
@@ -439,6 +439,7 @@ export var BaseShaclCoreShape;
         }
         const xone = _xoneEither.unsafeCoerce();
         return purify.Either.of({
+            identifier,
             and,
             classes,
             comments,
@@ -446,7 +447,6 @@ export var BaseShaclCoreShape;
             deactivated,
             flags,
             hasValues,
-            identifier,
             in_,
             isDefinedBy,
             labels,
@@ -467,185 +467,169 @@ export var BaseShaclCoreShape;
             xone,
         });
     }
-    BaseShaclCoreShape.fromRdf = fromRdf;
+    BaseShaclCoreShape._propertiesFromRdf = _propertiesFromRdf;
 })(BaseShaclCoreShape || (BaseShaclCoreShape = {}));
 export var ShaclCorePropertyShape;
 (function (ShaclCorePropertyShape) {
-    function fromRdf({ ignoreRdfType: _ignoreRdfType, languageIn: _languageIn, resource: _resource, 
+    function _propertiesFromRdf({ ignoreRdfType: _ignoreRdfType, languageIn: _languageIn, resource: _resource, 
     // @ts-ignore
     ..._context }) {
-        return BaseShaclCoreShape.fromRdf({
+        const _super0Either = BaseShaclCoreShape._propertiesFromRdf({
             ..._context,
             ignoreRdfType: true,
             languageIn: _languageIn,
             resource: _resource,
-        }).chain((_super) => {
-            if (!_ignoreRdfType &&
-                !_resource.isInstanceOf(dataFactory.namedNode("http://www.w3.org/ns/shacl#PropertyShape"))) {
-                return purify.Left(new rdfjsResource.Resource.ValueError({
-                    focusResource: _resource,
-                    message: `${rdfjsResource.Resource.Identifier.toString(_resource.identifier)} has unexpected RDF type`,
-                    predicate: dataFactory.namedNode("http://www.w3.org/ns/shacl#PropertyShape"),
-                }));
-            }
-            const _defaultValueEither = purify.Either.of(_resource
-                .values(dataFactory.namedNode("http://www.w3.org/ns/shacl#defaultValue"), { unique: true })
+        });
+        if (_super0Either.isLeft()) {
+            return _super0Either;
+        }
+        const _super0 = _super0Either.unsafeCoerce();
+        if (!_ignoreRdfType &&
+            !_resource.isInstanceOf(dataFactory.namedNode("http://www.w3.org/ns/shacl#PropertyShape"))) {
+            return purify.Left(new rdfjsResource.Resource.ValueError({
+                focusResource: _resource,
+                message: `${rdfjsResource.Resource.Identifier.toString(_resource.identifier)} has unexpected RDF type`,
+                predicate: dataFactory.namedNode("http://www.w3.org/ns/shacl#PropertyShape"),
+            }));
+        }
+        const identifier = _resource.identifier;
+        const type = "ShaclCorePropertyShape";
+        const _defaultValueEither = purify.Either.of(_resource
+            .values(dataFactory.namedNode("http://www.w3.org/ns/shacl#defaultValue"), { unique: true })
+            .head()
+            .chain((_value) => purify.Either.of(_value.toTerm()))
+            .toMaybe());
+        if (_defaultValueEither.isLeft()) {
+            return _defaultValueEither;
+        }
+        const defaultValue = _defaultValueEither.unsafeCoerce();
+        const _descriptionsEither = purify.Either.of([
+            ..._resource
+                .values(dataFactory.namedNode("http://www.w3.org/ns/shacl#description"), { unique: true })
+                .flatMap((_item) => _item
+                .toValues()
+                .filter((_value) => {
+                const _languageInOrDefault = _languageIn ?? [];
+                if (_languageInOrDefault.length === 0) {
+                    return true;
+                }
+                const _valueLiteral = _value.toLiteral().toMaybe().extract();
+                if (typeof _valueLiteral === "undefined") {
+                    return false;
+                }
+                return _languageInOrDefault.some((_languageIn) => _languageIn === _valueLiteral.language);
+            })
                 .head()
-                .chain((_value) => purify.Either.of(_value.toTerm()))
-                .toMaybe());
-            if (_defaultValueEither.isLeft()) {
-                return _defaultValueEither;
-            }
-            const defaultValue = _defaultValueEither.unsafeCoerce();
-            const _descriptionsEither = purify.Either.of([
-                ..._resource
-                    .values(dataFactory.namedNode("http://www.w3.org/ns/shacl#description"), { unique: true })
-                    .flatMap((_item) => _item
-                    .toValues()
-                    .filter((_value) => {
-                    const _languageInOrDefault = _languageIn ?? [];
-                    if (_languageInOrDefault.length === 0) {
-                        return true;
-                    }
-                    const _valueLiteral = _value.toLiteral().toMaybe().extract();
-                    if (typeof _valueLiteral === "undefined") {
-                        return false;
-                    }
-                    return _languageInOrDefault.some((_languageIn) => _languageIn === _valueLiteral.language);
-                })
-                    .head()
-                    .chain((_value) => _value.toLiteral())
-                    .toMaybe()
-                    .toList()),
-            ]);
-            if (_descriptionsEither.isLeft()) {
-                return _descriptionsEither;
-            }
-            const descriptions = _descriptionsEither.unsafeCoerce();
-            const _groupsEither = purify.Either.of([
-                ..._resource
-                    .values(dataFactory.namedNode("http://www.w3.org/ns/shacl#group"), {
-                    unique: true,
-                })
-                    .flatMap((_item) => _item
-                    .toValues()
-                    .head()
-                    .chain((_value) => _value.toIdentifier())
-                    .toMaybe()
-                    .toList()),
-            ]);
-            if (_groupsEither.isLeft()) {
-                return _groupsEither;
-            }
-            const groups = _groupsEither.unsafeCoerce();
-            const identifier = _resource.identifier;
-            const _namesEither = purify.Either.of([
-                ..._resource
-                    .values(dataFactory.namedNode("http://www.w3.org/ns/shacl#name"), {
-                    unique: true,
-                })
-                    .flatMap((_item) => _item
-                    .toValues()
-                    .filter((_value) => {
-                    const _languageInOrDefault = _languageIn ?? [];
-                    if (_languageInOrDefault.length === 0) {
-                        return true;
-                    }
-                    const _valueLiteral = _value.toLiteral().toMaybe().extract();
-                    if (typeof _valueLiteral === "undefined") {
-                        return false;
-                    }
-                    return _languageInOrDefault.some((_languageIn) => _languageIn === _valueLiteral.language);
-                })
-                    .head()
-                    .chain((_value) => _value.toLiteral())
-                    .toMaybe()
-                    .toList()),
-            ]);
-            if (_namesEither.isLeft()) {
-                return _namesEither;
-            }
-            const names = _namesEither.unsafeCoerce();
-            const _orderEither = purify.Either.of(_resource
-                .values(dataFactory.namedNode("http://www.w3.org/ns/shacl#order"), {
+                .chain((_value) => _value.toLiteral())
+                .toMaybe()
+                .toList()),
+        ]);
+        if (_descriptionsEither.isLeft()) {
+            return _descriptionsEither;
+        }
+        const descriptions = _descriptionsEither.unsafeCoerce();
+        const _groupsEither = purify.Either.of([
+            ..._resource
+                .values(dataFactory.namedNode("http://www.w3.org/ns/shacl#group"), {
                 unique: true,
             })
+                .flatMap((_item) => _item
+                .toValues()
                 .head()
-                .chain((_value) => _value.toNumber())
-                .toMaybe());
-            if (_orderEither.isLeft()) {
-                return _orderEither;
-            }
-            const order = _orderEither.unsafeCoerce();
-            const _pathEither = _resource
-                .values(dataFactory.namedNode("http://www.w3.org/ns/shacl#path"), {
+                .chain((_value) => _value.toIdentifier())
+                .toMaybe()
+                .toList()),
+        ]);
+        if (_groupsEither.isLeft()) {
+            return _groupsEither;
+        }
+        const groups = _groupsEither.unsafeCoerce();
+        const _namesEither = purify.Either.of([
+            ..._resource
+                .values(dataFactory.namedNode("http://www.w3.org/ns/shacl#name"), {
                 unique: true,
+            })
+                .flatMap((_item) => _item
+                .toValues()
+                .filter((_value) => {
+                const _languageInOrDefault = _languageIn ?? [];
+                if (_languageInOrDefault.length === 0) {
+                    return true;
+                }
+                const _valueLiteral = _value.toLiteral().toMaybe().extract();
+                if (typeof _valueLiteral === "undefined") {
+                    return false;
+                }
+                return _languageInOrDefault.some((_languageIn) => _languageIn === _valueLiteral.language);
             })
                 .head()
-                .chain((value) => value.toResource())
-                .chain((_resource) => PropertyPath.fromRdf({
-                ..._context,
-                ignoreRdfType: true,
-                languageIn: _languageIn,
-                resource: _resource,
-            }));
-            if (_pathEither.isLeft()) {
-                return _pathEither;
-            }
-            const path = _pathEither.unsafeCoerce();
-            const type = "ShaclCorePropertyShape";
-            const _uniqueLangEither = purify.Either.of(_resource
-                .values(dataFactory.namedNode("http://www.w3.org/ns/shacl#uniqueLang"), { unique: true })
-                .head()
-                .chain((_value) => _value.toBoolean())
-                .toMaybe());
-            if (_uniqueLangEither.isLeft()) {
-                return _uniqueLangEither;
-            }
-            const uniqueLang = _uniqueLangEither.unsafeCoerce();
-            return purify.Either.of({
-                and: _super.and,
-                classes: _super.classes,
-                comments: _super.comments,
-                datatype: _super.datatype,
-                deactivated: _super.deactivated,
-                flags: _super.flags,
-                hasValues: _super.hasValues,
-                identifier,
-                in_: _super.in_,
-                isDefinedBy: _super.isDefinedBy,
-                labels: _super.labels,
-                languageIn: _super.languageIn,
-                maxCount: _super.maxCount,
-                maxExclusive: _super.maxExclusive,
-                maxInclusive: _super.maxInclusive,
-                maxLength: _super.maxLength,
-                minCount: _super.minCount,
-                minExclusive: _super.minExclusive,
-                minInclusive: _super.minInclusive,
-                minLength: _super.minLength,
-                nodeKind: _super.nodeKind,
-                nodes: _super.nodes,
-                not: _super.not,
-                or: _super.or,
-                patterns: _super.patterns,
-                xone: _super.xone,
-                defaultValue,
-                descriptions,
-                groups,
-                names,
-                order,
-                path,
-                type,
-                uniqueLang,
-            });
+                .chain((_value) => _value.toLiteral())
+                .toMaybe()
+                .toList()),
+        ]);
+        if (_namesEither.isLeft()) {
+            return _namesEither;
+        }
+        const names = _namesEither.unsafeCoerce();
+        const _orderEither = purify.Either.of(_resource
+            .values(dataFactory.namedNode("http://www.w3.org/ns/shacl#order"), {
+            unique: true,
+        })
+            .head()
+            .chain((_value) => _value.toNumber())
+            .toMaybe());
+        if (_orderEither.isLeft()) {
+            return _orderEither;
+        }
+        const order = _orderEither.unsafeCoerce();
+        const _pathEither = _resource
+            .values(dataFactory.namedNode("http://www.w3.org/ns/shacl#path"), {
+            unique: true,
+        })
+            .head()
+            .chain((value) => value.toResource())
+            .chain((_resource) => PropertyPath.fromRdf({
+            ..._context,
+            ignoreRdfType: true,
+            languageIn: _languageIn,
+            resource: _resource,
+        }));
+        if (_pathEither.isLeft()) {
+            return _pathEither;
+        }
+        const path = _pathEither.unsafeCoerce();
+        const _uniqueLangEither = purify.Either.of(_resource
+            .values(dataFactory.namedNode("http://www.w3.org/ns/shacl#uniqueLang"), { unique: true })
+            .head()
+            .chain((_value) => _value.toBoolean())
+            .toMaybe());
+        if (_uniqueLangEither.isLeft()) {
+            return _uniqueLangEither;
+        }
+        const uniqueLang = _uniqueLangEither.unsafeCoerce();
+        return purify.Either.of({
+            ..._super0,
+            identifier,
+            type,
+            defaultValue,
+            descriptions,
+            groups,
+            names,
+            order,
+            path,
+            uniqueLang,
         });
     }
+    ShaclCorePropertyShape._propertiesFromRdf = _propertiesFromRdf;
+    function fromRdf(parameters) {
+        return ShaclCorePropertyShape._propertiesFromRdf(parameters);
+    }
     ShaclCorePropertyShape.fromRdf = fromRdf;
+    ShaclCorePropertyShape.fromRdfType = dataFactory.namedNode("http://www.w3.org/ns/shacl#PropertyShape");
 })(ShaclCorePropertyShape || (ShaclCorePropertyShape = {}));
 export var ShaclCorePropertyGroup;
 (function (ShaclCorePropertyGroup) {
-    function fromRdf({ ignoreRdfType: _ignoreRdfType, languageIn: _languageIn, resource: _resource, 
+    function _propertiesFromRdf({ ignoreRdfType: _ignoreRdfType, languageIn: _languageIn, resource: _resource, 
     // @ts-ignore
     ..._context }) {
         if (!_ignoreRdfType &&
@@ -656,6 +640,8 @@ export var ShaclCorePropertyGroup;
                 predicate: dataFactory.namedNode("http://www.w3.org/ns/shacl#PropertyGroup"),
             }));
         }
+        const identifier = _resource.identifier;
+        const type = "ShaclCorePropertyGroup";
         const _commentsEither = purify.Either.of([
             ..._resource
                 .values(dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#comment"), { unique: true })
@@ -681,7 +667,6 @@ export var ShaclCorePropertyGroup;
             return _commentsEither;
         }
         const comments = _commentsEither.unsafeCoerce();
-        const identifier = _resource.identifier;
         const _labelsEither = purify.Either.of([
             ..._resource
                 .values(dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#label"), { unique: true })
@@ -707,111 +692,101 @@ export var ShaclCorePropertyGroup;
             return _labelsEither;
         }
         const labels = _labelsEither.unsafeCoerce();
-        const type = "ShaclCorePropertyGroup";
-        return purify.Either.of({ comments, identifier, labels, type });
+        return purify.Either.of({ identifier, type, comments, labels });
+    }
+    ShaclCorePropertyGroup._propertiesFromRdf = _propertiesFromRdf;
+    function fromRdf(parameters) {
+        return ShaclCorePropertyGroup._propertiesFromRdf(parameters);
     }
     ShaclCorePropertyGroup.fromRdf = fromRdf;
+    ShaclCorePropertyGroup.fromRdfType = dataFactory.namedNode("http://www.w3.org/ns/shacl#PropertyGroup");
 })(ShaclCorePropertyGroup || (ShaclCorePropertyGroup = {}));
 export var ShaclCoreNodeShape;
 (function (ShaclCoreNodeShape) {
-    function fromRdf({ ignoreRdfType: _ignoreRdfType, languageIn: _languageIn, resource: _resource, 
+    function _propertiesFromRdf({ ignoreRdfType: _ignoreRdfType, languageIn: _languageIn, resource: _resource, 
     // @ts-ignore
     ..._context }) {
-        return BaseShaclCoreShape.fromRdf({
+        const _super0Either = BaseShaclCoreShape._propertiesFromRdf({
             ..._context,
             ignoreRdfType: true,
             languageIn: _languageIn,
             resource: _resource,
-        }).chain((_super) => {
-            if (!_ignoreRdfType &&
-                !_resource.isInstanceOf(dataFactory.namedNode("http://www.w3.org/ns/shacl#NodeShape"))) {
-                return purify.Left(new rdfjsResource.Resource.ValueError({
-                    focusResource: _resource,
-                    message: `${rdfjsResource.Resource.Identifier.toString(_resource.identifier)} has unexpected RDF type`,
-                    predicate: dataFactory.namedNode("http://www.w3.org/ns/shacl#NodeShape"),
-                }));
-            }
-            const _closedEither = purify.Either.of(_resource
-                .values(dataFactory.namedNode("http://www.w3.org/ns/shacl#closed"), {
+        });
+        if (_super0Either.isLeft()) {
+            return _super0Either;
+        }
+        const _super0 = _super0Either.unsafeCoerce();
+        if (!_ignoreRdfType &&
+            !_resource.isInstanceOf(dataFactory.namedNode("http://www.w3.org/ns/shacl#NodeShape"))) {
+            return purify.Left(new rdfjsResource.Resource.ValueError({
+                focusResource: _resource,
+                message: `${rdfjsResource.Resource.Identifier.toString(_resource.identifier)} has unexpected RDF type`,
+                predicate: dataFactory.namedNode("http://www.w3.org/ns/shacl#NodeShape"),
+            }));
+        }
+        const identifier = _resource.identifier;
+        const type = "ShaclCoreNodeShape";
+        const _closedEither = purify.Either.of(_resource
+            .values(dataFactory.namedNode("http://www.w3.org/ns/shacl#closed"), {
+            unique: true,
+        })
+            .head()
+            .chain((_value) => _value.toBoolean())
+            .toMaybe());
+        if (_closedEither.isLeft()) {
+            return _closedEither;
+        }
+        const closed = _closedEither.unsafeCoerce();
+        const _ignoredPropertiesEither = purify.Either.of(_resource
+            .values(dataFactory.namedNode("http://www.w3.org/ns/shacl#ignoredProperties"), { unique: true })
+            .head()
+            .chain((value) => value.toList())
+            .map((values) => values.flatMap((_value) => _value
+            .toValues()
+            .head()
+            .chain((_value) => _value.toIri())
+            .toMaybe()
+            .toList()))
+            .toMaybe());
+        if (_ignoredPropertiesEither.isLeft()) {
+            return _ignoredPropertiesEither;
+        }
+        const ignoredProperties = _ignoredPropertiesEither.unsafeCoerce();
+        const _propertiesEither = purify.Either.of([
+            ..._resource
+                .values(dataFactory.namedNode("http://www.w3.org/ns/shacl#property"), {
                 unique: true,
             })
-                .head()
-                .chain((_value) => _value.toBoolean())
-                .toMaybe());
-            if (_closedEither.isLeft()) {
-                return _closedEither;
-            }
-            const closed = _closedEither.unsafeCoerce();
-            const identifier = _resource.identifier;
-            const _ignoredPropertiesEither = purify.Either.of(_resource
-                .values(dataFactory.namedNode("http://www.w3.org/ns/shacl#ignoredProperties"), { unique: true })
-                .head()
-                .chain((value) => value.toList())
-                .map((values) => values.flatMap((_value) => _value
+                .flatMap((_item) => _item
                 .toValues()
                 .head()
-                .chain((_value) => _value.toIri())
+                .chain((_value) => _value.toIdentifier())
                 .toMaybe()
-                .toList()))
-                .toMaybe());
-            if (_ignoredPropertiesEither.isLeft()) {
-                return _ignoredPropertiesEither;
-            }
-            const ignoredProperties = _ignoredPropertiesEither.unsafeCoerce();
-            const _propertiesEither = purify.Either.of([
-                ..._resource
-                    .values(dataFactory.namedNode("http://www.w3.org/ns/shacl#property"), { unique: true })
-                    .flatMap((_item) => _item
-                    .toValues()
-                    .head()
-                    .chain((_value) => _value.toIdentifier())
-                    .toMaybe()
-                    .toList()),
-            ]);
-            if (_propertiesEither.isLeft()) {
-                return _propertiesEither;
-            }
-            const properties = _propertiesEither.unsafeCoerce();
-            const type = "ShaclCoreNodeShape";
-            return purify.Either.of({
-                and: _super.and,
-                classes: _super.classes,
-                comments: _super.comments,
-                datatype: _super.datatype,
-                deactivated: _super.deactivated,
-                flags: _super.flags,
-                hasValues: _super.hasValues,
-                identifier,
-                in_: _super.in_,
-                isDefinedBy: _super.isDefinedBy,
-                labels: _super.labels,
-                languageIn: _super.languageIn,
-                maxCount: _super.maxCount,
-                maxExclusive: _super.maxExclusive,
-                maxInclusive: _super.maxInclusive,
-                maxLength: _super.maxLength,
-                minCount: _super.minCount,
-                minExclusive: _super.minExclusive,
-                minInclusive: _super.minInclusive,
-                minLength: _super.minLength,
-                nodeKind: _super.nodeKind,
-                nodes: _super.nodes,
-                not: _super.not,
-                or: _super.or,
-                patterns: _super.patterns,
-                xone: _super.xone,
-                closed,
-                ignoredProperties,
-                properties,
-                type,
-            });
+                .toList()),
+        ]);
+        if (_propertiesEither.isLeft()) {
+            return _propertiesEither;
+        }
+        const properties = _propertiesEither.unsafeCoerce();
+        return purify.Either.of({
+            ..._super0,
+            identifier,
+            type,
+            closed,
+            ignoredProperties,
+            properties,
         });
     }
+    ShaclCoreNodeShape._propertiesFromRdf = _propertiesFromRdf;
+    function fromRdf(parameters) {
+        return ShaclCoreNodeShape._propertiesFromRdf(parameters);
+    }
     ShaclCoreNodeShape.fromRdf = fromRdf;
+    ShaclCoreNodeShape.fromRdfType = dataFactory.namedNode("http://www.w3.org/ns/shacl#NodeShape");
 })(ShaclCoreNodeShape || (ShaclCoreNodeShape = {}));
 export var OwlOntology;
 (function (OwlOntology) {
-    function fromRdf({ ignoreRdfType: _ignoreRdfType, languageIn: _languageIn, resource: _resource, 
+    function _propertiesFromRdf({ ignoreRdfType: _ignoreRdfType, languageIn: _languageIn, resource: _resource, 
     // @ts-ignore
     ..._context }) {
         if (!_ignoreRdfType &&
@@ -823,6 +798,7 @@ export var OwlOntology;
             }));
         }
         const identifier = _resource.identifier;
+        const type = "OwlOntology";
         const _labelsEither = purify.Either.of([
             ..._resource
                 .values(dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#label"), { unique: true })
@@ -848,15 +824,22 @@ export var OwlOntology;
             return _labelsEither;
         }
         const labels = _labelsEither.unsafeCoerce();
-        const type = "OwlOntology";
-        return purify.Either.of({ identifier, labels, type });
+        return purify.Either.of({ identifier, type, labels });
+    }
+    OwlOntology._propertiesFromRdf = _propertiesFromRdf;
+    function fromRdf(parameters) {
+        return OwlOntology._propertiesFromRdf(parameters);
     }
     OwlOntology.fromRdf = fromRdf;
+    OwlOntology.fromRdfType = dataFactory.namedNode("http://www.w3.org/2002/07/owl#Ontology");
 })(OwlOntology || (OwlOntology = {}));
 export var ShaclCoreShape;
 (function (ShaclCoreShape) {
-    function fromRdf(parameters) {
-        return ShaclCoreNodeShape.fromRdf(parameters).altLazy(() => ShaclCorePropertyShape.fromRdf(parameters));
+    function fromRdf({ ignoreRdfType, resource, ...context }) {
+        return ShaclCoreNodeShape.fromRdf({ ...context, resource }).altLazy(() => ShaclCorePropertyShape.fromRdf({
+            ...context,
+            resource,
+        }));
     }
     ShaclCoreShape.fromRdf = fromRdf;
 })(ShaclCoreShape || (ShaclCoreShape = {}));

package/package.json

@@ -25,6 +25,10 @@
   ],
   "license": "Apache-2.0",
   "name": "@shaclmate/shacl-ast",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/minorg/shaclmate"
+  },
   "scripts": {
     "build": "tsc -b",
     "check": "biome check",
@@ -46,10 +50,6 @@
     "watch": "tsc -w --preserveWatchOutput",
     "watch:noEmit": "tsc --noEmit -w --preserveWatchOutput"
   },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/minorg/shaclmate"
-  },
   "type": "module",
-  "version": "2.0.17"
+  "version": "2.0.19"
 }