@shaclmate/shacl-ast 2.0.13 → 2.0.15

package/ShapesGraph.js

@@ -1,201 +1,2 @@
-import TermMap from "@rdfjs/term-map";
-import TermSet from "@rdfjs/term-set";
-import { rdf, sh } from "@tpluscode/rdf-ns-builders";
-import { Maybe } from "purify-ts";
-import { Resource, ResourceSet } from "rdfjs-resource";
-import { NodeShape } from "./NodeShape.js";
-import { PropertyGroup } from "./PropertyGroup.js";
-import { PropertyShape } from "./PropertyShape.js";
-export class ShapesGraph {
-    constructor(dataset) {
-        this.dataset = dataset;
-        this.node = this.readGraph();
-        const { nodeShapes, nodeShapesByNode, propertyShapes, propertyShapesByNode, } = this.readShapes();
-        this.nodeShapes = nodeShapes;
-        this.nodeShapesByNode = nodeShapesByNode;
-        this.propertyShapes = propertyShapes;
-        this.propertyShapesByNode = propertyShapesByNode;
-        const { propertyGroups, propertyGroupsByNode } = this.readPropertyGroups();
-        this.propertyGroups = propertyGroups;
-        this.propertyGroupsByNode = propertyGroupsByNode;
-    }
-    static fromDataset(dataset) {
-        return new ShapesGraph(dataset);
-    }
-    nodeShapeByNode(nodeShapeNode) {
-        return Maybe.fromNullable(this.nodeShapesByNode.get(nodeShapeNode));
-    }
-    propertyGroupByNode(propertyGroupNode) {
-        return Maybe.fromNullable(this.propertyGroupsByNode.get(propertyGroupNode));
-    }
-    propertyShapeByNode(propertyShapeNode) {
-        return Maybe.fromNullable(this.propertyShapesByNode.get(propertyShapeNode));
-    }
-    shapeByNode(node) {
-        const nodeShape = this.nodeShapeByNode(node);
-        if (nodeShape.isJust()) {
-            return nodeShape;
-        }
-        return this.propertyShapeByNode(node);
-    }
-    readGraph() {
-        const graphs = new TermSet();
-        for (const quad of this.dataset) {
-            graphs.add(quad.graph);
-        }
-        if (graphs.size !== 1) {
-            return null;
-        }
-        const graph = [...graphs.values()][0];
-        switch (graph.termType) {
-            case "BlankNode":
-            case "DefaultGraph":
-            case "NamedNode":
-                return graph;
-            default:
-                throw new RangeError(`expected NamedNode or default graph, actual ${graph.termType}`);
-        }
-    }
-    readPropertyGroups() {
-        const propertyGroups = [];
-        const propertyGroupsByNode = new TermMap();
-        for (const quad of this.dataset.match(null, rdf.type, sh.PropertyGroup, this.node)) {
-            const subject = quad.subject;
-            if (subject.termType !== "NamedNode") {
-                continue;
-            }
-            if (propertyGroupsByNode.has(subject)) {
-                continue;
-            }
-            const propertyGroup = new PropertyGroup(new Resource({ dataset: this.dataset, identifier: subject }));
-            propertyGroups.push(propertyGroup);
-            propertyGroupsByNode.set(subject, propertyGroup);
-        }
-        return { propertyGroups, propertyGroupsByNode };
-    }
-    readShapes() {
-        const resourceSet = new ResourceSet({ dataset: this.dataset });
-        // Collect the shape identifiers in sets
-        const shapeNodeSet = new TermSet();
-        // Utility function for doing the collection
-        const addShapeNode = (shapeNode) => {
-            switch (shapeNode.termType) {
-                case "BlankNode":
-                case "NamedNode":
-                    shapeNodeSet.add(shapeNode);
-                    break;
-            }
-        };
-        // Test each shape condition
-        // https://www.w3.org/TR/shacl/#shapes
-        // Subject is a SHACL instance of sh:NodeShape or sh:PropertyShape
-        for (const rdfType of [sh.NodeShape, sh.PropertyShape]) {
-            for (const resource of resourceSet.instancesOf(rdfType, {
-                graph: this.node,
-            })) {
-                addShapeNode(resource.identifier);
-            }
-        }
-        // Subject of a triple with sh:targetClass, sh:targetNode, sh:targetObjectsOf, or sh:targetSubjectsOf predicate
-        for (const predicate of [
-            sh.targetClass,
-            sh.targetNode,
-            sh.targetObjectsOf,
-            sh.targetSubjectsOf,
-        ]) {
-            for (const quad of this.dataset.match(null, predicate, null, this.node)) {
-                addShapeNode(quad.subject);
-            }
-        }
-        // Subject of a triple that has a parameter as predicate
-        // https://www.w3.org/TR/shacl/#constraints
-        // https://www.w3.org/TR/shacl/#core-components
-        for (const predicate of [
-            sh.class,
-            sh.datatype,
-            sh.nodeKind,
-            sh.minCount,
-            sh.maxCount,
-            sh.minExclusive,
-            sh.minInclusive,
-            sh.maxExclusive,
-            sh.maxInclusive,
-            sh.minLength,
-            sh.maxLength,
-            sh.pattern,
-            sh.languageIn,
-            sh.uniqueLang,
-            sh.equals,
-            sh.disjoint,
-            sh.lessThan,
-            sh.lessThanOrEquals,
-            sh.not,
-            sh.and,
-            sh.or,
-            sh.xone,
-            sh.node,
-            sh.property,
-            sh.qualifiedValueShape,
-            sh.qualifiedMinCount,
-            sh.qualifiedMaxCount,
-            sh.closed,
-            sh.ignoredProperties,
-            sh.hasValue,
-            sh.in,
-        ]) {
-            for (const quad of this.dataset.match(null, predicate, null, this.node)) {
-                addShapeNode(quad.subject);
-            }
-        }
-        // Object of a shape-expecting, non-list-taking parameter such as sh:node
-        for (const predicate of [sh.node, sh.property]) {
-            for (const quad of this.dataset.match(null, predicate, null, this.node)) {
-                addShapeNode(quad.object);
-            }
-        }
-        // Member of a SHACL list that is a value of a shape-expecting and list-taking parameter such as sh:or
-        for (const predicate of [sh.and, sh["in"], sh.languageIn, sh.or, sh.xone]) {
-            for (const quad of this.dataset.match(null, predicate, null, this.node)) {
-                switch (quad.object.termType) {
-                    case "BlankNode":
-                    case "NamedNode":
-                        break;
-                    default:
-                        continue;
-                }
-                for (const value of resourceSet
-                    .resource(quad.object)
-                    .toList()
-                    .orDefault([])) {
-                    value.toIdentifier().ifRight(addShapeNode);
-                }
-            }
-        }
-        // Separate shapes into node and property shapes.
-        const nodeShapes = [];
-        const nodeShapesByNode = new TermMap();
-        const propertyShapes = [];
-        const propertyShapesByNode = new TermMap();
-        for (const shapeNode of shapeNodeSet) {
-            if (this.dataset.match(shapeNode, sh.path, null, this.node).size > 0) {
-                // A property shape is a shape in the shapes graph that is the subject of a triple that has sh:path as its predicate. A shape has at most one value for sh:path. Each value of sh:path in a shape must be a well-formed SHACL property path. It is recommended, but not required, for a property shape to be declared as a SHACL instance of sh:PropertyShape. SHACL instances of sh:PropertyShape have one value for the property sh:path.
-                const propertyShape = new PropertyShape(resourceSet.resource(shapeNode), this);
-                propertyShapes.push(propertyShape);
-                propertyShapesByNode.set(shapeNode, propertyShape);
-            }
-            else {
-                // A node shape is a shape in the shapes graph that is not the subject of a triple with sh:path as its predicate. It is recommended, but not required, for a node shape to be declared as a SHACL instance of sh:NodeShape. SHACL instances of sh:NodeShape cannot have a value for the property sh:path.
-                const nodeShape = new NodeShape(resourceSet.resource(shapeNode), this);
-                nodeShapes.push(nodeShape);
-                nodeShapesByNode.set(shapeNode, nodeShape);
-            }
-        }
-        return {
-            nodeShapes,
-            nodeShapesByNode,
-            propertyShapes,
-            propertyShapesByNode,
-        };
-    }
-}
+export {};
 //# sourceMappingURL=ShapesGraph.js.map

package/defaultFactory.d.ts

@@ -0,0 +1,12 @@
+import type { Factory } from "./Factory.js";
+import { NodeShape } from "./NodeShape.js";
+import { Ontology } from "./Ontology.js";
+import { PropertyGroup } from "./PropertyGroup.js";
+import { PropertyShape } from "./PropertyShape.js";
+import type { Shape } from "./Shape.js";
+type DefaultNodeShape = NodeShape<any, Ontology, PropertyGroup, DefaultPropertyShape, DefaultShape>;
+type DefaultPropertyShape = PropertyShape<DefaultNodeShape, Ontology, PropertyGroup, any, DefaultShape>;
+type DefaultShape = Shape<DefaultNodeShape, Ontology, PropertyGroup, DefaultPropertyShape, any>;
+export declare const defaultFactory: Factory<DefaultNodeShape, Ontology, PropertyGroup, DefaultPropertyShape, DefaultShape>;
+export {};
+//# sourceMappingURL=defaultFactory.d.ts.map

package/defaultFactory.js

@@ -0,0 +1,32 @@
+import { NodeShape } from "./NodeShape.js";
+import { Ontology } from "./Ontology.js";
+import { PropertyGroup } from "./PropertyGroup.js";
+import { PropertyShape } from "./PropertyShape.js";
+import * as generated from "./generated.js";
+export const defaultFactory = {
+    nodeShapeFromRdf({ resource, shapesGraph, }) {
+        return generated.ShaclCoreNodeShape.fromRdf({
+            ignoreRdfType: true,
+            resource,
+        }).map((generatedShape) => new NodeShape(generatedShape, shapesGraph));
+    },
+    ontologyFromRdf({ resource, }) {
+        return generated.OwlOntology.fromRdf({
+            ignoreRdfType: true,
+            resource,
+        }).map((generatedOntology) => new Ontology(generatedOntology));
+    },
+    propertyGroupFromRdf({ resource, }) {
+        return generated.ShaclCorePropertyGroup.fromRdf({
+            ignoreRdfType: true,
+            resource,
+        }).map((propertyGroup) => new PropertyGroup(propertyGroup));
+    },
+    propertyShapeFromRdf({ resource, shapesGraph, }) {
+        return generated.ShaclCorePropertyShape.fromRdf({
+            ignoreRdfType: true,
+            resource,
+        }).map((generatedShape) => new PropertyShape(generatedShape, shapesGraph));
+    },
+};
+//# sourceMappingURL=defaultFactory.js.map

package/generated.d.ts

@@ -0,0 +1,138 @@
+import type * as rdfjs from "@rdfjs/types";
+import { PropertyPath } from "@shaclmate/shacl-ast/PropertyPath.js";
+import * as purify from "purify-ts";
+import * as rdfjsResource from "rdfjs-resource";
+export interface BaseShaclCoreShape {
+    readonly and: readonly (readonly (rdfjs.BlankNode | rdfjs.NamedNode)[])[];
+    readonly classes: readonly rdfjs.NamedNode[];
+    readonly comments: readonly rdfjs.Literal[];
+    readonly datatype: purify.Maybe<rdfjs.NamedNode>;
+    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[];
+    readonly languageIn: purify.Maybe<readonly string[]>;
+    readonly maxCount: purify.Maybe<number>;
+    readonly maxExclusive: purify.Maybe<rdfjs.Literal>;
+    readonly maxInclusive: purify.Maybe<rdfjs.Literal>;
+    readonly maxLength: purify.Maybe<number>;
+    readonly minCount: purify.Maybe<number>;
+    readonly minExclusive: purify.Maybe<rdfjs.Literal>;
+    readonly minInclusive: purify.Maybe<rdfjs.Literal>;
+    readonly minLength: purify.Maybe<number>;
+    readonly nodeKind: purify.Maybe<rdfjs.NamedNode<"http://www.w3.org/ns/shacl#BlankNode" | "http://www.w3.org/ns/shacl#BlankNodeOrIRI" | "http://www.w3.org/ns/shacl#BlankNodeOrLiteral" | "http://www.w3.org/ns/shacl#IRI" | "http://www.w3.org/ns/shacl#IRIOrLiteral" | "http://www.w3.org/ns/shacl#Literal">>;
+    readonly nodes: readonly (rdfjs.BlankNode | rdfjs.NamedNode)[];
+    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 }: {
+        [_index: string]: any;
+        ignoreRdfType?: boolean;
+        languageIn?: readonly string[];
+        resource: rdfjsResource.Resource;
+    }): purify.Either<rdfjsResource.Resource.ValueError, {
+        and: readonly (readonly (rdfjs.BlankNode | rdfjs.NamedNode)[])[];
+        classes: readonly rdfjs.NamedNode[];
+        comments: readonly rdfjs.Literal[];
+        datatype: purify.Maybe<rdfjs.NamedNode>;
+        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[];
+        languageIn: purify.Maybe<readonly string[]>;
+        maxCount: purify.Maybe<number>;
+        maxExclusive: purify.Maybe<rdfjs.Literal>;
+        maxInclusive: purify.Maybe<rdfjs.Literal>;
+        maxLength: purify.Maybe<number>;
+        minCount: purify.Maybe<number>;
+        minExclusive: purify.Maybe<rdfjs.Literal>;
+        minInclusive: purify.Maybe<rdfjs.Literal>;
+        minLength: purify.Maybe<number>;
+        nodeKind: purify.Maybe<rdfjs.NamedNode<"http://www.w3.org/ns/shacl#BlankNode" | "http://www.w3.org/ns/shacl#BlankNodeOrIRI" | "http://www.w3.org/ns/shacl#BlankNodeOrLiteral" | "http://www.w3.org/ns/shacl#IRI" | "http://www.w3.org/ns/shacl#IRIOrLiteral" | "http://www.w3.org/ns/shacl#Literal">>;
+        nodes: readonly (rdfjs.BlankNode | rdfjs.NamedNode)[];
+        not: readonly (rdfjs.BlankNode | rdfjs.NamedNode)[];
+        or: readonly (readonly (rdfjs.BlankNode | rdfjs.NamedNode)[])[];
+        patterns: readonly string[];
+        xone: readonly (readonly (rdfjs.BlankNode | rdfjs.NamedNode)[])[];
+    }>;
+}
+export interface ShaclCorePropertyShape extends BaseShaclCoreShape {
+    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 }: {
+        [_index: string]: any;
+        ignoreRdfType?: boolean;
+        languageIn?: readonly string[];
+        resource: rdfjsResource.Resource;
+    }): purify.Either<rdfjsResource.Resource.ValueError, ShaclCorePropertyShape>;
+}
+export interface ShaclCorePropertyGroup {
+    readonly comments: readonly rdfjs.Literal[];
+    readonly identifier: rdfjs.BlankNode | rdfjs.NamedNode;
+    readonly labels: readonly rdfjs.Literal[];
+    readonly type: "ShaclCorePropertyGroup";
+}
+export declare namespace ShaclCorePropertyGroup {
+    function fromRdf({ ignoreRdfType: _ignoreRdfType, languageIn: _languageIn, resource: _resource, ..._context }: {
+        [_index: string]: any;
+        ignoreRdfType?: boolean;
+        languageIn?: readonly string[];
+        resource: rdfjsResource.Resource;
+    }): purify.Either<rdfjsResource.Resource.ValueError, ShaclCorePropertyGroup>;
+}
+export interface ShaclCoreNodeShape extends BaseShaclCoreShape {
+    readonly closed: purify.Maybe<boolean>;
+    readonly identifier: rdfjs.BlankNode | rdfjs.NamedNode;
+    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 }: {
+        [_index: string]: any;
+        ignoreRdfType?: boolean;
+        languageIn?: readonly string[];
+        resource: rdfjsResource.Resource;
+    }): purify.Either<rdfjsResource.Resource.ValueError, ShaclCoreNodeShape>;
+}
+export interface OwlOntology {
+    readonly identifier: rdfjs.BlankNode | rdfjs.NamedNode;
+    readonly labels: readonly rdfjs.Literal[];
+    readonly type: "OwlOntology";
+}
+export declare namespace OwlOntology {
+    function fromRdf({ ignoreRdfType: _ignoreRdfType, languageIn: _languageIn, resource: _resource, ..._context }: {
+        [_index: string]: any;
+        ignoreRdfType?: boolean;
+        languageIn?: readonly string[];
+        resource: rdfjsResource.Resource;
+    }): purify.Either<rdfjsResource.Resource.ValueError, OwlOntology>;
+}
+export type ShaclCoreShape = ShaclCoreNodeShape | ShaclCorePropertyShape;
+export declare namespace ShaclCoreShape {
+    function fromRdf(parameters: {
+        [_index: string]: any;
+        ignoreRdfType?: boolean;
+        resource: rdfjsResource.Resource;
+    }): purify.Either<rdfjsResource.Resource.ValueError, ShaclCoreShape>;
+}
+//# sourceMappingURL=generated.d.ts.map