@shaclmate/shacl-ast 2.0.17 → 2.0.18

package/dist/generated.d.ts

@@ -2,6 +2,7 @@ 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 and: readonly (readonly (rdfjs.BlankNode | rdfjs.NamedNode)[])[];
     readonly classes: readonly rdfjs.NamedNode[];
@@ -32,7 +33,7 @@ export interface BaseShaclCoreShape {
     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[];
@@ -78,12 +79,24 @@ export interface ShaclCorePropertyShape extends BaseShaclCoreShape {
     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, {
+        defaultValue: purify.Maybe<rdfjs.BlankNode | rdfjs.NamedNode | rdfjs.Literal>;
+        descriptions: readonly rdfjs.Literal[];
+        groups: readonly (rdfjs.BlankNode | rdfjs.NamedNode)[];
+        identifier: rdfjs.BlankNode | rdfjs.NamedNode;
+        names: readonly rdfjs.Literal[];
+        order: purify.Maybe<number>;
+        path: PropertyPath;
+        type: "ShaclCorePropertyShape";
+        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[];
@@ -92,12 +105,19 @@ export interface ShaclCorePropertyGroup {
     readonly type: "ShaclCorePropertyGroup";
 }
 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, {
+        comments: readonly rdfjs.Literal[];
+        identifier: rdfjs.BlankNode | rdfjs.NamedNode;
+        labels: readonly rdfjs.Literal[];
+        type: "ShaclCorePropertyGroup";
+    }>;
+    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>;
@@ -107,12 +127,20 @@ export interface ShaclCoreNodeShape extends BaseShaclCoreShape {
     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, {
+        closed: purify.Maybe<boolean>;
+        identifier: rdfjs.BlankNode | rdfjs.NamedNode;
+        ignoredProperties: purify.Maybe<readonly rdfjs.NamedNode[]>;
+        properties: readonly (rdfjs.BlankNode | rdfjs.NamedNode)[];
+        type: "ShaclCoreNodeShape";
+    } & 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;
@@ -120,19 +148,26 @@ export interface OwlOntology {
     readonly type: "OwlOntology";
 }
 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;
+        labels: readonly rdfjs.Literal[];
+        type: "OwlOntology";
+    }>;
+    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,7 +4,7 @@ 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 _andEither = purify.Either.of([
@@ -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 _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 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.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 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({
+            ..._super0,
+            defaultValue,
+            descriptions,
+            groups,
+            identifier,
+            names,
+            order,
+            path,
+            type,
+            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 &&
@@ -710,108 +694,99 @@ export var ShaclCorePropertyGroup;
         const type = "ShaclCorePropertyGroup";
         return purify.Either.of({ comments, identifier, labels, type });
     }
+    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 _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 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
+            .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();
+        const type = "ShaclCoreNodeShape";
+        return purify.Either.of({
+            ..._super0,
+            closed,
+            identifier,
+            ignoredProperties,
+            properties,
+            type,
         });
     }
+    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 &&
@@ -851,12 +826,20 @@ export var OwlOntology;
         const type = "OwlOntology";
         return purify.Either.of({ identifier, labels, type });
     }
+    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

@@ -51,5 +51,5 @@
     "url": "git+https://github.com/minorg/shaclmate"
   },
   "type": "module",
-  "version": "2.0.17"
+  "version": "2.0.18"
 }